Principles of Programming Languages - Module 5

Module 5      
Elementary Data Type

A data type is a class of data objects together with a set of operations for creating and manipulating them.

An elementary data object contains a single data value.  A class of such data objects over which various operations are defined is termed an elementary data type.

The basic elements of a specification of an elementary data type are as follows:
1. Attributes that distinguish data objects of that type. 
2. Values  that data objects of that type may have.  The type of a data object determines the set of possible(maximum) values that it may contain.  The set of values defined by an elementary data type is usually an ordered set with a least value and a greatest value; for any pair of distinct values, one is greater than the other.
3. Operations that define the possible manipulations of data objects of that type.  They may be  primitive which means that they are specified as part of the language definition, or they may be programmer-defined operations, in the form of subprograms or method declarations as part of class definitions.  Examples: integer addition, the use of the equal symbol to test equality, square-root operation

Implementation of Elementary Data Types

The implementation of an elementary data type consists of a storage representation for data objects and values of that type, and a set of  algorithms  or  procedures that define the operations of the type in terms of manipulations of the storage representation.

Storage Representation

Storage for elementary data types is strongly influenced by the under lying computer that will execute the program.  For example, the storage representation for integer or real values is almost always the integer or floating-point binary representation for numbers used in the underlying hardware.

The representation of a data object is ordinarily independent of its location in memory.  The storage representation is usually described in terms of the size of the block of the memory required(the number of memory words, bytes, or bits needed) and the layout of the attributes and data values within its block.  Usually the address of the first word or byte of such a block of memory is taken to represent the location of the data object.

Implementation of operations

Each operation defined for data objects of a given type may be implemented in one of three main ways:
1. Directly as hardware operation.  For example, if integers are stored using hardware representation for integers, then addition and subtraction are implemented using the arithmetic operations built into the hardware.
2.  As a procedure or function subprogram.  For example, a square-root operation is usually not provided directly as hardware operation.  It might be implemented as a square-root subprogram that calculates the square root of its argument.
3. As an inline code sequence.  An inline code sequence is also a software implementation of the operation.  However, instead of using a subprogram, the operations in the subprogram are copied into the program at the point where the subprogram would otherwise have been invoked.  For example, the absolute-value function  on numbers,  defined by  abs(x) = if x < 0 then -x else x is usually implemented as an inline code sequence:
a.  Fetch value of x from memory.
b.  If x > 0, skip the next instruction.
c.  Set x = -x.
d. Store new value of x in memory.
Each line is implemented by a single-hardware operation.

Declaration

A declaration  is a program statement that serves to communicate to the language translator information about the name and type of data objects needed during program execution.  By its placement in the program (e.g. within a particular subprogram or class definition), a declaration may also serve to indicate the desired lifetimes of the data objects.

Sample declarations of some programming languages:

• The C declaration float A, B; at the start of a subprogram indicates that two data objects of type float are needed during execution of the subprogram.  This is an example of an explicit declaration.
• FORTRAN is a programming language that provides implicit or default declarations, which are declarations that hold when no explicit declaration is given.  The variable INDEX may be used without explicit declaration; it is assumed by the compiler to be an integer variable because its name begins with one of  the letters I-N. 
• In Perl, simply assigning a value to a variable declares  the type of the variable
Examples:  $MyVar = 'This is a string'    # $MyVar is now a string variable
      $MyVar = 890                   # $MyVar is now an integer variable

The most important purpose for declarations, from the programmer's viewpoint, is that they allow for static rather than dynamic type checking.

Data storage representations that are built into the computer hardware usually include no type information, and the primitive operations on the data do no type checking.  For example, a particular word in the computer memory during execution of a program may contain the bit sequence 101010010100…1001 may represent an integer, a real  number, a sequence of characters, or an instruction.  The hardware primitive operation for integer addition cannot check whether its two arguments represents integers; they are simply bit sequences.  At the hardware level, conventional computers are particularly unreliable in detecting data type errors.

Type checking means the checking that each operation executed by a program receives the proper number of arguments of the proper data types.  For example given the expression X = A + B * C, the compiler must determine for each operation(addition, multiplication, and assignment) that each receives two arguments of the proper data type.

Type checking may be done at run time (dynamic type checking) or at compile time (static type checking).

Dynamic type checking  is run-time type checking usually performed immediately before the execution of a particular operation.  It is usually implemented by storing  a type tag in each data object that indicates the data type of the object.  For example, an integer data object would contain both the integer value and an integer type tag.

Scalar Data Types

Scalar data objects have a single attribute for its data object.  For example, an integer object has an integral value (ex. 130, -90, 12), and no other information can be obtained from that object.  They also follow the hardware architecture of a computer (e.g. integers, floating-points, characters).

Integers

The set of integer values defined for the type forms an ordered subset, within some finite bounds, of the infinite set of integers studied in mathematics.  The maximum integer value is sometimes represented as a defined costant.

Operations on these data objects include:
• Arithmetic
• Relational
• Assignment
• Bit

Floating-Point Real Numbers

A floating-point real number data type is often specified with only the single data type  attribute real, as in ForTran, or float, as in C.  The values form an ordered sequence from some hardware-determined minimum negative value to a maximum value, but the values are not distributed evenly across this range.  The precision required for floating-point numbers, in terms of the number of digits used in the decimal representation, may be specified by the programmer.

Operations on these data objects include:
• Arithmetic
• Relational
• Assignment
• Bit

Boolean operations on these objects are sometimes restricted.  Due to roundoff issues, equality between two real numbers is rarely achieved.

Fixed-Point Real Numbers

Data objects like money which contains pesos and cents, and other values which are rational that requires two or specific number of decimal places, should not be written as integers or floating-point values to avoid roundoff errors.  Thus, a form of fixed-point data should be used to represent these values.

A fixed number is represented as a digit sequence of fixed length, with the decimal point positioned at a given point between two digits.

Complex numbers

This numeric data type consists of a pair of numbers representing the number's real and imaginary parts.

Rational Numbers

A rational number is the quotient of two integers.  It is included in a programming language to avoid the problems of roundoff and truncation encountered in floating and fixed point representations of reals.

Enumerations

An ordered list of distinct values is called an enumeration.  Languages such as C, and C++ include an enumeration data type that allows the programmer to define and manipulate such variables more directly.

Below is sample program that uses the enum data type:

#include
#include
#include

void main()
{
enum x {One, Two, Three};
x y = Three;
clrscr();
if (y == 2)
cout << "Three"<< endl;
getch();
}

Booleans

Most languages provide a data type for representing true or false, usually called a Boolean or logical data type.

The most common operations on Boolean types include assignment as well as the following logical operations:
• And - Conjunction
• Or - Inclusive disjunction
• Not - Negation or complement

Characters

A character data type provides data objects that have a single character as their value.   The set of possible character values is usually taken to be a language-defined enumeration corresponding to the standard character sets supported by the underlying hardware and operating system, such as the ASCII character set. 

The ordering of the characters in this character set is called the collating sequence for the character set. Collating sequence is important because it determines the alphabetical ordering given to character strings by the relational operations.  Spaces, digits, and special characters may be alphabetized as well.

Operations include:

• Relational
• Assignment
• Testing whether a character value is one of the special classes letter, digit, or special character

Composite Data Types
Elementary data types may involve a complex data structure organization by the compiler.  Thus, multiple attributes  are often given for each such data type.

Character Strings

These are objects that composed of a sequence of characters.

There are at least three different treatments of character-string data types :

• Fixed declared length.  A character-string data object may have a fixed length that is declared in the program.
• Variable length to a declared bound.  A character-string data object may have a maximum length that is declared in the prior program, but the actual value stored in the data object may be a string  of shorter length-possibly even the empty string of no characters.
• Unbounded length.  A character-string data object may have a string value of any length, and the length may vary dynamically during execution  with no bound (beyond available memory).

Operations on Strings:
• Concatenation - an operation of joining two character strings to make one long string
• Relational operations on strings - use of logical operators like the less than, greater than symbols, etc.
• Substring selection using positioning subscripts - extracting substrings through positioning subscripts
• Input-output formatting - formatting of strings when read or displayed
• Substring selection using pattern matching - - extracting substrings through pattern matching
• Dynamic strings - The language Perl supports static and dynamic strings.  The string '$ABC' is static, and the statement print '$ABC'; will print the value $ABC.  The string "$ABC" is dynamic and the statement print "$ABC"; will cause the string to be evaluated, and the value of the Perl variable $ABC is printed instead.

Pointers

A pointer is also called a reference or access type.  It contains the location of another data object or may contain the null pointer, nil or null.  Pointers are ordinary data objects that may be simple variables or components of arrays and records.

Files and Input-Output

A file  is a data structure with two special properties:
1. It ordinarily is represented on a secondary storage device such as a disk or tape and thus may be much larger than the most data structures of other types.
2. Its lifetime may encompass a greater span of time than that of the program creating it.

Sequential Files

These are the most common type of file.  It is a data structure composed of a linear sequence of components of the same type.
Operations

• Open - this operation ordinarily requests information from the operating system about the location and properties of the file, allocates the required internal storage for buffers and other information, and sets the file-position pointer to the first component of the file.
• Read - this operation transfers the contents of the current file component to a designated variable in the program
• Write - this operation creates a new component at the current position in the file(always at the end) and transfers the contents of a designated program variable to the new component.
• End-of-file test - A read operation fails if the file position pointer designates the end of the file.  Because the file is of variable length, an explicit test for the end-of-file position is needed so that the program may take special action.
• Close - this operation involves notification to the operating system that the file can be detached from the program (and potentially made available to other programs) and possibly also deallocation of internal storage used for the file (such as buffers and buffer variables) (Pratt, and Zelkowitz, 2001)

Principles of Programming Languages - Module 4

Module 4  Names, Bindings, Type Checking and Scopes

Names

One of the fundamental attributes of variables is names, which have broader use than simply for variables.  They are also associated with labels, subprograms, formal parameters, and other program constructs.  The term identifier is often used interchangeably with name.

Name forms

A name is a string of characters used to identify some entity in a program.  The earliest programming languages used single-character names.  This was natural because early programming was primarily mathematical, and mathematicians have long used single-character names for unknowns in their formal notations.

A programming language has a maximum length of a name. For example, FORTRAN 90 and C allow up to 31 characters. Ada names have no length limit.  Some languages like C++, do not specify a length limit on names.

The commonly acceptable name form is a string with a reasonably long length limit, if any, with some connector character such as the underscore(_) included.  The underscore serves the same purpose as a space in English text but without terminating the name string in which it is placed.

In some languages, like C, C++, and Java, uppercase and lowercase letters in names are distinct; that is, names in these languages are case sensitive.

Special Words

Special words in programming languages are used to make programs more readable by naming actions to be performed.  They are  used to separate the syntactic entities of programs.  In most languages, these words are classified as reserved words, but in some they are only keywords.

A keyword is a word of a programming language that is special only in certain contexts.  A reserved word is a special word  of a programming language that cannot be used as a name.  As a language design choice, reserved words are better than keywords because the ability to redefine keywords can lead to readability problems.

Variables

A program variable is an abstraction of a computer memory cell or collection of cells.  Programmers often think of variables as names for memory locations, but there is much more to a variable than just a name.  A variable can be characterized as a sextuple of attributes: (name, address, value, type, lifetime, scope).
Address

The address of a variable is the memory address with which it is associated.  It is sometimes called its l-value, because that is what is required when a variable appears in the left side of an assignment statement.

Aliases

It is possible to have multiple identifiers reference the same address.  When more than one variable name can be used to access a single memory location, the names are called aliases.  Aliasing is a hindrance to readability because it allows  a variable to have its value changed by an assignment to a different variable.

Type

The type of a variable determines the range of values the variable can have and the set of operations that are defined for values of the type.

Value

The value of a variable is the contents of the memory cell or cells associated with the variable.  It is convenient to think of computer memory in terms of abstract cells, rather than physical cells.  It is sometimes called the variable's r-value because it is what is required when the variable is used on the right side of an assignment statement.


Bindings

Binding is an association such as between an attribute and an entity or between an operation and a symbol.  The time at which a binding takes place is called binding time. Bindings can take place at language design time, language implementation time, compile time, link time, load time, or load time. 

Examples:
• The asterisk symbol(*) is usually bound to the multiplication operation at language design time.
• A variable in C or C++ program is bound to as particular data type at compile time.
• A variable may be bound to a storage cell when the program is loaded to the memory
• A call to a library subprogram is bound to the subprogram code at link time.

Given some lines of a C++ program:

int iCt;
…
iCt = iCt + 1;

Some of the bindings and their binding times for the parts of this assignment statement are as follows:
• Set of possible types for iCt:  bound at language design time.
• Type of count:  bound at compile time.
• Set of possible values of iCt: bound at compiler design time.
• Value of iCt: bound at execution time with this statement.
• Set of possible meanings for the operator symbol +:  bound at language definition time.
• Meaning of the operator symbol + in this statement:  bound at compile time.
• Internal representation of the literal 1:  bound at compiler design time.

A binding is static if it occurs before run time and remains unchanged throughout program execution.  If it occurs during run time or can change in the program execution, it is called dynamic.

Type Bindings

Before a variable can be referenced in a program, it must be bound to a data type.  The two important aspects of this binding are (1) how the type is specified and (2) when the binding takes place.

Forms of Variable Declaration
1. Explicit declaration - a statement in a program that lists variable names and specifies that they are a particular type.
2. Implicit declaration - a means of associating variables with types  through default conventions instead of declaration statements.

The first appearance of a variable name in a program constitutes its implicit declaration.  Both explicit and implicit declarations create static binding to types.

Dynamic Type Binding

With dynamic type binding, the type is not specified by a declaration statement.  Instead, the variable is bound to a type when it is assigned a value in an assignment statement. When the assignment statement is executed, the variable being assigned is bound to the type of the value, variable, or expression on the right side of the assignment.

One of its advantages is that it provides a great deal of programming flexibility.  With dynamic type binding, one can deal with data of any type.

Dynamic type binding has also disadvantages. One of these is the error detection capability of the compiler is diminished relative to a compiler for a language with  static type bindings, because any two types can appear on opposite sides of the assignment operator.  Incorrect types of right sides of assignments are not detected as errors; rather, the type of the left side is simply changed to the incorrect type.

Type Inference

For programming languages like ML, Miranda, and Haskell, with type inference, the types of most expressions can be determined without requiring the programmer to specify the types of the variables

Type Checking

When dealing with type checking, one has to consider the following:
1. Subprograms will be taken as operators whose operands are their parameters;
2. The assignment symbol will be thought of  as a binary operator, with its target variable and its expression being the operands.

Type checking is the activity of ensuring that the operands of an operator are of compatible types.  A compatible type is one that is either legal for the operator or is allowed under language rules to be implicitly converted by compiler-generated code to a legal type which is known as coercion.  A type error is the application of an operator to an operand of an inappropriate type.

Strong Typing

This is one of the new ideas in language design that became prominent in the so-called structured programming revolution of the 1970s. A strongly typed language is one in which each name in a program in the language has a single type associated with it, and that type is known at compile time.  A programming language is considered strongly typed if type errors are always detected.  The importance of strong typing lies in its ability to detect all misuses of variables that result in type errors.  Languages like FORTRAN, C and C++ are not strongly typed.  Examples of programming languages that are nearly strongly typed are Pascal and Ada.  Languages like ML and Java are strongly typed.

Type Compatibility

The design of the type compatibility rules of a language is important, because it influences the design of the data types and operations provided for values  of those types.

Two different type compatibility methods:
1. Name compatibility -  this means that two variables have compatible types only if they are  in either the same declaration or in declarations that use the same type name.
2. Structure compatibility - this means that two variables have compatible types if their types have identical structures.

Scope

One of the most important factors having an effect on the understanding of variables is scope.  The scope of a program variable is defined as the range of statements in which the variable is visible.  A variable is visible in a statement if it can be referenced in that statement  A variable is local in a program unit or block if it is declared there.  The nonlocal variables of a program unit or block are those that are visible within the program unit or block but are not declared there. (Sebesta)

Principles of Programming Languages - Module 3

Module 3 Describing Syntax  and Semantics

The study of programming languages, like the study of natural languages, can be divided into examinations of syntax and semantics.  The syntax of a programming language is the form of its expressions, statements, and program units.  Its semantics is the meaning of those expressions, statements, and program units.  For example, the syntax of a C if  statement is if () .  The semantics of this statement form is that if the current value of the expression is true, the embedded statement is selected for execution.

Syntax and semantics are closely related.  In a well-designed programming language, semantics, should follow directly from syntax; that is, the form of statement should strongly suggest what the statement is meant to accomplish.

Languages, whether natural (such as English) or artificial (such as Java), are sets of strings of characters from some alphabet.  The strings of a language are called sentences or statements.  The syntax rules of a language specify which strings of characters from the language's alphabet are in the language. 

Formal descriptions of the syntax of programming languages, often do not include descriptions of the lowest level syntactic units.  These small units are called lexemes.  The lexemes of a programming language include its identifiers, literals, operators, and special words.

A  token  of a language is a category of its lexemes.  An identifier is a token that can have lexemes, or instances.  In some cases, a token has only a single possible lexeme. 

For example:

Given  the C statement:  index = 2 * count + 20;

The lexemes and tokens of this statement

Lexemes        Tokens
index              identifier
=                     equal_sign
2                     int_literal
*                      mult_op
count              identifier
+                     plus_op
20                   int_literal
;                      semicolon

A Grammar for Simple Assignment Statements

Given:   a = b * ( a + c )

    =
      a =
                    a = *
                    a = b *
                    a = b * ( )
                    a = b * ( + )
                    a = b  * ( a + )
                    a = b * ( a +
                    a = b *  ( a + c)

Parse Trees

One of the most attractive features of grammars is that they naturally describe the hierarchical syntactic structure of the sentences of the languages they define.  These structures are called parse trees.

Given: a = b * ( a + c )

Ambiguity

A grammar that generates a sentence for which there are two or more distinct parse trees is said to be ambiguous.

Given: a = b *  a + c
Note:  The parse tree will be supplied by the teacher in class.

Operator Precedence

A parse tree of a sentence with multiple operators, regardless of the particular operators involved, has the rightmost operator in the expression at the lowest point in the parse tree, with the other operators in the tree moving progressively higher as one moves to the left in the expression. 

Static Semantics

The static semantics of a language is only indirectly related to the meaning of programs during execution; rather, it has to do with the legal forms of programs (syntax rather than semantics).  In many cases, the static semantic rules of a language state its type constraints.  Static semantics is so named because the analysis required to check these specifications can be done at compile time.

Denotational Semantics

This is the most rigorous widely know method for describing the meaning of programs.  The fundamental concept of denotational semantics is to define for each language entity both a mathematical object and a function that maps instances of that entity onto instances of the   mathematical object.

Principles of Programming Languages - Module 2

Module 2

Levels of Programming Languages, Programming Domains, Language Evaluation Criteria

Levels of Programming Languages

Programming languages were invented to make machines easier to use.  They thrive because they make problems easier to solve.

The informal term level  is useful for gross distinctions between languages.  Levels of readability for programs are analogous to levels of readability for English text.

Machine Language

Machine computations are low level, full of details that have more to do  with the inner workings of the machine than with what the computation is for.  A typical machine-level operation might add numbers or compare characters.

Machine language is the native language of a computer; it is the notation to which  the computer responds directly. The term code originally referred to machine language, although code is now used more broadly to refer to any program text.

Programs in machine language are usually unintelligible at the lowest level, the most detailed level, since they consist only of 0s and 1s.

Assembly language is a variant of machine language in which names and symbols take the place of the actual codes for machine operations, values, and storage locations, making individual instructions more readable.

High-level Language

A language is a high-level language if it is independent of the underlying machine.  They have replaced machine and assembly language in virtually all areas of programming, because they provide benefits like the following:

a. Readable familiar notations
b. Machine independence
c. Availability of program libraries
d. Consistency checks during implementation that can detect errors

Portability is another term for machine independence; a language is portable if programs in the language can be run on different machines with little or no change. (Sethi, R.)

Programming Domains

Computers have been applied to a myriad of different areas, from controlling nuclear power plants to storing the records of personal checkbooks.  Because of this great diversity in computer use, programming languages with very different goals have been developed.

Scientific Applications

Typically, scientific applications have simple data structures but require large numbers of floating-point arithmetic computations.  The most common data structures are arrays and matrices; the most common control structures are counting loops and selections.  Examples of these languages are FORTRAN and ALGOL 60.

Business Applications

Business languages are characterized by facilities for producing elaborate reports, precise ways of describing and storing decimal numbers and character data, and the ability to specify decimal arithmetic operations.

With the advent of microcomputers came new ways for businesses, especially small businesses, to use computers.  Two specific tools that can be used on small computers, spreadsheet systems and database systems, were developed for business and now are widely used.  The COBOL language belongs to this category.

Artificial Intelligence

This is a broad area of computer applications characterized by the use of symbolic rather than numeric computations. Symbolic computation means that symbols, consisting of names rather than numbers, are manipulated.  Also, symbolic computation is more conveniently done with linked lists of data rather than arrays.  This kind of programming sometimes requires more flexibility  than other programming domains.  The functional language LISP and the ProLog which supports logic programming belong to this group.

Systems Programming

The OS and all of the programming support tools of a computer system are collectively known as its systems software.  Systems s/w is used almost continuously and therefore must have execution efficiency.  A language for this domain must provide fast execution.  It should have low-level features that allow the s/w interfaces to external devices to be written.  Examples of this softwares are PL/1, BLISS, Extended ALGOL, and UNIX.


Scripting Languages

A scripting language is used by putting a list of commands, called a script, in a file to be executed.  sh (for shell) was the first of these languages.  It began as a small collection of commands that were interpreted as calls to system subprograms that performed utility functions, such as file management and simple file filtering.    To these basis were added variables, control flow statements, functions, and various other capabilities, and the result is a complete programming language.  As a result, ksh was developed by David Korn at Bell Laboratories.

awk is another scripting language, developed by Al Aho, Brian Kernighan, and Peter Wienberger at Bell Laboratories.  It began as a report-generation language but later became a more general purpose language.

tcl is an extensible scripting language developed by John Outsterhout at the University of California at Berkeley.  Today, tcl is combined with tk,  a language that provides a method of building X Window application. 

The Perl  language, developed by Larry Wall, was originally a combination of sh and awk.  Since the advent of the WWW, the popularity of Perl has risen dramatically, primarily because it is a nearly  ideal language for CGI(Common Gateway Interface) programming.

Special-Purpose Languages

They range from RPG, which is used to produce business reports, to APT, which is used for instructing programmable machine tools, to GPSS, which is used for systems simulation.

Language Evaluation Criteria

A.  Readability

One of the most important criteria for judging a programming language is the ease with which the programs can be read and understood. Readability must be considered in the context of the problem domain. For example, if a program that describe a computation was written in a language not desired for use, the program may be unnatural and convoluted, making it unusually difficult to read.

B.  Writability. 
Is a measure of how easily a langaueg can be used to create programs for a chosen problem domain.

C.  Reliability. 
A program is said to be reliable if it performs to its specifications under all conditions.
   
D.  Cost . 
The ultimate total cost of a programming language is a function of many of this characteristics.  First, there is the cost of training programmers to use the language.  Second is the cost of writing programs in language. Third is the cost of compiling programs in the language. Fourth, the cost of executing programs written in language is greatly influenced by that language's design.

Principles of Programming Languages - Module 1

Module 1
Defining Programming Languages

• A tool for instructing machines
• A means for communicating between programmers
• A vehicle for expressing high-level designs
• A notation for algorithms - they are used for specifying, organizing and reasoning about computations
• A way of expressing relationships between concepts
• A tool for experimentation
• A means of controlling computerized devices (Sethi, R.)

Reasons for Studying Concepts of Programming Languages

• Increased capacity to express ideas - it is widely believe that the depth at which we can think is influenced by the expressive power of language in which we communicate our thoughts. Awareness of a wider variety of programming language features can reduce such limitations in software development. Programming can increase the range of their software-development process by learning new language constructs.
• Improved background for choosing appropriate languages - Many professional programmers have had little education in computer science; rather they have learned programming on their own thought in-house training programs. Such training programs often teach one or two languages that are directly relevant to the current work of the organization. Many other programmers received their formal training in the distant past.
• Increased ability to learn new languages - Computer programming is a young discipline, and design methodologies, software development tools, and programming languages are still in the state of continuous evolution. This makes systems development exciting profession, but it also means that continuous learning is essential.
• Better understanding of the significance of implementation - In learning the concepts of programming languages, it is both interesting and necessary to touch on the implementation issues that affect those concepts. In some cases, understanding of implementation issues leads to understanding of why languages are designed the way they are. This in turn leads to the ability to use a language more intelligently, as it was designed to be used. We can become better programmers by understanding the choices among programming languages construct and the consequences of those choice.
• Increased ability to design new languages - to a student, the possibility of being required at some future time to design a new programming language may seem remote. However, most professional programmers occasionally do design languages of one sort or another.
• Overall advancement of computing - Finally, there is a global view of computing that can justify the study of programming language concept. Although it is usually possible to determine why a particular programming language become popular, it is not always clear, at least in retrospect that the most popular programming languages are the best available. (Sebesta, R.)