Chapter 12: Programming Languages Learning Objectives



Download 95.12 Kb.
Date conversion28.01.2017
Size95.12 Kb.
Chapter 12: Programming Languages

Learning Objectives:

In this chapter, we are going to discuss the following topics:



  • History of Programming languages

  • Why do we need Programming Languages?

  • Generations of Programming Languages

  • Programming languages categories

  • Examples of Programming Languages


Learning outcomes:

At the end of this chapter, students will be able to:



  1. Describe the history of programming languages and its evolution to the present stage

  2. Explain the need for programming languages

  3. Identify the different generations of programming languages

  4. Categorize programming languages

  5. Provide examples of programming languages


12.1 History of Programming languages

There were significant events in history that lead up to where we are today with Programming Languages [1], [2], [3].


1949: Short Code

The first computer language actually used on an electronic computing device. The programmer was required to, by hand, change its statements into 0's and 1's for the processor to understand.



1951 - 1957: FLOW-MATIC & the First Compiler

Grace Hopper develops the first computer compiler which is called A-0, in 1951. Hopper produces specifications for a common business language. Flow-Matic provides the foundations for the specification of the language COBOL (COmmon Business-Oriented Language).


1952: Autocode

Alick E. Glennie, at the University of Manchester, devises a programming system called AUTOCODE, a rudimentary compiler.


1957: The Development of FORTRAN I

The first major language appears in the form of FORTRAN, short for FORmula TRANslating system. FORTRAN was designed by IBM for scientific computing. The components were very simple, and provided the programmer with low-level access to the computers innards. It included the IF, DO, and GOTO statements, which were a major step forward when it was released. Data-types in use by today's languages got their start in FORTRAN. These included the logical variables (TRUE or FALSE), and numerical variables (integer, real, and double-precision numbers).


1958: The Development of FORTRAN II & III

Adding the capability for separate compilation of program modules, FORTRAN II was a significant improvement, allowing assembly language modules to be 'linked loaded' with FORTRAN modules. Although it was never released, FORTRAN III made it possible to use assembly language code right in the middle of FORTRAN code.


1958: LISP

John McCarthy of MIT creates the LISt Processing (LISP) language. It was designed for Artificial Intelligence (AI) research, and because of which, had syntax which had rarely been seen before or since its introduction.


1958: ALGOL 58

Created originally in 1958 by a committee for scientific use, ALGOL was the first block-structured language that appears. A later version, ALGOL 60, was released in 1960 and would serve as the root of the family tree that will ultimately produce other languages such as Pascal, C, C++, and Java.


1959: COBOL

Although FORTRAN was good at handling numbers, it was not so good at handling input and output, which mattered to most business computing. When business computing began to take off in 1959, COBOL was developed to fill the need that FORTRAN could not. Created by the Conference on Data Systems and Languages (CODASYL), COBOL was developed from the ground up as the language for business men. COBOL statements have a very English-like grammar, making it quite easy to learn, especially for the business men for which it was designed.


1960: APL

Kenneth Iverson invented APL--A Programming Language. It is an interpreted mathematical language characterized by its terse syntax and bizarre non-ASCII character set. It is very strong in all forms of arithmetic and matrix manipulation According to its fans, its expressive power allows a skilled programmer to create complex applications in a very short time. Sometimes, entire complex mathematical analyses can be coded in a couple of lines of code. However, APLs unconventional structure and odd character set make it challenging to learn and master. Today, APL is used mainly in niches in the scientific, financial, and econometric communities


1961: FORTRAN IV

FORTRAN IV was released in 1961 and it improved things like the implementation of the COMMON and EQUIVALENCE statements, and eliminating some machine-dependant language irregularities. A FORTRAN II to FORTRAN IV translator was used to retain backward compatibility with earlier FORTRAN programs.



1962: SNOBOL

Designed by three people at Bell Laboratories: (D.J. Farber, R.E. Griswold, and F.P. Polensky, SNOBOL (StriNg-Oriented symBOlic Language) is a special purposed language developed to provide a powerful means of doing character string manipulation. Accordingly SNOBOL has a collection of powerful operations for doing string pattern matchings. The most common early application of SNOBOL was to write text editors. Because of the dynamic nature of SNOBOL and its interpreter implementation, it is now considered too slow for such applications. Infact SNOBOL is now close to being completely unused.


1963: PL/I

PL/I (Programming Language 1) is a large, complex block-structured language invented by IBM in 1963, and first released in 1964 in conjunction with the influential System/360 line of computers. PL/I was intended to be THE all-around language for mainframe system and application development, and therefore it had a very large feature set. PL/I was widely used by the IBM community


1964: BASIC

The Beginners All-purpose Symbolic Instruction Code (BASIC) was designed in 1964 by two graduate students at Dartmouth, John Kennedy and Thomas Kurtz, to be an easy first language for programming neophytes, especially those who weren't "computer-science" oriented. Though the first version was compiled, most Basic systems were interpreters. Original Basic had a simple syntax that included a line number for every source line. Control structure mostly consisted of GOTO ### and GOSUB ###; simple conditional and bounded loop constructs were also available. Original Basic provided numeric, string, and array datatypes, but no structures or objects.



1966: FORTRAN 66

The new ASA standard was published in 1966, and was known accordingly as FORTRAN 66. This was a very important step that made it worthwhile for vendors to produce FORTRAN systems for every new computer, making FORTRAN an even more popular HLL.


1966: Logo

Logo is a functional language designed to teach programming and problem-solving principles to children. It is a functional language, related to Lisp, with a simple syntax and a graphics-oriented feature set. The Logo language provides a set of built-in procedures, a means to create new procedures, a simple data framework with symbols, numbers, and lists, and simple control structures. Logo is a simple language to learn, but amazingly functional. Many elementary schools have used Logo to teach children how to think about really controlling computers (not just point-n-click). Many of the sites listed below have links to these educational projects.


1967: BCPL

BCPL is an operator-typed language; the data types of variables are defined by the operators applied (rather than being declared for the variable, as in Algol). Data items were untyped cells labeled with identifiers. Data types supported by BCPL included integers, reals, bit patterns, I/O streams, various kinds of references, and vectors. Strings could only be used as constants. The language supported simple control constructs like loops and conditionals, as well as means to declare subroutines and functions. The BCPL system library, which evolved along with the language, provided I/O support and very simple memory management. Early versions of BCPL were machine native compilers, but nearly all recent versions have been translators. In other words, the BCPL compiler translates the BCPL code to an abstract machine language called INTCODE. The INTCODE data is then interpreted by a simple, fast virtual machine (typically coded in assembly language, C, or a mixture of the two).




1970: Forth

A Forth program is a sequence of words such that each word is independent, and causes some specified action. Even constants are words: the word "12" is just a command to push the number 12 onto the data stack. Sequences of words can be grouped as procedures, and employed to build up modular programs. In order for this to work, of course, operators and operands must be given in reverse polish order (operands followed by operator). All data manipulation takes place on the data stack, so Forth offers several operations for manipulating the stack. Forth implementations vary in the range of data types they provide, but most provide a conventional set of numeric and string types, plus arrays. Forth offers regular control structures: If-Else, While-Do, and For-Next, albeit with peculiar ordering of the keywords. Most dialects of Forth provides simple file handling and I/O support. Meant to be extensible at every level, Forth programmers can define new words, and implement them in Forth itself, in some other high-level language, or in machine code. Click to view a sample Forth program


1970: Smalltalk

Developed at Xerox PARC, led by Alan Kay, Smalltalk is a dynamic object-oriented language which was originally designed as an experiment, but evolved into a powerful application development language. Smalltalk is a pure object-oriented language


1970: Icon

A decendent of SNOBOL known as Icon is first introduced. It is a procedural language with high-level semantics for string and data aggregate processing. Icon is normally interpreted, but there is also a translator that generates compilable C code from Icon code. Icon was originally implemented for UNIX, but has been ported to VMS, MS-DOS, 32-bit MS-Windows, OS/2, and the Macintosh.


1971: Pascal

Pascal is a simple block-structured language originally designed for computer science education. Pascal features strong type checking, simple I/O facilities, a good set of primitive data types, arrays, fixed and variant records, conventional control structures, and simple dynamic memory management. In most programming areas, Pascal has been superseded by newer, object-oriented languages, such as C, C++, and Java.


1971: B

With its roots based in BCPL (see 1967), B is a new computer language designed and implemented at Murray Hill, New Jersey, by Dennis M. Ritchie and K. L. Thompson. B is suited for non-numeric computations, typified by system programming, which usually involve many complex logical decisions, computations on integers and fields of words, especially characters and bit strings, and no floating point. Unfortunately B is short lived, as within a year it spawns C, which will eventually incorporate everything that B already does.


1971: sh

The developement of sh, aka Bourne Shell, is no different from other shell scripting languages. Created in 1971 by Steve Bourne, the shell has been included on all Unix and Linux systems, and more-or-less complete versions are available for many other systems. Eventually, this would become part the development of Perl in 1987. The Bourne shell scripting language was one of the original command languages for the Unix operating system. It is a simple interpreted language, but widely used for automating complex tasks and assembling multi-step functionality from individual Unix tools. It offers extensive special syntax and features for running programs and handling their I/O. One of the most influential of these constructs was the "pipe", a simple syntax for connecting the output of one program to the input of another.


1972: Prolog

The first implementation of Prolog, developed by Alain Colmerauer and Phillip Roussel appears after work had begun in 1971. A Prolog program can accomplish amazing things with a very short amount of code. The logic paradigm is a very powerful one for certain problem domains, but unsuitable for some others. PROLOG stands for PROgramming in LOGic.


1972: C

Developed by Dennis M. Richie while working at Bell Labs in Murray Hill, New Jersey, the language of C, a fairly low-level block structured language with good support for system programming. It had fair arithmetic support, simple data structures, subroutines, conventional flow control constructs, naked memory pointers, simple but useful I/O facilities, and a powerful macro preprocessor. Richie had developed C for the new Unix system being created around the same time, and because of this, Unix and C go hand in hand. However, C would not be limited to just Unix as language would become widely used in PC, Mac, mainframe, and other computing environments. Based in two lesser known languages of B (see 1971) and BCPL (see 1967), C signified the next major step in programming languages as it also seemed to improve on the already popular Pascal.


1975: Tiny BASIC

A relatively unknown language called Tiny BASIC is released by Bob Albrecht and Dennis Allison (implementation by Dick Whipple and John Arnold). It runs on a microcomputer with just 2 KB of RAM. A 4-KB machine is sizable, which left 2 KB available for the program.


1975: Scheme

Developed at MIT, Scheme, a dialect of LISP, was created with functional and procedural language aspects. Unlike original LISP, Scheme is lexically scoped, but like LISP it is dynamically typed. Scheme is used to teach computer science principles, as well as for writing various compilers, AI systems, and many other kinds of programs.


1975: The Microsoft Empire Takes Shape

With the release of their own version of BASIC (see 1964), Bill Gates and Paul Allen being the company known today as Microsoft. They sell it to MITS (Micro Instrumentation and Telemetry Systems) on a per-copy royalty basis. MITS is producing the Altair, an 8080-based microcomputer at the time.


1975: RATFOR

B.W. Kerninghan describes RATFOR which stands for RATional FORTRAN. It is a preprocessor that allows C-like control structures in FORTRAN. RATFOR is used in Kernighan and Plauger's "Software Tools," which appears a year later.


1977: MUMPS

The ANSI standard for MUMPS (Massachusetts General Hospital Utility Multi-Programming System) is released. Soon after it becomes standardized and commercialized, people started calling it 'M' because it was cooler and didn't evoke an unpleasant disease. MUMPS (aka M) is a procedural, interpreted language with extensive features for event-driven programming, text handling, and database manipulation.


1978: Awk

Awk is an interpreted string-processing language developed at Bell Labs. It quickly assumed its place as the utility language of choice for small UNIX data transformation and parsing programs. Awk offered powerful regular expression pattern matching, handy line-oriented program structure, and enough conventional language features to let you get your work done. Awk did not support any kind of modularity nor type checking. Awk remains moderately well-known in the UNIX community, but has been largely superseded by the more powerful Perl programming language in 1987.


1979: Rexx

Originally invented as a sophisticated command language for IBM mainframe environments (MVS, CMS), Rexx has gained some popularity as a programming language with expressive power and convenience. In the Windows environment it competes with Visual Basic, Java, Perl, and Tcl. In the UNIX environment is competes with Perl, Tcl, Java, and various shells. On IBM OS/2 Rexx is probably the most popular scripting language.



1980: Modula 2

Originally conceived by Niklaus Wirth in 1977, Modula 2 was officially released in 1980. It is designed to support the construction and maintenance of real application software systems, unlike its predecessor Pascal. Modula 2's support for concurrency and dynamic memory management are also better than Pascal, allowing the programmer more flexibility.


1980: C with Classes

With OOP (Object Oriented Programming) developing in the late 70's, Bjarne Stroustrup develops a set of languages, collectively referred to as "C With Classes". These are extensions to C which was released in 1972, providing advanced features such as dynamic variables, multitasking, interrupt handling, forking, and strong, low-level input/output. "C With Classes" server as the breeding ground for C++ which would be released in 1983.


1982: The Foundation of Adobe and PostScript

PostScript is a threaded interpreted language with stack-based semantics. While usable for general-purpose computation, PostScript was specially designed to drive graphic devices, initially printers, and has a large set of operators for rendering onto a page. In terms of syntax and semantics, PostScript resembles Forth: operators use data from a stack, and place their results back on the stack. PostScript data types include floating-point numbers, strings, fonts, files, vectors, and symbols. Defined procedures are simply code sequences stored in dictionaries.


1983: Ada

Originally designed for the US Dept. of Defense, with intentions to support large-scale programming and promote software reliability, Ada is released in 1983. Named in honor of Lady Ada Lovelace (1815-1852), a friend and confidante of Charles Babbage, Ada is a block-structured language with many object-oriented programming features that include: nested procedures, nested packages, strong typing, multi-tasking, generics, exception handling, and abstract data types. Ada is a fairly complex language that has a conventional but very rich Pascal-like syntax, with many specialized features. The best aspects of Ada are its support for generics (templates), its support for task synchronization, and its very good exception handling. Its worst features are its complex syntax, and the poor performance of the code generated by most early compilers.


1983: C++

In July of 1983, the first implementation of C++ appears. The name is coined by Rick Mascitti. C++ is a fairly complicated object-oriented language derived from C. The syntax of C++ is a lot like C, with various extensions and extra keywords needed to support classes, inheritance and other OO features. C++ was originally developed as an extension to C, but quickly evolved into its language. Despite some of the flaws it has inherited from C, C++ is a very popular language for application development on Unix systems and PCs.


1983: C Compilers

In late 1983 and early 1984, Microsoft and Digital Research both release the first C compilers for microcomputers.


1986: Actor

Charles Duff releases Actor, an object-oriented language for developing Microsoft Windows applications


1986: Eiffel

An object-oriented language intended for general application programming, Eiffel is designed in large part to support program safety and orderly software development, whose goals were also embraced by the Ada community. Superficially similar to C, the syntax of Eiffel offers a broad range of OO programming features: inheritance, polymorphism, assertions, exception handling, packaging, generics, and strong type checking.



1987: Perl

"Perl" stands for "Practical Extraction and Reporting Language," a reference to the purpose for which the Perl interpreter was originally created: system administration and data reduction. It is an interpreted scripting language with extensive facilities for data manipulation and rapid application development. Perl is basically block-structured, but also supports object-oriented programming. Perl is very popular in the UNIX community, and gaining acceptance in the Microsoft Windows developer community. There is only one Perl language system; written in C to be very portable, it runs on all UNIX platforms, 32-bit Windows, VMS, and many other systems. Perl is free. Books, tutorials, and on-line resources for Perl are widely available, and generally of good quality.


1988: Oberon

Oberon is a procedural, block-structured language with many object-oriented features. It was designed for computer science education, but is also suitable for general-purpose application programming. Oberon has a Pascal-like syntax, but its semantics are richer than Pascal's. An Oberon system consists of the Oberon language compiler along with a comprehensive operating environment.


1990: J

Kenneth Iverson and Roger Hui present J at the APL90 conference in 1990. J programming is normally conducted as an interactive session. J is a interpreted mathematical/functional programming language very closely related to APL. Basically, it is a dialect of APL with the same functionality, but employing the ASCII character set instead of APL's original unique character set.


1991 - 2001: The Arrival of the Internet Languages

By the mid 90's, the Internet had become part of our society. With the start of the new millennium, the Internet is as common as the television, and with it comes new languages designed specifically for its use.



1991: Java

Designed by research staff at Sun Microsystems, Java is a simple, portable object-oriented language. The feel of the Java language is fairly similar to that of C++, but it also borrows ideas from Modula-3, Mesa, and Objective-C. According to its designers, Java was intended to be object-oriented, robust, secure, architecture neutral, portable, high-performance, threaded, and dynamic.


1991: Python

Python is an interpreted, object-oriented language. It is intended to be highly effective, easy to use, and extensible. The syntax of Python is very simple and statement-oriented. Block structure is specified with indentation. Considered a good language to use for certain kinds of web programming, the standard library of Python supports HTTP and CGI services, as well as a Windows-specific library support ActiveX scripting (so that you can use powerful Python for active server pages instead of the intentionally weak VBScript). Python can be extended by adding C/C libraries, and it can also be embedded in an application to serve as its extension language.


1991: Visual Basic

As a language, Visual Basic has evolved enormously since its commercial introduction in 1991 by Microsoft. Visual Basic is an advanced structured dialect of Basic that is intended for application development. The "Visual" in the name Visual Basic does not really refer to the language, but to the development environment. The VB integrated development environment that Microsoft distributes has extensive facilities for on-screen design of graphical user interfaces: dialog boxes, window interfaces, menus, etc. It also provides a rich but complicated interface for code management and debugging. GUI programs are easy to write in Visual Basic, and the development environment provides copious support for coding the necessary event handling subroutines.



1992: Dylan

Developed by Apple Computer in 1992 by their advanced technology east lab, Dylan (DYnamic LANguage) is a dynamic object-oriented language with both procedural and functional features, intended for application development and system programming. It was originally intended for the Macintosh, but has been ported to many other computers. Implementations of Dylan are available for most platforms including Unix, Macintosh, and Windows. Dylan has been implemented as an interpreter, as a C front-end, and as a native compiler.


1993: Ruby

Based on earlier less known programming languages, Ruby was first a teaching language created in the late 1960's based on Markov processes. It eventually developed into a hardware specification language based on higher-order functions during the mid 1980's. The Ruby OOP language is the 3rd programming language to bear that name. Ruby is an interpreted scripting language, fully object-oriented and designed for easy extensibility. The syntax of Ruby is simple but bears a strong resemblance to Perl.


1994: JavaScript

Invented by Netscape Communications for adding dynamic behavior to web pages, JavaScript was originally called 'LiveScript'. Sun Microsystems, developer of Java, took an interest in this powerful script and, along with Netscape, made some adjustments to re-introduce the script under the new name of JavaScript. Unlike Java, which can be used to develop entirely standalone applications, JavaScript works primarily with Web pages. JavaScript is a loosely typed scripting language with object-oriented and block-structuring features. The syntax of JavaScript is similar to that of C or Java, but simpler and not as rich. Primitive data types include integers, reals, strings, and a associative arrays. Javascript is loosely typed, any variable can contain data of any type, and conversion is mostly automatic. The language definition includes extensive facilities for controlling and manipulating parts of web pages, especially HTML forms. Each version of Netscape Navigator has brought a new version of JavaScript, and later versions also include a complicated security model for restricting the hostile capabilities of scripts embedded in web pages. Microsoft web browser also support Javascript, but under the name "JScript".


1995: VBScript

Although VBScript was first developed in 1995, the first release of VBScript (v2.0) was part of Microsoft's Internet Explorer 3.0 which came out in 1997. VBScript has no language-defined I/O facilities, so that any I/O that it supports must be provided by object classes supplied from the controlling application environment. In a web browser client, these objects are not available, but in a web server environment they are. VBScript (Visual Basic Scripting Edition) is a subset dialect of Visual Basic. It is an interpreted, procedural language intended for creating application extension scripts and for adding interactivity to web pages.


12.2 Why do we need Programming Languages?

A programming language serves several purposes [4], [5]. We can instruct the computer what to do in a human-readable form. Programming languages allow the programmer to structure the instructions into functions, procedures, etc. This also allows the program to be broken into "chunks" which can be developed by a group of developers. It also provides portability, whereby the low-level instructions of one computer will be different from that of another computer. A high-level language hides that.


A programming language is important because it defines the relationship, semantics and grammar which allow the programmers to effectively communicate with the machines that they program. Just as French allows French people to communicate with each other and German allows German people to communicate with each other. Learning a programming language is something that you do in order to communicate with a machine. Just like a German person would learn the French language in order to communicate with a French person.


12.3 Generations of Programming Languages
The first and second generation languages (1950-60)

These languages also called the machine and assembly languages [6], [7]. Developments in early 1950 brought us machine language without interpreters and compilers to translate languages. Micro-code is an example of the first generation language residing in the CPU written for doing multiplication or division. Computers then were programmed in binary notation that was very prone to errors. A simple algorithm resulted in lengthy code. This was then improved to mnemonic codes to represent operations.


Symbolic assembly codes came next in the mid 1950's, the second generation of programming language like AUTOCODER, SAP and SPS. Symbolic addresses allowed programmers to represent memory locations, variables and instructions with names. Programmers now had the flexibility not to change the addresses for new locations of variables whenever they are modified. This kind of programming is still considered fast and to program in machine language required high knowledge of the CPU and machine's instruction set. This also meant high hardware dependency and lack of portability. Assembly or machine code could not run on different machines. Example, code written for the Intel® Processor family would look very different for code written for the Motorola 68X00 series. To convert would mean changing a whole length of code.
The third generation languages.

Throughout the early 1960's till 1980 saw the emergence of the third generation programming languages [8], [9]. Languages like ALGOL 58, 60 and 68, COBOL, FORTRAN IV, ADA and C are examples of this and were considered as high level languages. Most of these languages had compilers and the advantage of this was speed. Independence was another factor as these languages were machine independent and could run on different machines. The advantages of high level languages include the support for ideas of abstraction so that programmers can concentrate on finding the solution to the problem rapidly, rather than on low-level details of data representation. The comparative ease of use and learning, improved portability and simplified debugging, modifications and maintenance led to reliability and lower software costs. Third generation languages often followed procedural code, meaning the language performs functions defined in specific procedures on how something is done.


The fourth generation languages

Features evident in fourth generation languages [10] quite clearly are that it must be user friendly, portable and independent of operating systems, usable by non-programmers, having intelligent default options about what the user wants and allowing the user to obtain results fasts using minimum requirement code generated with bug-free code from high-level expressions (employing a data-base and dictionary management which makes applications easy and quick to change), which was not possible using COBOL or PL/I. Standardization however, in early stages of evolution can inhibit creativity in developing powerful languages for the future. Examples of this generation of languages are IBM's ADRS2, APL, CSP and AS, Power Builder, Access.


The fifth generation languages

The 1990's saw the developments of fifth generation languages [11] like PROLOG, referring to systems used in the field of artificial intelligence, fuzzy logic and neural networks. Complex processes like understanding speech would appear to be trivial using these fast inferences and would make the software seem highly intelligent. In fact, these databases programmed in a specialized area of study would show a significant expertise greater than humans. Also, improvements in the fourth generation languages now carried features where users did not need any programming knowledge. Little or no coding and computer aided design with graphics provides an easy to use product that can generate new applications.


The sixth generation

It is uncertain at the moment. With fast processors, like in fifth generation computers, able to have multiple processors operating in parallel to solve problems simultaneously will probably ignite a whole new type of language being designed. The current trend of the Internet and the World Wide Web could cultivate a whole new breed of radical programmers for the future, now exploring new boundaries with languages like HTML and Java. What happens next is entirely dependent on the future needs of the whole computer and communications industry.


12.4 Programming languages categories

Programming languages can be categories in various ways but a more practical way of classifying languages is to classify them by problem-domain or in other words, context. So we will have languages classified as:



  • System Languages

  • Architectural Languages

  • Application Languages


System Languages

These languages are best used to build operating systems, hardware drivers etc. they are fast and gives you low level (close to the core) access to the computer. These languages are used when speed is critical. These languages include:



  • C

  • C++

  • Assembler


Architectural Languages

These languages are best used to build frameworks that support (make easy) application building. They are not as fast (at run-time) as system level languages, but they provide a higher level of abstraction that makes writing software quicker and more productive. These languages include:



  • Java

  • C#


Application Languages

These languages are best used to build the actual business applications like web shopping carts/stores, connecting to databases and creating the screens for users to interact with the database. These languages include:



  • PHP

  • Ruby

  • Perl

  • Python

These languages all allow for extremely fast development. Programmers are freed from the low-level details that you have to contend with when working with architectural and system level languages. The fact that they’re all scripting languages (that don’t need to be compiled,) adds to the ease of use and speed of development.
12.5 Examples of Programming Languages

There are many examples of programming languages and some of them have already been described in the previous sections. If you want to know more about any of them or new ones, you may click on the following links.



  • A-0

  • Ada

  • ALGOL

  • Alphard

  • ALTRAN

  • APL

  • AspectJ

  • Assembly

  • Autocode

  • AWK

  • B

  • BASIC

  • BCPL

  • BLISS

  • C

  • C#

  • C++

  • CAML

  • CLOS

  • COBOL

  • Concurrent Prolog

  • CPL

  • CSP

  • dBASE II

  • Design System Language

  • Dylan

  • ECMAScript

  • Eiffel

  • Euler

  • FLOW-MATIC

  • Forth

  • FORTRAN

  • FP

  • GAP

  • Haskell

  • HTML

  • HyperTalk

  • Icon

  • IPL

  • ISWIM

  • Java

  • JavaScript

  • LISP

  • LOGO

  • MATH-MATIC

  • Mathmatica

  • Miranda

  • ML

  • Modula

  • Modula-2

  • Objective C

  • OPS5

  • Parlog

  • Pascal

  • Perl

  • PHP

  • Plantalkül

  • PL/I

  • PostScript

  • Pov-Ray

  • Prolog

  • Python

  • RATFOR

  • REBOL

  • Relational Language

  • RPG

  • Ruby

  • SASL

  • Scala

  • Scheme

  • Scriptol

  • Short Code

  • Simula

  • SmallTalk

  • SNOBOL

  • SQL

  • Standard ML

  • UML

  • UNIX shell script

Summary:

There were significant events in history that lead up to where we are today with Programming Languages. It started in 1949 when Short Code was invented. It is the first computer language actually used on an electronic computing device. The programmer was required to, by hand, change its statements into 0's and 1's for the processor to understand.


Programming languages allow the programmer to structure the instructions into functions, procedures, etc. This also allows the program to be broken into "chunks" which can be developed by a group of developers. Since we started, there are now five generations of Programming Languages. The first and second generation languages (1950-60) are languages which also called the machine and assembly languages. The second generation of programming languages used symbolic addresses allowed programmers to represent memory locations, variables and instructions with names. The third generation languages were considered as high level languages. The fourth generation languages quite clearly are that it must be user friendly, portable and independent of operating systems and usable by non-programmers. The fifth generation languages like PROLOG, referring to systems used in the field of artificial intelligence, fuzzy logic and neural networks.
Programming languages can be classified as: System Languages, Architectural Languages and Application Languages. System Languages are used when speed is critical. Architectural Languages are best used to build frameworks that support (make easy) application building. Application Languages are all scripting languages (that don’t need to be compiled,) adds to the ease of use and speed of development.

Exercises

Fill in the blanks:

  1. ….. are best used to build the actual business applications like web shopping carts/stores, connecting to databases and creating the screens for users to interact with the database.

  2. ….. are not as fast (at run-time) as system level languages, but they provide a higher level of abstraction that makes writing software quicker and more productive.

  3. …. are used when speed is critical.

  4. ….. generation languages quite clearly are that it must be user friendly, portable and independent of operating systems, usable by non-programmers.

  5. Languages like ALGOL 58, 60 and 68, COBOL, FORTRAN IV, ADA and C are examples of the …. generation languages.

  6. A ….. is important because it defines the relationship, semantics and grammar which allow the programmers to effectively communicate with the machines that they program.

  7. …. is an interpreted, object-oriented language. It is intended to be highly effective, easy to use, and extensible. Its syntax is very simple and statement-oriented.

  8. ….. was developed from the ground up as the language for business men. Its statements have a very English-like grammar, making it quite easy to learn, especially for the business men for which it was designed.

Answers:

  1. Application languages

  2. Architectural languages

  3. System languages

  4. Fourth

  5. Third

  6. programming language

  7. Python

  8. COBOL

Short essay questions:

  1. Describe the history of programming languages and its evolution to the present stage

  2. Why do we need to use programming languages?

  3. Describe the different generations of programming languages

  4. Describe the different categories of programming languages

  5. Provide 3 examples of programming languages and write short notes about them – why they are invented, the area which they are best used and their acceptance in the software development industry.

References:

Books:

  1. Diane M. Coyle, Computers Are Your Future, Complete, 10/E, Prentice Hall, 2009. ISBN-10: 0135045118, ISBN-13: 9780135045114.




  1. John Preston, Sally Preston and Robert L. Ferrett, Computer Literacy for IC3, Prentice Hall, 2009. ISBN-10: 0131498649, ISBN-13: 9780131498648.



  1. Alan Evans, Mary Ann Poatsy and Kendall Martin, Technology in Action, Introductory, 5/E, Prentice Hall, 2009. ISBN-10: 0135137667, ISBN-13: 9780135137666.



  1. Brian K.Williams and Stacey Sawyer, Using Information Technology: A Practical Introduction to Computers and Communications, 7th Edition, McGraw-Hill, 2007. ISBN-13 9780072260717.



  1. James A. O'Brien and George Marakas, Introduction to Information Systems, 13th Edition, McGraw-Hill, 2007, ISBN-13 9780073043555.


Online References:

[1] oreilly.com/news/graphics/prog_lang_poster.pdf



[2] www.byte.com/art/9509/sec7/art19.htm - 37k

[3] www2.lv.psu.edu/ojj/courses/ist-240/reports/spring2001/fa-cb-bc-kf/historyindex.html

[4] blog.thingoid.com/2004/05/programming-eight-things-2/

[5] answers.yahoo.com/question/index?qid=20090107143053AAS5VTA

[6] en.wikipedia.org/wiki/Low-level_programming_language

[7] wiki.answers.com/.../What_is_second-generation_programming_language_and_how_does_second-generation_programming_...

[8] www.computerhope.com/jargon/num/1gl.htm www.computerhope.com/jargon/num/1gl.htm

[9] science.jrank.org/pages/1695/Computer-Languages-Third-generation-language.html

[10] science.jrank.org/pages/1696/Computer-Languages-Fourth-generation-language.html

[11] doit.ort.org/course/languages/205.htm


The database is protected by copyright ©ininet.org 2016
send message

    Main page