Evolution of the Major Programming languages,Handouts

Handouts

Evolution of the Major Programming languages




Ada (After Ada Lovelace) A Pascal-descended language, designed by Jean Ichbiah's team at CII Honeywell in 1979, made mandatory for Department of Defense software projects by the Pentagon. The original language was standardized as "Ada 83", the latest is "Ada 95".


Ada is a large, complex, block-structured language aimed primarily at embedded applications. It has facilities for real-time response, concurrency, hardware access and reliable run-time error handling. In support of large-scale software engineering, it emphasizes strong typing, data abstraction and encapsulation. The type system uses name equivalence and includes both subtypes and derived types. Both fixed and floating-point numerical types are supported.



Control flow is fully bracketed: if-then-elsif-end if, case-is-when-end case, loop-exit-end loop, goto. Subprogram parameters are in, out, or inout. Variables imported from other packages may be hidden or directly visible. Operators may be overloaded and so may enumeration literals. There are user-defined exceptions and exception handlers.



An Ada program consists of a set of packages encapsulating data objects and their related operations. A package has a separately compilable body and interface. Ada permits generic packages and subroutines, possibly parametrised.



Ada support single inheritance, using "tagged types" which are types that can be extended via inheritance.



Ada programming places a heavy emphasis on multitasking. Tasks are synchronised by the rendezvous, in which a task waits for one of its subroutines to be executed by another. The conditional entry makes it possible for a task to test whether an entry is ready. The selective wait waits for either of two entries or waits for a limited time.



Ada is often criticised, especially for its size and complexity, and this is attributed to its having been designed by committee. In fact, both Ada 83 and Ada 95 were designed by small design teams to be internally consistent and tightly integrated. By contrast, two possible competitors, Fortran 90 and C++ have both become products designed by large and disparate volunteer committees.



ALGOL A portable language for scientific computations. ALGOL 60 was small and elegant. It was block-structured, nested, recursive and free form. It was also the first language to be described in BNF.



There were three lexical representations: hardware, reference, and publication. The only structured data types were arrays, but they were permitted to have lower bounds and could be dynamic. It also had conditional expressions; it introduced :=; if-then-else; very general "for" loops; switch declaration (an array of statement labels generalizing Fortran's computed goto). Parameters were call-by-name and call-by-value. It had static local "own" variables. It lacked user-defined types, character manipulation and standard I/O.



APL (A Programming Language) A language designed originally by Ken Iverson at Harvard University in 1957-1960 as a notation for the concise expression of mathematical algorithms. It went unnamed (or just called Iverson's Language) and unimplemented for many years. Finally a subset, APL\360, was implemented in 1964.



APL is an interactive array-oriented language with many innovative features. It was originally written using a non-standard character set but now can use ISO8485. It is dynamically typed with dynamic scope. APL introduced several functional forms but is not purely functional.



Dijkstra got the size of it when he said that APL was a language designed to perfection - in the wrong direction. IBM once adopted APL - can one be ruder?



Versions: APL\360, APL SV, VS APL, Sharp APL, Sharp APL/PC, APL*PLUS, APL*PLUS/PC, APL*PLUS/PC II, MCM APL, Honeyapple, and DEC APL.



B A systems language written by Ken Thompson in 1970 mostly for his own use under Unix on the PDP-11. B was later improved by Kerninghan(?) and Ritchie to produce C. B was used as the systems language on Honeywell's GCOS-3.



B was, according to Ken, greatly influenced by BCPL, but the name B had nothing to do with BCPL. B was in fact a revision of an earlier language, bon, named after Ken Thompson's wife, Bonnie.



BASIC Beginner's All-purpose Symbolic Instruction Code. A simple language designed by John G. Kemeny and Thomas E. Kurtz at Dartmouth College in 1963. It first ran on an IBM 704 on 1964-05-01. It was designed for quick and easy programming by students and beginners. BASIC exists in many dialects, and is popular on microcomputers with sound and graphics support. Most micro versions are interactive and interpreted, but the original Dartmouth BASIC was compiled.



BASIC was originally designed for Dartmouth's experimental time-sharing system and has since become the leading cause of brain-damage in proto-hackers. This is another case (like Pascal) of the cascading lossage that happens when a language deliberately designed as an educational toy gets taken too seriously. A novice can write short BASIC programs (on the order of 10--20 lines) very easily; writing anything longer is (a) very painful, and (b) encourages bad habits that will make it harder to use more powerful languages well. This wouldn't be so bad if historical accidents hadn't made BASIC so common on low-end micros. As it is, it ruins thousands of potential wizards a year.



Originally, all references to code, both GOTO and GOSUB (subroutine call) referred to the destination by its line number. This allowed for very simple editing in the days before text editors were considered an essential tool on every computer. Just typing the line number deleted the line and to edit a line you just typed the new line with the same number. Programs were typically numbered in steps of ten to allow for insertions. Later versions, such as BASIC V, allow GOTO-less structured programming with named procedures and functions, IF-THEN-ELSE-ENDIF constructs and WHILE loops etc.



Early BASICs had no graphic operations except with graphic characters. In the 1970s BASIC interpreters became standard features in mainframes and minicomputers. Some versions included matrix operations as language primitives.



BCPL (Basic CPL) A British systems language developed by Richards in 1969 and descended from CPL (Combined Programming Language). BCPL is low-level, typeless and block-structured, and provides only one-dimensional arrays. Case is not significant, but conventionally reserved words begin with a capital. Flow control constructs include: If-Then, Test-Then-Else, Unless-Do, While-Do, Until-Do, Repeat, Repeatwhile, Repeatuntil, For-to-By-Do, Loop, Break and Switchon-Into-Case-Default-Endcase. BCPL has conditional expressions, pointers, and manifest constants. It has both procedures: 'Let foo(bar) Be command' and functions: 'Let foo(bar) = expression'. 'Valof $(..Resultis..$)' causes a compound command to produce a value. Parameters are call-by-value.



Program segments communicate via the global vector where system and user variables are stored in fixed numerical locations in a single array.



The first BCPL compiler was written in AED. BCPL was used to implement the TRIPOS operating system, which was subsequently reincarnated as AmigaDOS.



BLISS Basic Language for Implementation of System Software. (BLISS, or allegedly, "System Software Implementation Language, Backwards") A language designed by W.A. Wulf at CMU around 1969.



BLISS is an expression language. It is block-structured, and type-less, with exception handling facilities, co-routines, a macro system, and a highly optimizing compiler. It was one of the first non-assembly languages for operating system implementation. It gained fame for its lack of a goto and also lacks implicit dereferencing: all symbols stand for addresses, not values.



Versions: CMU BLISS-10 for the PDP-10; CMU BLISS-11, DEC BLISS-32 for VAX/VMS.



C A programming language designed by Dennis Ritchie at AT&T Bell Labs ca. 1972 for systems programming on the PDP-11 and immediately used to reimplement Unix.



It was called "C" because many features derived from an earlier compiler named "B". In fact, C was briefly named "NB". B was itself strongly influenced by BCPL. Before Bjarne Stroustrup settled the question by designing C++, there was a humorous debate over whether C's successor should be named "D" or "P" (following B and C in "BCPL").



C is terse, low-level and permissive. It has a macro preprocessor, cpp.



Partly due to its distribution with Unix, C became immensely popular outside Bell Labs after about 1980 and is now the dominant language in systems and microcomputer applications programming. It has grown popular due to its simplicity, efficiency, and flexibility. C programs are often easily adapted to new environments.



C is often described, with a mixture of fondness and disdain, as "a language that combines all the elegance and power of assembly language with all the readability and maintainability of assembly language".



Ritchie's original C, known as K&R C after Kernighan and Ritchie's book, has been standardized (and simultaneously modified) as ANSI C.



C++ One of the most used object-oriented languages, a superset of C developed primarily by Bjarne Stroustrup  at AT&T Bell Laboratories in 1986.



In C++ a class is a user-defined type, syntactically a struct with member functions. Constructors and destructors are member functions called to create or destroy instances. A friend is a nonmember function that is allowed to access the private portion of a class. C++ allows implicit type conversion, function inlining, overloading of operators and function names, and default function arguments. It has streams for I/O and references.



C++ 2.0 (May 1989) introduced multiple inheritance, type-safe linkage, pointers to members, and abstract classes.



C++ 2.1 was introduced in ["Annotated C++ Reference Manual", B. Stroustrup et al, A-W 1990].



COBOL COmmon Business Oriented Language. A programming language for simple computations on large amounts of data designed by the CODASYL Committee in April 1960. It is the most widely used programming language of its today. The natural language style is intended to be largely self-documenting. It introduced the record structure.



Major revisions in 1968 (ANS X3.23-1968), 1974 (ANS X3.23-1974) and 1985.



For many hackers, COBOL is synonymous with evil, for being a weak, verbose, and flabby language used by card wallopers to do boring mindless things on dinosaur mainframes. Many believe that all COBOL programmers are suits or code grinders, and would never admit to having learned the language. However, as most haven't indeed, their judgment is somewhat questionable.



CPL (Combined Programming Language) A very complex language, syntactically based on ALGOL 60, with a pure functional subset. Provides the ..where.. form of local definitions. Strongly typed but has a "general" type enabling a weak form of polymorphism. Functions may be defined as either normal or applicative order. Typed array and polymorphic list structures. List selection is through structure matching. Partially implemented on the Titan (Atlas 2) computer at Cambridge. Led to the much simpler BCPL. "The Main Features of CPL", D.W. Barron et al, Computer J 6(2):134-143 (Jul 1963).



Eiffel An object-oriented language produced by Bertrand Meyer in 1985. Eiffel has classes with multiple inheritance and repeated inheritance, deferred classes (like Smalltalk's abstract class), and clusters of classes. Objects can have both static types and dynamic types. The dynamic type must be a descendant of the static (declared) type. Dynamic binding resolves multiple inheritance clashes. It has flattened forms of classes, in which all of the inherited features are added at the same level and generic classes parametrized by type.



Other features are persistent objects, garbage collection, exception handling, foreign language interface. Classes may be equipped with assertions (routine preconditions and post-conditions, class invariants) implementing the theory of "Design by Contract" and helping produce more reliable software.



Eiffel is compiled to C. It comes with libraries containing several hundred classes: data structures and algorithms (EiffelBase), graphics and user interfaces (EiffelVision) and language analysis (EiffelLex, EiffelParse).



The first release of Eiffel was release 1.4, introduced at the first OOPSLA in October 1986. The language proper was first described in a University of California, Santa Barbara report dated September 1985.



Eiffel is available, with different libraries, from several sources including Interactive Software Engineering, USA (ISE Eiffel version 3.3); Sig Computer GmbH, Germany (Eiffel/S); and Tower, Inc., Austin (Tower Eiffel).



The language definition is administered by an open organization, the Nonprofit International Consortium for Eiffel (NICE). There is a standard kernel library.



FORTRAN (Formula Translation) The first and, for a long time, the most widely used programming language for numerical and scientific applications. The original versions lacked recursive procedures and block structure and had a line-oriented syntax in which certain columns had special significance. There have been a great many versions.



The name is often written "FORTRAN", harking back to the days before computers were taught about lower case, but ANSI decreed (circa. 1985 via the ANSI FORTRAN Technical Committee TC that it should be "Fortran".



ICON A descendant of SNOBOL4 with Pascal-like syntax, produced by Griswold in the 1970's. Icon is a general-purpose language with special features for string scanning. It has dynamic types: records, sets, list, strings, and tables. It has some object-oriented features but no modules or exceptions. It has a primitive Unix interface.



The central theme of Icon is the generator: when an expression is evaluated it may be suspended and later resumed, producing a result sequence of values until it fails. Resumption takes place implicitly in two contexts: iteration that is syntactically loop-like ('every-do'), and goal-directed evaluation in which a conditional expression automatically attempts to produce at least one result. Expressions that fail are used in lieu of Booleans. Data backtracking is supported by a reversible assignment. Icon also has co-expressions, which can be explicitly resumed at any time.



Java (After the Indonesian island, a source of programming fluid) A simple, object-oriented, distributed, interpreted, robust, secure, architecture-neutral, portable, multithreaded, dynamic, buzzword-compliant, general-purpose programming language developed by Sun Microsystems in 1995(?). Java supports programming for the Internet in the form of platform-independent Java "applets".



Java is similar to C++ without operator overloading (though it does have method overloading), without multiple inheritance, and extensive automatic coercions. It has automatic garbage collection.



Java programs can run stand-alone on small computers. The interpreter and class support take about 40 kilobytes; adding the standard libraries and thread support (essentially a self-contained microkernel) adds an additional 175Kb.



Java extends C++'s object-oriented facilities with those of Objective C for dynamic method resolution.



Java has an extensive library of routines for TCP/IP protocols like HTTP and FTP. Java applications can access objects across the Internet via URLs as easily as on the local file system.



The Java compiler and linker both enforce strong type checking - procedures must be explicitly typed. Java supports the creation of virus-free, tamper-free systems with authentication based on public-key encryption.



The Java compiler generates an architecture-neutral object file executable on any processor supporting the Java runtime system. The object code consists of bytecode instructions designed to be both easy to interpret on any machine and easily translated into native machine code at load time.



The Java libraries provide portable interfaces. For example, there is an abstract Window class and implementations of it for Unix, Microsoft Windows and the Macintosh. The runtime system is written in POSIX-compliant ANSI C. Java applets can be executed as attachments in World-Wide Web documents using either Sun's HotJava browser, Netscape Navigator, or Microsoft Internet Explorer.



LISP LISt Processing language. (Or mythically "Lots of Irritating Superfluous Parentheses"). Artificial Intelligence's mother tongue, a symbolic, functional, recursive language based on the ideas of lambda-calculus, variable-length lists and trees as fundamental data types and the interpretation of code as data and vice-versa.



Data objects in Lisp are lists and atoms. Lists may contain lists and atoms. Atoms are either numbers or symbols. Programs in Lisp are themselves lists of symbols which can be treated as data. Most implementations of Lisp allow functions with side-effects but there is a core of Lisp which is purely functional.



All Lisp functions and programs are expressions that return values; this, together with the high memory use of Lisp, gave rise to Alan Perlis's famous quip (itself a take on an Oscar Wilde quote) that "Lisp programmers know the value of everything and the cost of nothing".



The original version was LISP 1, invented by John McCarthy   at MIT in the late 1950s. Lisp is actually older than any other high level language still in use except Fortran. Accordingly, it has undergone considerable change over the years. Modern variants are quite different in detail. The dominant HLL among hackers until the early 1980s, Lisp now shares the throne with C.



One significant application for Lisp has been as a proof by example that the newest languages, such as COBOL and Ada, are full of unnecessary crocks. When the Right Thing has already been done once, there is no justification for bogosity in newer languages.



Modula (MODUlar Language) Wirth's 1977 predecessor of Modula-2. The original Modula was, more oriented towards concurrent programming, but otherwise quite similar.



["Modula - A Language for Modular Multiprogramming", N. Wirth, Soft Prac & Exp 7(1):3-35, Jan 1977].



Oberon A strongly typed procedural programming language and an operating environment evolved from Modula-2 by Nicklaus Wirth in 1988. Oberon adds type extension (inheritance), extensible record types, multidimensional open arrays, and garbage collection. It eliminates variant records, enumeration types, subranges, lower array indices and for loops.



A successor called Oberon-2 by H. Moessenboeck features a handful of extensions to Oberon including type-bound procedures (methods).



Seneca is a variant of Oberon focussing on numerical programming under development by R. Griesemer in April 1993 (to be renamed).



Pascal (After the French mathematician Blaise Pascal (1623-1662)) A programming language designed by Niklaus Wirth around 1970. Pascal was designed for simplicity and for teaching programming, in reaction to the complexity of ALGOL 68. It emphasises structured programming constructs, data structures and strong typing. Innovations included enumeration types, subranges, sets, variant records and the case statement. Pascal has been extremely influential in programming language design and has a great number of variants and descendants.



Perl A high-level programming language, started by Larry Wall in 1987 and developed as an open source project. It has an eclectic heritage, deriving from the ubiquitous C programming language and to a lesser extent from sed, awk, various Unix shell languages, Lisp, and at least a dozen other tools and languages. Originally developed for Unix, it is now available for many platforms.



Perl's elaborate support for regular expression matching and substitution has made it the language of choice for tasks involving string manipulation, whether for text or binary data. It is particularly popular for writing CGI scripts.



The language's highly flexible syntax and concise regular expression operators, make densely written Perl code indecipherable to the uninitiated. The syntax is, however, really quite simple and powerful and, once the basics have been mastered, a joy to write.



Perl's only primitive data type is the "scalar", which can hold a number, a string, the undefined value, or a typed reference. Perl's aggregate data types are arrays, which are ordered lists of scalars indexed by natural numbers, and hashes (or "associative arrays") which are unordered lists of scalars indexed by strings. A reference can point to a scalar, array, hash, function, or filehandle. Objects are implemented as references "blessed" with a class name. Strings in Perl are eight-bit clean, including nulls, and so can contain binary data.



Unlike C but like most Lisp dialects, Perl internally and dynamically handles all memory allocation, garbage collection, and type coercion.



Perl supports closures, recursive functions, symbols with either lexical scope or dynamic scope, nested data structures of arbitrary content and complexity (as lists or hashes of references), and packages (which can serve as classes, optionally inheriting methods from one or more other classes). There is ongoing work on threads, Unicode, exceptions, and backtracking. Perl program files can contain embedded documentation in POD (Plain Old Documentation), a simple markup language.



The normal Perl distribution contains documentation for the language, as well as over a hundred modules (program libraries). Hundreds more are available from The Comprehensive Perl Archive Network. Modules are themselves generally written in Perl, but can be implemented as interfaces to code in other languages, typically compiled C.



The free availability of modules for almost any conceivable task, as well as the fact that Perl offers direct access to almost all system calls and places no arbitrary limits on data structure size or complexity, has led some to describe Perl, in a parody of a famous remark about lex, as the "Swiss Army chainsaw" of programming.



The use of Perl has grown significantly since its adoption as the language of choice of many World-Wide Web developers. CGI interfaces and libraries for Perl exist for several platforms and Perl's speed and flexibility make it well suited for form processing and on-the-fly web page creation.



Perl programs are generally stored as text source files, which are compiled into virtual machine code at runtime; this, in combination with its rich variety of data types and its common use as a glue language, makes Perl somewhat hard to classify as either a "scripting language" or an "applications language" -- see Ousterhout's dichotomy. Perl programs are usually called "Perl scripts", if only for historical reasons.



Version 5 was a major rewrite and enhancement of version 4, released sometime before November 1993. It added real data structures by way of "references", un-adorned subroutine calls, and method inheritance.



The spelling "Perl" is preferred over the older "PERL" (even though some explain the language's name as originating in the acronym for "Practical Extraction and Report Language"). The program that interprets/compiles Perl code is called "perl", typically "/usr/local/bin/perl" or "/usr/bin/perl".





Prolog Programming in Logic or (French) Programmation en Logique. It is the first of a huge family of logic programming languages.



Prolog was invented by Alain Colmerauer and Phillipe Roussel at the University of Aix-Marseille in 1971. It was first implemented 1972 in ALGOL-W. It was designed originally for natural-language processing but has become one of the most widely used languages for artificial intelligence.



It is based on LUSH (or SLD) resolution theorem proving and unification. The first versions had no user-defined functions and no control structure other than the built-in depth-first search with backtracking. Early collaboration between Marseille and Robert Kowalski at University of Edinburgh continued until about 1975.



Early implementations included C-Prolog, ESLPDPRO, Frolic, LM-Prolog, Open Prolog, SB-Prolog, UPMAIL Tricia Prolog. In 1998, the most common Prologs in use are Quintus Prolog, SICSTUS Prolog, LPA Prolog, SWI Prolog, AMZI Prolog, SNI Prolog.



PL/I Programming Language One (PL/S a dialect). An attempt to combine the best features of Fortran, COBOL and ALGOL 60. Developed by George Radin of IBM in 1964. Originally named NPL and Fortran VI. The result is large but elegant. PL/I was one of the first languages to have a formal semantic definition, using the Vienna Definition Language. EPL, a dialect of PL/I, was used to write almost all of the Multics operating system. PL/I is still widely used internally at IBM. The PL/I standard is ANS X3.53-1976.



PL/I has no reserved words. Types are fixed, float, complex, character strings with maximum length, bit strings, and label variables. Arrays have lower bounds and may be dynamic. It also has summation, multi-level structures, structure assignment, un-typed pointers, side effects and aliasing. Control flow constructs include goto; do-end groups; do-to-by-while-end loops; external procedures; internal nested procedures and blocks; generic procedures and exception handling. Procedures may be declared recursive. Many implementations support concurrency ('call task' and 'wait(event)' are equivalent to fork/join) and compile-time statements.



LPI is a PL/I interpreter.



Scheme (Originally "Schemer", by analogy with Planner and Conniver). A small, uniform Lisp dialect with clean semantics, developed initially by Guy Steele and Gerald Sussman in 1975. Scheme uses applicative order reduction and is lexically scoped. It treats both functions and continuations as first-class objects.



Self A small, dynamically typed object-oriented language, based purely on prototypes and delegation. Self was developed by the Self Group at Sun Microsystems Laboratories, Inc. and Stanford University. It is an experimental exploratory programming language.



Release 2.0 introduces full source-level debugging of optimized code, adaptive optimization to shorten compile pauses, lightweight threads within Self, support for dynamically linking foreign functions, changing programs within Self and the ability to run the experimental Self graphical browser under OpenWindows. Designed for expressive power and malleability, Self combines a pure, prototype-based object model with uniform access to state and behavior. Unlike other languages, Self allows objects to inherit state and to change their patterns of inheritance dynamically. Self's customizing compiler can generate very efficient code compared to other dynamically-typed object-oriented languages.



Smalltalk The pioneering object-oriented programming system developed by the Software Concepts Group, led by Alan Kay, at Xerox PARC in 1972. It includes a language (usually interpreted), a programming environment, and an extensive object library.



Smalltalk took the concepts of class and message from Simula-67 and made them all-pervasive. Innovations included the bitmap display, windowing system and use of a mouse.



Two pseudo-variables are defined: "self" - the receiver of the current message and "super" - an object of the current class's superclass. Smalltalk does not have multiple inheritance so each class can have at most one superclass.



Early versions: Smalltalk-72, Smalltalk-74, Smalltalk-76 (inheritance taken from Simula, and concurrency), and Smalltalk-78, Smalltalk-80. Other versions: Little Smalltalk, GNU Smalltalk, Smalltalk/V.



SNOBOL String Oriented Symbolic Language - A string processing language for text and formula manipulation written by David Farber, Ralph Griswold, and I. Polonsky of Bell Labs in 1962-3.



SNOBOL had only simple control structures but provided a rich string-matching formalism of power comparable to regular expressions but implementated differently. People used it for simple natural language processing analysis tasks well into the 1980s. Since then, Perl has come into favour for such tasks.



SNOBOL was originally called "SEXI" - String EXpression Interpreter. In spite of the suggestive name, SNOBOL is not related to COBOL.



Implementations include (in no particular order): SNOBOL2, SNOBOL3, SNOBOL4, FASBOL, SITBOL, MAINBOL, SPITBOL and vanilla.



VisualBasic (VB) A popular event-driven visual programming system from Microsoft Corporation for Microsoft Windows. VB is good for developing Windows interfaces, it invokes fragments of BASIC code when the user performs certain operations on graphical objects on-screen. It is widely used for in-house application program development and for prototyping. It can also be used to create ActiveX and COM components.

Version 1 was released in 1991. Current version: 6, as of 1999-11-26.



Support for Object-Oriented Programming


Object Orientation
Abstraction
Abstract Data Type (ADT)
Object Oriented Programming
Object Characteristic
Object Persistency
Messages, Message Protocol, and Methods
Classes
Variables
Inheritance
Polymorphism
Encapsulation
Object Oriented Environment



Abstraction

It corresponds to the ability of human beings to focus their thinking on an element of a representation or a concept, denoting their full attention to it while neglecting all others. The process of abstraction starts with the identification of the common characteristics of a set of elements, and proceeds to the concise description of these characteristics of a set of elements, and proceeds to the concise description of these characteristics in what is conventionally called a class. The abstraction process is arbitrary, it is defined with respect to a particular viewpoint. As a result, a real world object may be seen through different abstractions, which implies that it is important to establish sensible criteria in the application domain of interest.



Generalization. Abstraction ignoring and/or hiding details to capture commonality between different instances (objects). Examples are abstract data types (the representation details are hidden), abstract syntax (the details of the concrete syntax are ignored), and abstract interpretation (details are ignored to analyze specific properties).



An abstraction is a view or representation of an entity that includes only the attributes of significance in a particular context.



Abstraction is opposite of concretization.



Abstract Data Type (ADT)

A data type which internal form is hidden the set of access functions. Objects of the type are created and inspected only by calls to the access functions. This allows the implementation of the type to be changed without requiring any changes outside the module in which it is defined.



Data Abstraction An abstract data type, simply put, is an encapsulation that includes only the data representation of one specific data type and the subprogram that provide the operations for that type. Through access control, unnecessary details of the type can be hidden from units outside the encapsulation that use the type. Program units that use an abstract data type can declare variables of that type, even though the actual representation is hidden from them. An instance of an abstract data type is called an object.



Object Oriented Programming (OOP)

Writing programs in one of a class of programming languages and techniques based on the concept of an "object" which is a data structure (abstract data type) encapsulated with a set of routines, called "methods" which operate on the data. Operations on the data can only be performed via these methods, which are common to all objects that are instances of a particular "class". Thus the interface to objects is well defined, and allows the code implementing the methods to be changed so long as the interface remains the same.



Each class is a separate module and has a position in a "class hierarchy". Methods or code in one class can be passed down the hierarchy to a subclass or inherited from a superclass.



Procedure calls are described in term of message passing. A message names a method and may optionally include other arguments. When a message is sent to an object, the method is looked up in the object's class to find out how to perform that operation on the given object. If the method is not defined for the object's class, it is looked for in its superclass and so on up the class hierarchy until it is found or there is no higher superclass. Procedure calls always return a result object, which may be an error, as in the case where no superclass defines the requested method.



OOP started with SIMULA-67 around 1970. Popular examples of object-oriented programming languages (OOPL) are Smalltalk, from Xerox's Palo Alto Research Center (PARC) and C++. Others include Ada, Object Pascal, Objective C, DRAGOON, BETA, Emerald, POOL, Eiffel, Self, Oblog, ESP, POLKA and Loops.


Object Characteristic
State
Behavior
Identity



An object has an identity that characterized its own existence. The identity makes it possible to distinguish any object in an unambiguous way, and independently from its state. This allows, among other things, the differentiation of two objects for which all attributes has identical values.


Object Persistency
Persistence refers to an object's ability to transcend time or space. A persistent object saves its state in a permanent storage system to make it possible for the process that created the object to terminate, without losing the information represented by the object. Later, the object may be reconstructed by another process and will behave in exactly the same way as it did in the initial process.
Non-persistent objects are said to be transient or ephemeral. By default, objects are not considered persistent.


Messages, Message Protocol, and Methods

All computing in a pure object-oriented language is done by the same uniform technique: sending message to an object to invoke one of its methods. A reply to a message is an object that returns the value of the computation of the method.



Message A request sent to an object to invoke a method. A message is similar to a function call, but different in that an object only responds to a predetermined set of messages defined by its class.



Message Categories



Constructors: Create objects

Destructors: Delete Objects

Getters: (Accessors / Selectors) Return all or part of the state of an object

Setters: (Mutators / Modifiers) Change all or part of the state of an object

Iterators: Visit the state of an object or the content of a data structure that includes several objects



Methods The subprograms that define the operations on objects of a class are called methods. The calls to methods are often called messages.



Protocol The entire collection of methods of an object is called the message protocol, or message interface, of the object.



A message must have at least two parts, the specific object to which it is being sent and the name of a method that defines the request action on the object. So computations in an object-oriented program are specified by messages sent from objects to other objects.



Class

An implementation creates multiple objects with the same behavior. An object is an instance of a class. Types classify objects according to a common interface; classes classify objects according to a common implementation.



A class that is defined through inheritance from another class is a derived class or subclass. A class from which the new class is derived is its “parent class” or “superclass”



Superclass The class from which subclass inherits. It is also called base class.



Subclass A class that is derived from superclass by inheritance. The subclass contains all the features of the superclass, but may have new features added or redefine existing features.



Variables

Class can have two kinds of methods and two kinds of variables. The most commonly used methods and variables are called instance methods and variables. Every object of a class has its own set of instance variables, which store the object’s state. The only difference between two objects of the same class is the state of their instance variables. Instance methods operate only one the objects of the class. Class variables belong to the class, rather than its object, so there s only one copy for the class. Class methods can perform operations on the class, and possibly also on the objects of the class.



Global Variables Variables are those that are visible in all program units.



Local Variables Variables that are defined inside subprograms are called local variables because access to them is usually restricted to the subprogram in which they are defined.



Instance Variables Variables that are per instance (object) only



Class Variables Variables that are shared among all the object of the same class (or superclasses)



Inheritance

It is the subclasses’ acquisition of its superclass state and behavior definitions. In object-oriented programming, the ability to derive new classes from existing classes. A derived class ("subclass") inherits the instance variables and methods of the base class ("superclass"), and may add new instance variables and methods. New methods may be defined with the same names as those in the base class, in which case they override the original one.



For example, bytes might belong to the class of integers for which an "add" method might be defined. The byte class would inherit the "add" method from the integer class.



Single Inheritance Inherit from a single superclass.



Multiple Inheritances Inherit from a multiple superclasses.



Behavior Override In addition to inheriting entities from its superclass, a subclass can add new entities and modify inherited methods. A modified method has the same name, and often the same protocol, as the one of which it is a modification. The new method is said to override the inherited version, which is then called an overridden method. The most common purpose of an overriding method is to provide an operation that is specific for objects of the subclass but is not appropriate for objects of the superclass.







Polymorphism

The term polymorphism describe the characteristic of an element that may take on different forms, like water that can be found in either solid, liquid, or gaseous state. In computer science, polymorphism pertains top a concept of type theory, according to which an object name can designate instances of different classes within a single hierarchy.



Encapsulation

Object state protection. The ability to provide users with a well-defined interface to a set of functions in a way that hides their internal workings. In object-oriented programming, the technique of keeping data structures and methods (procedures) together, which act on them.



Object Oriented Environment



Virtual Machine A self-contained operating environment that behaves as if it is a separate computer. For example, Java applets run in a Java virtual machine (VM) that has no access to the host operating system. This design has two advantages:



System Independence: A Java application will run the same in any Java VM, regardless of the hardware and software underlying the system. Security: Because the VM has no contact with the operating system, there is little possibility of a Java program damaging other files or applications.



The second advantage, however, has a downside. Because programs running in a VM are separate from the operating system, they cannot take advantage of special operating system features.



1. An abstract machine for which an interpreter exists. Virtual machines are often used in the implementation of portable executors for high-level languages. The HLL is compiled into code for the virtual machine (an intermediate language) which is then executed by an interpreter written in assembly language or some other portable language like C.



Examples are Core War, Java Virtual Machine, OCODE, OS/2, POPLOG, Portable Scheme Interpreter, Portable Standard Lisp, Parallel Virtual Machine, Sequential Parlog Machine, SNOBOL Implementation Language, SODA.



2. A software emulation of a physical computing environment.



The term gave rise to the name of IBM's VM operating system whose task is to provide one or more simultaneous execution environments in which operating systems or other programs may execute as though they were running "on the bare iron", that is, without an eveloping Control Program. A major use of VM is the running of both outdated and current versions of the same operating system on a single CPU complex for the purpose of system migration, thereby obviating the need for a second processor.



Java Virtual Machine (JVM)

A specification for software which interprets Java programs that have been compiled into byte-codes, and usually stored in a ".class" file. The JVM instruction set is stack-oriented, with variable instruction length. Unlike some other instruction sets, the JVM's supports object-oriented programming directly by including instructions for object method invocation (similar to subroutine call in other instruction sets).



The JVM itself is written in C and so can be ported to run on most platforms. It needs thread support and I/O (for dynamic class loading). The Java byte-code is independent of the platform.



There are also some hardware implementations of the JVM.



Byte-Code A binary file containing an executable program, formed by a sequence of op code/data pairs. Byte-code op codes are most often fixed size binary patterns, but can be variable size. The data portion consists of zero or more bits, the format of the data portion may be determined by the identifier. The data is most often variable in size.



In some cases, by clever design, (e.g. some RISC instruction sets) the identifier/data pair is a fixed size. This can provide performance benefits.



A byte-code program is normally interpreted by a byte-code interpreter. The advantage of this technique compared with outputing machine code for a particular processor is that the same byte-code can be executed on any processor on which the byte-code interpreter runs. The byte-code may be compiled to machine code ("native code") for speed of execution but this usually requires significantly greater effort for each new target architecture than simply porting the interpreter.



For example, Java is compiled to byte-code which runs on the Java Virtual Machine.



Object Engine



Garbage Collection The process by which dynamically allocated storage is reclaimed during the execution of a program. The term usually refers to automatic periodic storage reclamation by the garbage collector (part of the run-time system), as opposed to explicit code to free specific blocks of memory.



Automatic garbage collection is usually triggered during memory allocation when the amount free memory falls below some threshold or after a certain number of allocations. Normal execution is suspended and the garbage collector is run. There are many variations on this basic scheme.



Languages like Lisp represent expressions as graphs built from cells which contain pointers and data. These languages use automatic dynamic storage allocation to build expressions. During the evaluation of an expression it is necessary to reclaim space which is used by subexpressions but which is no longer pointed to by anything. This reclaimed memory is returned to the free memory pool for subsequent reallocation.



Without garbage collection the program's memory requirements would increase monotonically throughout execution, possibly exceeding system limits on virtual memory size.



The three main methods are mark-sweep garbage collection, reference counting, and copying garbage collection.



Mark-sweep garbage collection

Each cell has a bit reserved for marking which is clear initially. During garbage collection all active cells are traced from the root and marked. Then all cells are examined. Unmarked cells are freed.



Reference counting

A garbage collection technique where each memory cell contains a count of the number of other cells which point to it. If this count reaches zero the cell is freed and its pointers to other cells are followed to decrement their counts, and so on recursively.



This technique cannot cope with circular data structures. Cells in such structures refer (indirectly) to themselves and so will never have a zero reference count. This means they would never be reclaimed, even when there are no references from outside the structure.



Copying garbage collection

A garbage collection method where memory is divided into two equal halves, known as the "from space" and "to space". Garbage collection copies active cells from the from space to the to space and leaves behind an invisible pointer (an "indirection") from the old position to the new copy. Once all active cells have been copied in one direction, the spaces are swapped and the process repeated in the opposite direction.



Memory Leak An error in a program's dynamic store allocation logic that causes it to fail to reclaim discarded memory, leading to eventual collapse due to running out of memory. Also (especially at CMU) called core leak. These problems were severe on older machines with small, fixed-size address spaces, and special "leak detection" tools were commonly written to root them out.



With the advent of virtual memory, it is unfortunately easier to be sloppy about wasting a bit of memory (although when you run out of virtual memory, it means you've got a “real” leak!).