Jump to content

Fourth-generation programming language: Difference between revisions

From Wikipedia, the free encyclopedia
Browse history interactively
← Previous editNext edit →
Content deleted Content added
VisualWikitext
Hu12 (talk | contribs)
91,877 edits
m Reverted edits by 217.115.75.232 (talk) to last version by Lambiam
Slamcool (talk | contribs)
34 edits
No edit summary
Line 35: Line 35:


==Types==
==Types==
⚫
A number of different types of 4GLs exist:


[[Image:EDev01.gif|thumbnail|300px|An example of a Table-driven algorithm programming in eDeveloper 9.4]]
⚫
A number of different types of 4GLs exist:
*Table-driven (Codeless) programming, usually running with runtime framework and libraries. Instead of using code, the developer defines his logic by selecting an operation in a pre-defined list of memory or data table manipulation commands. In other words, instead of coding, the developer uses Table-Driven algorithm programming, a good example of this type of 4GL language is eDeveloper (View screenshot on right). These type of tool can be used for business application development usually consisting in a package allowing for both business data manipulation and reporting, therefore they come with GUI screens and report editors. They usually offer integration with lower level DLLs generated from a typical 3GL for when the need arise for more hardware/OS specific operations.
*[[Report-generator programming language|Report generator]]s take a description of the data format and the report to generate and from that they either generate the required report directly or they generate a program to generate the report.
*[[Report-generator programming language|Report generator]]s take a description of the data format and the report to generate and from that they either generate the required report directly or they generate a program to generate the report.
*Similarly, [[forms-generator programming language|forms generator]]s manage online interactions with the application system users or generate programs to do so.
*Similarly, [[forms-generator programming language|forms generator]]s manage online interactions with the application system users or generate programs to do so.
*More ambitious 4GLs (sometimes termed ''fourth generation environments'') attempt to automatically generate whole systems from the outputs of [[Computer-Aided Software Engineering |CASE]] tools, specifications of screens and reports, and possibly also the specification of some additional processing logic.
*More ambitious 4GLs (sometimes termed ''fourth generation environments'') attempt to automatically generate whole systems from the outputs of [[Computer-Aided Software Engineering |CASE]] tools, specifications of screens and reports, and possibly also the specification of some additional processing logic.
*[[Data management]] 4GLs such as [[SAS System|SAS]], [[SPSS]] and [[Stata]] provide sophisticated [[Command (computing)|commands]] for data manipulation, file reshaping, case selection and data documentation in the preparation of data for [[statistical analysis]] and reporting.
*[[Data management]] 4GLs such as [[SAS System|SAS]], [[SPSS]] and [[Stata]] provide sophisticated coding [[Command (computing)|commands]] for data manipulation, file reshaping, case selection and data documentation in the preparation of data for [[statistical analysis]] and reporting.


Some 4GLs have integrated tools which allow for the easy specification of all the required information:
Some 4GLs have integrated tools which allow for the easy specification of all the required information:

Revision as of 15:06, 5 March 2008

A fourth-generation programming language (1970s-1990) (abbreviated 4GL) is a programming language or programming environment designed with a specific purpose in mind, such as the development of commercial business software. In the evolution of computing, the 4GL followed the 3GL in an upward trend toward higher abstraction and statement power. The 4GL was followed by efforts to define and use a 5GL.

The natural-language, block-structured mode of the third-generation programming languages improved the process of software development. However, 3GL development methods can be slow and error-prone. It became clear that some applications could be developed more rapidly by adding a higher-level programming language and methodology which would generate the equivalent of very complicated 3GL instructions with fewer errors. In some senses, software engineering arose to handle 3GL development. 4GL and 5GL projects are more oriented toward problem solving and systems engineering.

All 4GLs are designed to reduce programming effort, the time it takes to develop software, and the cost of software development. They are not always successful in this task, sometimes resulting in inelegant and unmaintainable code. However, given the right problem, the use of an appropriate 4GL can be spectacularly successful as was seen with MARK-IV and MAPPER (see History Section, Santa Fe real-time tracking of their freight cars - the productivity gains were estimated to be 8 times over COBOL). The usability improvements obtained by some 4GLs (and their environment) allowed better exploration for heuristic solutions than did the 3GL.

A quantitative definition of 4GL has been set by Capers Jones, as part of his work on function point analysis. Jones defines the various generations of programming languages in terms of developer productivity, measured in function points per staff-month. A 4GL is defined as a language that supports 12 - 20 FP/SM. This correlates with about 16 - 27 lines of code per function point implemented in a 4GL.

Fourth-generation languages have often been compared to domain-specific programming languages (DSLs). Some researchers state that 4GLs are a sub-set of DSLs. [1] Given the persistence of assembly language even now in advanced development environments (MS Studio), one expects that a system ought to be a mixture of all the generations, with only very limited use of the first.

History

Though used earlier in papers and discussions, the term 4GL was first used formally by James Martin in his 1982 book Applications Development Without Programmers [2] to refer to non-procedural, high-level specification languages. In some primitive way, IBM's RPG (1960) could be described as the first 4GL followed closely by others, such as the Informatics MARK-IV (1967) product and Sperry's MAPPER (1969 internal use, 1979 release).

The motivations for the '4GL' inception and continued interest are several. The term can apply to a large set of software products. It can also apply to an approach that looks for greater semantic properties and implementation power. Just as the 3GL offered greater power to the programmer, so too did the 4GL open up the development environment to a wider population.

In a sense, the 4GL is an example of 'black box' processing, each generation (in the sense of the page) is further from the machine (see the Computer Science history in regard to data structure improvements and information hiding). It is this latter nature that is directly associated with 4GL having errors that are harder, in many cases, to debug. In terms of applications, a 4GL could be business oriented or it could deal with some technical domain. Being further from the machine implies being closer to domain. Given the wide disparity of concepts and methods across domains, 4GL limitations lead to recognition of the need for the 5GL.

The early input scheme for the 4GL supported entry of data within the 72-character limit (8 bytes used for sequencing) of the punched card where a card's tag would identify the type or function. With judicious use of a few cards, the 4GL deck could offer a wide variety of processing and reporting capability where as the equivalent functionality coded in a 3GL could subsume, perhaps, a whole box or more of cards.[3]

The 72-character metaphor continued for a while as hardware progressed to larger memory and terminal interfaces. Even with its limitations, this approach supported highly sophisticated applications.

As interfaces improved and allowed longer statement lengths and grammar-driven input handling, greater power ensued. An example of this is described on the Nomad page.

Another example of Nomad's power is illustrated by Nicholas Rawlings in his comments for the Computer History Museum about NCSS (see citation below). He reports that James Martin asked Rawlings for a Nomad solution to a standard problem Martin called the Engineer's Problem: "give 6% raises to engineers whose job ratings had an average of 7 or better." Martin provided a "dozen pages of COBOL, and then just a page or two of Mark IV, from Informatics." Rawlings offered the following single statement, performing a set-at-a-time operation ...

The 4GL evolution was influenced by several factors, with the hardware and operating system constraints having a large weight. When the 4GL was first introduced, a disparate mix of hardware and operating systems mandated custom application development support that was specific to the system in order to ensure sales. One example is the MAPPER system developed by Sperry. Though it has roots back to the beginning, the system has proven successful in many applications and has been ported to modern platforms. The latest variant is embedded in the BIS [4] offering of Unisys. MARK-IV is now known as VISION:BUILDER and is offered by Computer Associates.

Santa Fe railroad used MAPPER to develop a system, in a project that was an early example of 4GL, rapid prototyping, and programming by users. [5]The idea was that it was easier to teach railroad experts to use MAPPER than to teach programmers the "intricacies of railroad operations". [6]

One of the early (and portable) languages that had 4GL properties was Ramis developed by Gerald C. Cohen at Mathematica, a mathematical software company. Cohen left Mathematica and founded Information Builders to create a similar reporting-oriented 4GL, called Focus.

Later 4GL types are tied to a database system and are far different from the earlier types in their use of techniques and resources that have resulted from the general improvement of computing with time.

An interesting twist to the 4GL scene is realization that graphical interfaces and the related reasoning done by the user form a 'language' that is poorly understood.

Types

File:EDev01.gif
An example of a Table-driven algorithm programming in eDeveloper 9.4

A number of different types of 4GLs exist:

  • Table-driven (Codeless) programming, usually running with runtime framework and libraries. Instead of using code, the developer defines his logic by selecting an operation in a pre-defined list of memory or data table manipulation commands. In other words, instead of coding, the developer uses Table-Driven algorithm programming, a good example of this type of 4GL language is eDeveloper (View screenshot on right). These type of tool can be used for business application development usually consisting in a package allowing for both business data manipulation and reporting, therefore they come with GUI screens and report editors. They usually offer integration with lower level DLLs generated from a typical 3GL for when the need arise for more hardware/OS specific operations.
  • Report generators take a description of the data format and the report to generate and from that they either generate the required report directly or they generate a program to generate the report.
  • Similarly, forms generators manage online interactions with the application system users or generate programs to do so.
  • More ambitious 4GLs (sometimes termed fourth generation environments) attempt to automatically generate whole systems from the outputs of CASE tools, specifications of screens and reports, and possibly also the specification of some additional processing logic.
  • Data management 4GLs such as SAS, SPSS and Stata provide sophisticated coding commands for data manipulation, file reshaping, case selection and data documentation in the preparation of data for statistical analysis and reporting.

Some 4GLs have integrated tools which allow for the easy specification of all the required information:

Some successful fourth-generation languages

  • Data-stream languages
    • APE
    • AVS
    • Iris Explorer

See also

References

  1. ^ 35th Hawaii International Conference on System Sciences - 1002 Domain-Specific Languages for Software Engineering
  2. ^ Martin, James. Application Development Without Programmers. Prentice-Hall, 1981. ISBN 0-13-038943-9.
  3. ^ Columbia University Computing History: IBM Cards
  4. ^ Unisys. Business Information Server (BIS).
  5. ^ Louis Schlueter, User-Designed Computing: The Next Generation, 1988. [book on report generator and MAPPER systems]
  6. ^ McNurlin & Sprague. Technologies for Developing Systems Information Systems Management in Practice. Prentice Hall, 2003. ISBN 0-13-101139-1

This article is based on material taken from the Free On-line Dictionary of Computing prior to 1 November 2008 and incorporated under the "relicensing" terms of the GFDL, version 1.3 or later.

Retrieved from "https://en.wikipedia.org/w/index.php?title=Fourth-generation_programming_language&oldid=196046289"