Programming languages

FORTRAN - numerical problems, very efficient compiler, separate compilation

•Fortran: the first "mainstream" imperative programming language, designed to facilitate scientific programming.

•Versions II through IV came out 1958-1962.

•Aimed at efficient calculation, good handling of arrays and loops, but not geared towards effective programming support, I/O, or dynamic allocation. •Fortran I was (arguably) the first compiled high level language, and introduced "if" statements, iterative "do" loops, and more flexible variable names. •Fortran IV was extensively used throughout the 1960's and 1970's, and fixed or included many more features (explicit type declarations, enhanced logic control and parameter passing)

LISP - List processing and symbolic manipulation, AI

•

•LISP (1959) the first functional programming language - the goal was to create a programming language which could be used to efficiently carry out symbolic computation (rather than numeric) and to operate effectively on lists of data - with an orientation towards AI applications.

•Evolved from the recognition that the existing high level language (Fortran I) could handle neither recursion nor conditional expressions nor dynamic allocation and de-allocation of list storage.

•Pure LISP would have only two types of data structure: atoms and lists, and all computation would be accomplished by applying functions to arguments.

•LISP and its descendants (including Scheme) have been the dominant AI programming languages for the past 40 years.

•Scheme is a small dialect of LISP, which exclusively uses static scoping rules and which allows functions to be treated as "first class" entities (i.e. can be passed as parameters, returned as values, etc).

•ALGOL (1958-1960) - numeric, block structure, recursion, elegant, very influential

•

•Was designed by international groups to be the first machine-independent language, but that very flexibility made it hard to implement and led to its failure as a "practical" language.

•

•ALGOL was designed to be an effective language for describing algorithms through semi-mathematical notation: it became a standard basis for publishing algorithms, and served as a basis for many later programming languages.

•ALGOL 60 introduced

•the block concept for scope environments,

•distinction between parameter passing "by name" and "by value",

•formal description of a language syntax (through BNF forms)

•Later, ALGOL 68 (which also failed to achieve any sort of widespread use) introduced a few primitive data types and structures which the user could combine to create more desired complex types as desired.

•Unfortunately (as with ALGOL 60) the language was described using a metalanguage, which the user had to learn before they could read the document describing the language itself!

•COBOL (1960): - business data processing, records

•

•Was designed for a business orientation, with the aim that it should be easy to read and understand (close to simple English).

•It is still the most widely used business applications language, yet it has had very little impact on the development of subsequent programming languages.

•The language design was carried out by a committee sponsored by the Department of Defence in 1959. Indeed, the original survival of the language is likely due to the fact that the DoD mandated the use of COBOL in spite of its early poor performance.

•The decision was to categorize language statements into two categories, depending on whether they describe data or represent executable operations, and to separate these groups of statements within the program.

•COBOL 60 was one the first high level language to implement the macro concept and also the use of hierarchical data structures.

•COBOL includes extensive definition of variables and file records, but is impaired by its lack of functions.

•BASIC (1964): designed to be an easy programming language for "non-science" students, it placed less emphasis on execution efficiency and more on programming time

•

•Early versions were designed for remote terminal access to a computer, and programs had to be run in batch mode.

•The language was very limited both in control statements and in data types, but was very easy to learn.

•More recent versions (e.g. Visual Basic) represent substantial improvements over the early days.

•PL/I (1963-5): was one of the few languages that attempted to be a general purpose language, rather than aiming at a particular category of programming.

•

•PL/I incorporated a blend of features from FORTRAN, ALGOL, and COBOL, plus allowed programmers to create concurrent tasks, handle run-time exceptions, use recursive procedures, and use pointers.

•The language development was closely tied to the development of the IBM/360, a line of "general use" computers.

•The main problems with the language were its large size and the interaction of so many complex features.

•PASCAL (1971): an extension of the ALGOL languages, it survived as a teaching language for structured programming.

•

•It still has widespread (though rapidly declining) use in the teaching community, but comparatively little commercial use.

•It has stronger type and error checking than Fortran or C and more restrictive syntax, hence enforces some fundamental programming concepts better than C (perhaps).

•C (1972): C presented relatively little that was new or remarkable in terms of programming language design, but used and combined established features in a very effective manner for programming.

•

•It was designed for systems programming, and initially spread through close ties with UNIX.

•C has numerous and powerful operators, and extensive libraries of supporting function.

•It has (comparatively) little in the way of type checking, which makes the language more flexible for the experienced user but more dangerous for the inexperienced.

•Prolog (1972): was the first widespread formal logic language. It is a non-procedural, goal oriented language.

•

•Computation takes place by trying to infer the response to queries through accessing a database of facts and rules.

•The user supplies the facts, rules, and queries (expressed in predicate calculus), while the computer carries out resolution to try and infer the replies.

•Smalltalk (1972-1980): was a combination of programming language and complete development environment which pioneered current GUI systems.

•

•It was the first fully object oriented language, supporting data abstraction, inheritance, and dynamic binding.

•The programmer's view of the world was through objects and methods, and all programming is carried out by sending a message to an object as a request to invoke a method. (E.g. calling a function associated with the object, and passing it appropriate parameters.)

•Ada (1975-1983): Ada, like COBOL, had its development sponsored by the US Department of Defence, and survived as a language largely because of mandated use by the DoD.

•

•In design, Ada's developers tried to incorporate everything known about software engineering to that time. It supports object oriented programming, concurrency, exception handling, etc.

•The design and implementation of the language suffered through being perhaps too ambitious. The language was officially defined by 1981, but effective compilers could not be completed until 1985.

•C++ (1985): based upon (and implemented in) C, but with an object oriented emphasis.

•

•The goals were to make C++ an equally (or almost so) efficient superset of C, with classes and inheritance added.

•It is a very popular language because of its close ties to C, the ready availability of good compilers, and its effective use of OO.

•Its drawbacks are the same type and error checking weaknesses as C, and perhaps an overabundance of features (many of which are rarely used in practice) which make the language more difficult to learn.

•Perl (1988): Perl was developed on Unix systems as a tool for bug reporting, and has evolved from simple programming languages to a full-fledged (though unusual) programming language.

•

•Perl is a partially-compiled scripting language, but the compiler is used essentially to perform error detection, and to reconfigure the commands in a manner which simplifies interpretation.

•Perl, like Java, has seen a dramatic surge in popularity tied to the Web, as the language is well suited for CGI programming.

•Java (1995): is a significantly simplified descendant of C++.

•

•It is based on C++, and fully supports OOP, but eliminates many of the "unsafe" or "extravagant" features of C++.

•The language was originally intended for use primarily in embedded systems (hence the reliability requirements, and the elimination of "unsafe" features), but gained popularity primarily as a tool for Web programming.