Escolar Documentos
Profissional Documentos
Cultura Documentos
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 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.
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").
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 <bs@alice.att.com> at AT&T Bell Laboratories in 1986.
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].
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).
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 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".
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Message Categories
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.