PROGRAMMING LANGUAGE ONE

INTRODUCTION

PL/1 is a large and powerful multipurpose programming language. The intent of the designers

of PL/1 was to create a language that could be used in business and in scientific applications,

as well as in systems programming applications such as writing operating systems. The

original design was developed in 1963 by a committee of people drawn from IBM and from

SHARE, an IBM user group. For a long time the only important implementation of PL/1

were those developed by IBM on the 360 and 370 computers and the implementation of the

GE 645 at the MULTICS Project at MIT. However, during the early 1970’s a number of

other implementations arose. The implementation of PL/1 by other organizations was given

impetus by the development of a national and international standard for PL/1 by a

subcommittee of the American National Standard Institution, in conjunction with a similar

subcommittee of the European Computer Manufacturers Association.

There are different types of programming languages. Some are directly understandable by the

computers and others that require intermediate translation steps. Programming languages can

be divided into three general types.

1. Machine Language

2. Assembly Language

3. High-level Language

Machine language is the natural language of a particular computer. Any computer can

directly understand only its own machine language. As computers became more popular, it

became clear that machine language programming was very slow and tedious for the

programmers. Instead of using machine language, programmers began to use English-like

abbreviations (Assembly Language) to represent the elementary operations of the computer.

(ninjacraze, 2013) Assembly languages has translator programs caller Assemblers and

converts assembly language programs to machine language. With the help of assembly

language computer usage increased rapidly. Even though assembly language is faster than

machine languages to program, still assembly language is very slow. High-level

programming language were developed to speed the programming process.

PL/I ("Programming Language One", pronounced /piː ɛl wʌn/) is

a procedural, imperative computer programming language designed for scientific,

engineering, business and system programming uses. It has been used by various academic,

commercial and industrial organizations since it was introduced in the 1960s, and continues

to be actively used as of 2009 (Sturm, 2009). PL/I is a structured language to develop systems

and applications programs (both business and scientific). The definition of standard PL/1 was

formally released late in 1976, but the content of the standard was publicly known well

before then. The standard itself was written in a novel manner as a set of algorithms,

expressed in highly stylized English, for the operation of a hypothetical PL/1 machine

(Paul Abrahams, 1978).

HISTORY OF PROGRAMMING LANGUAGE ONE (PL/1)

In the 1950s and early 1960s business and scientific users programmed for different computer

hardware using different programming languages. Business users were moving from Auto

coders via COMTRAN to COBOL, while scientific users programmed in General

Interpretive Programme (GIP), Fortran, ALGOL, GEORGE, and others. The IBM

System/360 (Emerson W. Pugh, 1991) (announced in 1964 but not delivered until 1966) was

designed as a common machine architecture for both groups of users, superseding all existing

IBM architectures. Similarly, IBM wanted a single programming language for all users. It

hoped that Fortran could be extended to include the features needed by commercial

programmers. In October 1963 a committee was formed composed originally of 3 IBMers

from New York and 3 members of SHARE, the IBM scientific users group, to propose these

extensions to Fortran. Given the constraints of Fortran, they were unable to do this and

embarked on the design of a “new programming language” based loosely on Algol labelled

“NPL". This acronym conflicted with that of the UK’s National Physical Laboratory and was

replaced briefly by MPPL (Multipurpose Programming Language) and, in 1965, with PL/I

(with a Roman numeral “I” ). The first definition appeared in April 1964. (Committee, 1964)

(Rogoway, 1965)

IBM took NPL as a starting point and completed the design to a level that the first compiler

could be written: the NPL definition was incomplete in scope and in detail (Radin,

1978). Control of the PL/I language was vested initially in the New York Programming

Center and later at the IBM UK Laboratory at Hursley. The SHARE and GUIDE user groups

were involved in extending the language and had a role in IBM’s process for controlling the

language through their PL/I Projects. The experience of defining such a large language

showed the need for a formal definition of PL/I. A project was set up in 1967 in IBM Vienna

to make an unambiguous and complete specification. This led in turn to one of the first large

scale Formal Methods for development, VDM. The language was first specified in detail in

the manual “PL/I Language Specifications. C28-6571” written in New York from 1965 and

superseded by “PL/I Language Specifications. GY33-6003” written in Hursley from 1967.

IBM continued to develop PL/I in the late sixties and early seventies, publishing it in the

GY33-6003 manual. These manuals were used by the Multics group and other early

implementers. The first compiler was delivered in 1966. The Standard for PL/I was approved

in 1976.

PL/I was developed by IBM in conjunction with representatives of two customer groups:

SHARE, the scientific users' organization and GUIDE, the commercial users' organization.

PROGRAMMING PARADIGM FOR PL/1

A programming paradigm is a fundamental style of computer programming. (Gaglani, 2010)

It’s a way of building the structure and elements of computer programs. Different

programming languages support different styles of programming. Capabilities and styles of

various programming languages are defined by their supported programming paradigms;

some programming languages are designed to follow only one paradigm, while others

support multiple paradigms. There are several kinds of major programming paradigms:

Imperative — Control flow is an explicit sequence of commands.

Declarative — Programs state the result you want, not how to get it.

Structured — Programs have clean, goto-free, nested control structures.

Procedural — Imperative programming with procedure calls.

Functional (Applicative) — Computation proceeds by (nested) function calls that

avoid any global state.

Function-Level (Combinator) — Programs have no variables.

Object-Oriented — Computation is effected by sending messages to objects; objects

have state and behaviour.

o Class-based — Objects get their state and behaviour based on membership in a class.

o Prototype-based — Objects get their behaviour from a prototype object.

Event-Driven — Control flow is determined by asynchronous actions (from humans

or sensors).

Flow-Driven — Computation is specified by multiple processes communicating over

predefined channels.

Logic (Rule-based) — Programmer specifies a set of facts and rules, and an engine

infers the answers to questions.

Structured programming is a kind of imperative programming where the control flow is

defined by nested loops, conditionals, and subroutines, rather than via goto’s. Variables are

generally local to blocks (have lexical scope). Early languages emphasizing structured

programming: Algol 60, PL/I, Algol 68, Pascal, C, Ada 83, Modula, Modula-2. Hence, PL/1

is of the Structural Programming Language Paradigm.

Imperative, declarative, functional, object-oriented, logic and symbolic programming

(Normark, 2014). Imperative / algorithmic programming paradigm has the following

programming languages: ALGOL, COBOL, Ada, C, Modula, FORTRAN, Pascal and

BASIC. In imperative paradigm, computations are performed through a guided sequence of

steps, in which these variables are referred to or changed. The order of the steps is crucial,

because a given step will have different consequences depending on the current values of

variables when the step is executed. The declarative can be divided into functional

programming and logical programming. (Leavens, n.d.) The Functional Programming

paradigm views all subprograms as functions in the mathematical sense-informally, they take

in arguments and return a single solution. The solution returned is based entirely on the input,

and the time at which a function is called has no relevance. Programming languages under the

functional programming paradigm are; Lisp, Haskell, ML, Miranda, APL. The Logical

Paradigm takes a declarative approach to problem-solving. Various logical assertions about a

situation are made, establishing all known facts. Then queries are made. The role of the

computer becomes maintaining data and logical deduction. Programming language under

Logical paradigm is Prolog. Object Oriented Programming (OOP) is a programming

paradigm in which real-world objects are each viewed as separate entities having their own

state which is modified only by built in procedures, called methods. Because objects operate

independently, they are encapsulated into modules which contain both local environments

and methods. Communication with an object is done by message passing. Examples of

Object-Oriented paradigm are; Smalltalk, Simula, C++, Java. (Leavens, n.d.).

DESIGN AND STRUCTURE OF PROGRAMMING LANGUAGE ONE (PL/1)

The design of PL/1 drew heavily on the major languages that existed in 1963: Fortran, Cobol

and Algol 60. The syntax of PL/1 most resembles that of Fortran, but without

Fortran's rigid rules for program formatting. The notion of block structure was taken from

Algol 60, while PL/1 structures were taken from the record descriptions of Cobol. However,

a great many features were added to PL/1 that have no counterpart in its ancestor languages

(Abrahams, 1978).

PL/I's main domains are data processing, numerical computation, scientific computing,

and system programming; it supports recursion, structured programming, linked data

structure handling, fixed-point, floating-point, complex, character string handling, and bit

string handling. The language syntax is English-like and suited for describing complex data

formats, with a wide set of functions available to verify and manipulate them.

The building blocks of PL/1 is made up of a series of subprograms called procedures.

Program is structured into a Main Program and subprograms. Subprograms include

subroutine and functions. Every PL/1 program consists of at least one procedure, block and

groups.

A PL/1 program has three parts:

(A) Program Heading: This defines the program names and program parameters.

(B) Declaration Parts: defines the names of constants and variables.

(C) Statement Parts: Declares actions to be performed by the program.

Program Sample (Input, Output) {Program Headings}

Var {Declaration Part}

Name: string [20];

Age: integer;

Begin {Statement Part}

Writeln (‘what is your name?’);

Readln (Age);

Writeln;

Writeln {‘your name is’, Name. ‘and you are’, Age, ‘years old’}

End.

The first line is the Program Heading. The program heading shows that it takes user input and output. The second is the Declaration part, which declares variables or constants that assign memory space for that variables or constants. The third line is the statement part. It actually do the input, output and processing tasks. PL/1 programming language is a high level language that has

its own syntax rules and grammar rules. Below is an example of a simple PL/1 Program.

Program 1

Program Lesson1_Program1;Begin

Write ('Hello World. Prepare to learn PL/1!!');

Readln; End.

The program is written only to display the message: 'Hello World. Prepare to learn PL/1!!' -

An introductory message that is displayed to you whenever you are going to learn a new

programming language.

A program in PL/1 starts with the reserved or keyword word 'Program' (although it is not

explicitly required) and ends with 'End', following a full stop (this is required though). A full-

stop is never used within the program, except when dealing with records and at the end of the

program as seen in the example above.

The 'Var' statement, is used to introduce any suitable variables which will be used later in the

program. These variables are non-constant terms so that they are used in the program for

storing values. (Saliba, 2006) The terms 'Num1', 'Num2' and 'Sum' in the program are the

variables which store any numbers, except those which are real (in fact, during the execution

of the program, a runtime error may occur if a decimal number is input). As you can see in

the example above, these variables are assigned to as integers. The term 'integer' means any

whole number, i.e. a number which is not a decimal number but a positive or negative

number. The integer type ranges from -32768 to 32767. So values which are not within the

specified range cannot be stored by an integer type. There are other types which are wider in

range, but for now the integer type is enough to hold up our values. The variables 'Num1',

'Num2' and 'Sum' are terms which are not reserved words, but can be used as variables in the

program to store data in them. They could be changed more than once. Moreover, I could

have used 'number1', 'number2' and 'totalsum' (note that there must be no spaces within the

variables), instead of 'Num1', 'Num2' and 'Sum', respectively. As you can see, it is much

better to shorten the variables than writing long words, such as 'variable_number1'. (Saliba,

2006) After declaring all the variables which are required to be used later in the program, the

main program always starts with the reserved word 'Begin'. Without this word, the compiler

will display a diagnostic (error message). In the program above, both of the two types of

'write' are used. These are 'write' and 'writeln'. Both has the same function, except that the

'write' function, does not proceed to the following line when writing a statement. If you run

this program, you will notice the difference between them. When using these two terms, any

message that will be typed in between the brackets and the inverted commas '(' ')', is

displayed on the screen. However, if a variable is used instead of a message, without using

the inverted commas, the CPU will display the stored variable in the memory, on the screen.

In line 9, the CPU will not display 'Sum' on the screen, but the stored number in the memory.

Another important thing which must be noticed is the semi-colon (;). The semicolon is used

after each statement in the program, except those that you will learn later. However, in the

example above, there isn't a semicolon after a 'begin' statement. This is because the flow of

the program has just started and must not be stopped by a ';'. (Saliba, 2006) The messages in

between the braces ({ }) are called comments or in-line documentation. I guess you

consider the comments to be 'extra'. Very long programs which include thousands of lines,

have already been felt in need of describing certain functions or even complicated functions.

In my experiences, I have already met many problems, when refusing to write a program for

a long time, and then resuming again writing it! I've made a long time trying to understand

what I have done. You must keep it into your mind that comments within the braces are not

read or compiled by the compiler/interpreter. (Saliba, 2006) The 'readln' statement is another

reserved word for input purposes, which enables the user to input a number or text only i.e.:

using the keyboard. But in our case the 'readln' statement is used to input numbers only

(letters are accepted but will cause a run-time error because it is not the input we want) and

store them in the variables 'Num1' and 'Num2'. This is because both variables are assigned to

as integers, and integer variables do not store strings. A run-time error is detected by the OS

(Operating System; ex. Windows or Linux) if something goes wrong with the input. One

last thing on errors is this: there are 2 major error types which are - Runtime Errors and

Compilation Errors. Runtime errors are those which occur unexpectedly during the execution

of the program, whereas a Compilation error is one which is detected during the compilation

process. Note that a decimal number is also considered as a wrong input; a decimal number

must not be input, since it is a real number. (Saliba, 2006). After the prompts and inputs by

the user, follows the addition. i.e. 

Sum: = Num1 + Num2;

The result of the above statement is the addition of the values stored in variables 'Num1' and

'Num2'. The important thing that you should know is that one cannot make the same

statement as follows:

Num1 + Num2:= Sum;

This is another syntax error. It is the fact that transfer of information is from left to right and

not from right to left. So, mind not to make this error. The ':=' is called the assignment

statement.

HOW TO RUN A PROGRAM IN PL1

Open a text editor and add the above mention code

Save the File as hello.pas

Open a Command Prompt and go to the directory where u saved the file

Type fpc hello. at the command prompt and press enter to compile your code.

If there are no errors in your code, the command prompt will take you to the next line

and you would generate hello executable file and hello.o object file.

Now type hello at command prompt to execute your program.

You will be able to see “Hello World” printed on the screen.

TEXT EDITOR FOR PL1

Text editors are used to type your program. The following are a collection of editors and

development environments known to have support for PL/I and a link where it could be

downloaded.

GNU Emacs http://www.gnu.org/software/emacs

GNU Emacs is an extensible, customizable text editor—and more. At its core is an interpreter for Emacs Lisp, a dialect of the Lisp programming language with extensions to support text editing. Mark Riggle has developed a PL/I mode for Emacs that can be found here. Details of the most recent version of Emacs ported to OpenVMS can be found here.

jEdit http://www.jedit.org

  jEdit is a text editor written in Java. It runs on Windows, Unix/Linux, MacOS X and OpenVMS. Rob Watson has written a module that provides syntax highlighting for PL/I. This module thips with the editor which can be downloaded from here.

Vim http://www.vim.org

  Vim (Vi improved) is a vi-compatible text editor that runs on nearly every operating system known to humanity (including OpenVMS). Michael Fitz has written a plugin for Vim, PLI-Tools, that provides syntax highlighting and indentation. The plugin and instructions on how to install and use it can be found here.

GNU nano http://www.nano-editor.org

  GNU nano is a simple text editor designed to be a drop-in replacement for the Pico editor that is part of the Pine email suite. Tim Sneddon has written a simple syntax highlighting module that can be included in the user's .nanorc file. This can be downloaded here.

Language Sensitive Editor

http://h71000.www7.hp.com/commercial/decset/decset_index.html

The Language Sensitive Editor (LSE) is a commerical editor that ships as part of HP's DECset development tool chain for OpenVMS. It provides support for PL/I.

NetBeans http://www.netbeans.org

  PL/I integration to the NetBeans IDE will be coming soon!

Ecplise http://www.pliedit.com/

William Fenalson has developed PLIEDIT, a plugin for the Eclipse IDE. which provides a PL/I sensitive editor for the Eclipse framework.  It supports syntax checking, highly customizable syntax colouring and supports the full IBM and ANSI language features.

 

COMPILERS FOR PL1

The following are compilers used in compiling PL1 Programs:

Multics PL1 Compiler

GCC PL1 Compiler

Iron Spring PL1 Compiler for Linux

PL/1 RESERVE WORDS OR KEYWORDS

The statements in PL/1 are designed with some specific PL/1 words, which are called the

Reserve words or Keywords. The following are list of reserved words in PL/1.

input

downto

else

do

function

set

then

to

while

with

if

not

or

output

array

record

goto

unit

repeat

program

var

real

begin

readline

writeline

end

type

and

A MORE COMPLEX PROGRAM ON PL/1

This program reads in a text and counts the number of times that each alphabetic diagram occurs. A

diagram is a sequence of two adjacent characters. For instance, the diagram in ‘GRUNGE’ are GR,

RU, UN, NG and GE.

In PL/1 there must be one and only one MAIN procedure to every program, the MAIN procedure

statement consists of:

Label

The statement ‘PROCEDURE OPTIONS (MAIN)’

A semicolon to mark the end of the statement.

A PL/I program is compiled by PL/I compiler and converted into the binary, Object program file

for link editing.

Coding a Program:

Comment line(s) begins with /* and ends with */. Although comments may be embedded

within a PL/I statements, but it is recommended to keep the embedded comments minimum.

DATA TYPES

The different kinds of data in PL/1 can be classified into groups called data types, or simply types.

The available types are either aggregate types or scalar types. An aggregate is composed from

simpler types and can be grouped into printable and non-printable types, sometimes known as

computational and non-computational. For each type, there can be variables and values of that type;

for some types there can also be constants. A constant associates a name with a single unchanging

value, while a variable associates a name with a location where a value can be stored. The value of

a variable is in general time dependent. Variables are introduced into the program by DECLARE

statements, e.g.:

DECLARE LETTER_SEQUENCE CHARACTER (15) VARYING;

Which declares the variable LETTER_SEQUENCE to have character string of length from 0 to 15

as its values. Below is a table showing a brief summary of the Primitive Data Types Associated

with PL1.

PRIMITIVE DATA TYPES OF PL/1

The table below shows few of PL/1 data types.

Type Minimum Maximum Format

Integer -2147483648 2147483647 Signed 32-bit

Cardinal 0 4294967285 Unsigned 32-bit

Shortint -128 127 Signed 8-bit

Smallint -32768 32767 Signed 16-bit

Longint -2147483648 2147483647 Signed 32-bit

Int 64 -2ˆ63 2 ˆ 63-1 Signed 64-bit

Byte 0 255 Unsigned 8-bit

Word 0 65535 Unsigned 16-bit

Longword 0 4294967295 Unsigned 32-bit

ARITHMETIC OPERATOR OF PL/1

The table below shows all the arithmetic operators supported by PL/1. Assume variable A holds 10

and variable B holds 20, then:

Operator Description Example

+ Adds two operands A+B will give 30

- Subtracts second operand from the first A-B will give -10

* Multiplies both operands A*B will give 200

Div Divides numerator by denominator B div A will give 2

Mod Modulus Operator AND remainder after an integer division. B mod

A

B mod A will give 0

RATIONAL OPERATORS

Following table shows all the relational operators supported by PL/1. Assume variable A holds 10

and variable B holds 20, then;

Operators Description Examples

= Checks if the values of two operands are equal or not. If yes, then

condition becomes true.

(A=B) is not true.

<> Checks if the values of the two operands are equal or not, if values

are not equal, then condition becomes true.

(A <> B) is true.

> Checks if the values of left operand is greater than the value of

right operand. If yes, then condition becomes true.

(A > B) is not true.

< Checks if the values of the left operand is less than the value of

right operand. If yes, then condition becomes true.

(A < B) is true.

>= Checks if the value of left operand is greater than or equal to the

right operand. If yes, then condition becomes true.

(A >= B) is not true.

<= Checks if the value of left operand is less than or equal to the

value of right operand. If yes, then condition becomes true.

(A <= B) is true.

BOOLEAN OPERATORS

The following table shows all the Boolean operators supported by PL/1 language. All these

operators work on Boolean operands and produce Boolean results. Assume variable A holds true

and variable B holds false, then;

Operator Description Example

and Called Boolean AND operator. If both the operands are true, then condition

becomes true.

(A and B) is

false.

and then It is similar to the AND operator. However, it guarantees the order in which

the compiler evaluates the logical expression. Left to right and the right

operands are evaluated only when necessary.

(A and then B) is

false.

or Called Boolean OR operator. If any of the two operands is true, then

condition becomes true.

(A or B) is true.

or else It is similar to Boolean OR. However, it guarantees the order in which the

compiler evaluates the logical expressions. Left to right and the right

operands are evaluated only when necessary.

(A or else B) is

true.

<= Called Boolean NOT operator, used to reverse the logical state of its

operand. If a condition is true, then logical NOT operator will make it false.

not (A and B) is

true

FEATURES OF PL/1

PL/1 contains some significant language features that allow it to use as a powerful learning tool in

introducing structured programming techniques to students, business organizations and scientific

uses:

Built in Data Types- PL/1 contains its own built in data types of Integer, Real, Character,

and Boolean.

User defined Data Types - Has the ability to define scalar types as well as sub ranges of

those data types.

Provides a defined set of Data Structures- These data structures include Arrays, Records,

Files and Sets.

Has a strong data typing element – PL/1 compliers can diagnose an incompatible

assignment of one type to a variable to another type.

Supports Structured Programming - This is accomplished through the use of subprograms

called procedures and functions.

Simplicity and Expressivity - Because the language is simple and expressive in nature. it

allows for effective teaching of computer programming techniques.

It offers extensive error checking.

It offers several data types like arrays, records, files and sets.

It offers a variety of programming structures.

It supports structured programming through functions and procedures.

It supports object oriented programming

ADVANTAGES OF PL/1

PL/I has been designed so that any programmer, no matter how brief or extensive his experience,

can use it easily at his own level. It is simple for the beginning programmer; it is powerful for the

experienced one. A programmer need not know everything about PL/I to be able to use it. An

experienced programmer can use PL/I to specify almost every detail of every step of a highly

complicated program. A beginner can take advantage of the many automatic features of the

language to do much of his work for him. The language provides many options in statements, in

descriptions of data or files. Wherever there are alternatives, the compiler makes an assumption if

no choice is stated by the programmer. In each case, the assumption, called a default, is the

alternative that would be required. In the majority of situations. The default concept is an important

part of the simplicity of PL/I. In many cases, a beginning programmer need not even know that

alternatives exist. Some other advantages are:

1. Better integration of sets of programs covering several applications.

2. Easier interchangeability of files.

3. Fewer programs to be written in a machine oriented language.

4. Better machine utilization, greater use of channels, more flexible storage assignment, better

intercept handling.

5. The process of compiling a PL/I program and executing it in the computer’s memory takes

place through JCL.

BRIEF COMPARISON BETWEEN PL1 AND JAVA

PL1 JAVA

Exception

Handling

The concept of exception handling was

pioneered in PL1. It allows the user to

write exception handlers not only for

language-defined exceptions but also for

user-defined exceptions. The binding of

exceptions to handlers is dynamic

Java’s exception handling is

based on that of C++. Java

supports both system-defined

and user-defined exceptions.

Easy to Learn PL/I has been designed so that any

programmer, no matter how brief or

extensive his experience, can use it

easily at his own level. It is simple for

the beginning programmer; it is

Java provides many benefits as

a programming language. One

of the key benefits is, it’s easy

to learn. This is because when

developing Java, its

powerful for the experienced one.

NOTE: PL1 is not Platform

Independence.

developers (The Sun

Microsystem) took all of the

good features of the then

existing object-oriented

programming languages such

as C++, Smalltalk, Ada etc

and removed most of their

flaws and peculiarities, thus

making Java possess features

and processes that are

consistent and make sense;

and thereby make Java easier

to learn and it is Platform

Independence.

Paradigm PL/1 falls under the Structural

Programming Language Paradigm.

Java falls under the Object-

Oriented paradigm

Reliability PL1 is very reliable Java is also very reliable. Java

programs should not crash.

Platform

Independence

PL1 is not Platform Independence Java is Platform

Independence. You can write

your program once and

execute on different platform

without recompiling your

code.

Security PL1 is very reliable in the aspect of

security, PL1 is been used to develop

Operating System and it’s not

susceptible to Hacking. Example, some

segments of the code used in the

development of Linux Operating was

from PL1.

Java is also a very reliable

programming language in the

area of security. Java is design

not to be susceptible to

hackers, to code and

dangerous viruses.

REFERENCES

Committee, D. (1964). Report II of the SHARE Advanced Language Development Committee.

Retrieved from https://en.wikipedia.org/wiki/PL/I

Emerson W. Pugh, L. R. (1991). IBM's 360 and Early 370 Systems. Retrieved from wikipedia:

https://en.wikipedia.

Gaglani, J. (2010, April 14). Programming paradigm. Retrieved from SlideFinder:

http://www.slidefinder.net/p/programming_paradigms/32399652.org/wiki/PL/I

Leavens, G.T. (n.d.). Major Programming Paradigms. Retrieved from University of Central Florida:

http://www.eecs.ucf.edu/~leavens/ComS541Fall97/hw-pages/paradigms/major.html.

Ninjacraze. (2013). Types of Computer languages. Retrieved from ninjacraze:

http://ninjacraze.hubpages.com/hub/Types-of-Computer-Languages.

Normark, K. (2014, January 3). Overview of the four main programming paradigms. Retrieved

from http://people.cs.aau.dk/~normark/prog3-03/html/notes/paradigms_themes-paradigms-

overview-section.html.

Paul Abrahams. (1978). THE PL/I PROGRAMMING LANGUAGE. Retrieved from

http://www.iron-spring.com/abrahams.pdf

Radin, G. (1978). The Early History and Characteristics of PL/I. Retrieved from wikipedia :

https://en.wikipedia.org/wiki/PL/I

Rogoway, G. a. (1965). Highlights of a New Programming Language, . Retrieved from wikipedia :

https://en.wikipedia.org/wiki/PL/I