COS 333: Chapter 2, Part 2

Summary

This lecture continues the exploration of high-level programming languages, covering Algol 60, COBOL, BASIC, PL1, APL, and SNOBOL. Algol 60 was influential but not widely adopted due to its complexity and lack of input/output support. COBOL was designed for business applications and emphasized English-like syntax. BASIC aimed to be easy for non-science students, leveraging time-sharing systems. PL1 sought to unify scientific and business computing. APL introduced powerful array operations but suffered from readability issues. SNOBOL focused on string manipulation and text processing. The lecture emphasizes the historical context and unique features of each language.

Takeaways

• 📚 The script discusses the evolution and development of major high-level programming languages, focusing on their historical context and design goals.
• 🔍 It provides an overview of Algol 60, highlighting its influence on subsequent languages and its goal of being a universal, machine-independent language, despite its limited adoption due to lack of I/O operations and string handling.
• 💼 COBOL is presented as the first widely adopted language for business applications, designed to be English-like and easy to use, with a focus on a detailed data division but a less powerful procedure division.
• 👶 BASIC (Beginner's All-Purpose Symbolic Instruction Code) was created with novice programmers in mind, emphasizing ease of learning, use, and a friendly approach for non-science students.
• 🔢 PL/1 (Programming Language 1) aimed to be a universal language applicable to both scientific and business computing, introducing features like concurrency, exception handling, and pointer data types, but was criticized for its complexity.
• 📊 APL (A Programming Language), also known as 'Apple', is noted for its expressive and powerful operators, especially for array operations, but is often considered hard to read due to its unique symbols and compact syntax.
• ❄️ Snowball is recognized as a dynamic language designed for text processing, featuring custom notation for string pattern matching, though its use is now limited compared to other languages.
• 🔑 The script emphasizes the importance of understanding the environment and needs that led to the development of each language, such as FORTRAN for scientific computing and COBOL for business applications.
• 🛠️ The design goals of each language are highlighted, showing how they were tailored to the specific requirements and limitations of their time, such as Algol 60's focus on algorithm description and machine independence.
• 📈 The script also discusses the challenges faced by some languages, such as Algol 60's lack of widespread adoption due to its initial design oversights and the competition with established languages like FORTRAN.
• 🔬 The development of programming languages is portrayed as an iterative process, with later languages building upon the innovations and addressing the shortcomings of their predecessors.

Q & A

What was the significance of ALGOL 60 in the history of programming languages?

ALGOL 60 was significant because it was an influential programming language that affected the development of most other high-level programming languages that followed it. It was designed to be machine-independent, aiming to be a universal programming language, and introduced many revolutionary concepts such as block structures with local scope for variables and sophisticated parameter passing mechanisms.

Why was COBOL designed and what were some of its unique features?

COBOL was designed as the first programming language intended for business applications. It was meant to be easy to use and understand, even for those without a strong technical background. Unique features included support for hierarchical data structures, long names with hyphens for better readability, and a separation of data and code with a detailed data division and a procedure division.

What was the purpose behind the creation of BASIC and how did it differ from other programming languages at the time?

BASIC, which stands for Beginner's All-Purpose Symbolic Instruction Code, was created to be an easy-to-learn and user-friendly language for non-science students. It differed from other languages by focusing on fast turnaround for homework assignments, being free and not vendor-specific, and treating user time as more important than computer time.

How did time-sharing systems influence the development and use of BASIC?

Time-sharing systems allowed multiple users to interact with a single powerful computer and its resources simultaneously. This enabled BASIC users to get real-time feedback on errors in their programs, promoting an iterative and interactive programming experience that was not possible with batch processing systems.

What was the goal of PL/1 and how did it attempt to achieve universality in programming?

PL/1 aimed to be a universal programming language applicable to different programming domains, particularly scientific computing and business computing. It attempted to achieve universality by incorporating features from both domains and by being designed to work with the IBM System/360 line of computers, which were intended for both scientific and business applications.

What are some of the major contributions of PL/1 to programming language design?

PL/1 introduced several major contributions, including the first unit-level concurrency, the first exception handling mechanism, the first pointer data type, and support for array cross-sections. These features influenced the design of subsequent programming languages.

Why was APL considered a very expressive programming language despite its complexity?

APL was considered very expressive because it had a large set of powerful operators that worked for both scalar and array values, allowing for the compact representation of complex operations such as matrix inversion and transposition. However, this also made APL programs difficult to read due to the large number of non-standard operators.

What is the primary focus of the Snowball programming language and how does it differ from other languages in string manipulation?

Snowball is primarily a string manipulation language designed for text processing. It differs from other languages by using its own custom notation for string pattern matching instead of regular expressions, which was a revolutionary idea at the time of its creation.

What were some of the challenges faced by the designers of ALGOL 60 in terms of implementation and adoption?

Some challenges faced by the designers of ALGOL 60 included the lack of input/output operations and string handling in the language specification, which limited its portability and实用性. Additionally, the formal syntax description in Backus-Naur Form (BNF) was considered confusing at the time, which may have hindered adoption.

How did the design goals of FORTRAN and COBOL differ, and what impact did these differences have on their respective uses?

FORTRAN was designed with a focus on scientific computing and efficient compiler performance, making it suitable for technical users. In contrast, COBOL was designed to be more English-like and easy to use for business applications, even at the cost of being less powerful. These differences led to FORTRAN being widely used in scientific fields and COBOL becoming the dominant language for business applications.

Outlines

00:00

📚 Evolution of High-Level Programming Languages

This lecture continues the discussion on the evolution and development of high-level programming languages. It reviews Plan Calcul, pseudo codes, FORTRAN (the first high-level language for scientific computing), and LISP (the first functional programming language). The focus then shifts to ALGOL 60, COBOL, BASIC, PL/I, APL, and SNOBOL. The significance and impact of these languages on subsequent developments in programming are emphasized.

05:01

🌍 ALGOL 60: Bridging International Gaps

ALGOL 60's development aimed to create a machine-independent programming language. It was a collaboration between European and American institutions. ALGOL 60 introduced several groundbreaking features, including a more sophisticated type system, flexible naming conventions, and compound statements. Despite its innovations, ALGOL 60 lacked input/output operations and string handling, which limited its adoption.

10:02

🖥️ ALGOL 58: A Foundation for ALGOL 60

ALGOL 58, the precursor to ALGOL 60, introduced key concepts like type declarations and flexible array handling. It supported compound statements and the colon equals assignment operator, which influenced later languages. However, ALGOL 58 did not include I/O operations, highlighting the tension between machine independence and practical implementation.

15:03

💼 COBOL: Business Programming Revolution

COBOL was designed for business applications with a focus on readability and ease of use. It featured hierarchical data structures, nested selection statements, and long, descriptive names. While COBOL's data division was highly detailed, its procedure division was less powerful, leading to verbose code. The language's adoption was significantly driven by the U.S. Department of Defense.

20:04

🎓 BASIC: Democratizing Programming Education

BASIC was created to teach programming to non-scientific users at Dartmouth College. It emphasized ease of learning, user-friendliness, and quick feedback through time-sharing systems. BASIC's design goals focused on simplicity, making it distinct from earlier scientific languages. Visual Basic and VB.NET are its modern descendants.

25:07

🖥️ PL/I: Universal Programming for All Domains

PL/I aimed to unify scientific and business computing under one language. Developed by IBM and SHARE, it introduced concurrency, exception handling, and pointer data types. Despite its innovations, PL/I's complexity made it difficult to learn and use. Its design philosophy of including every possible feature resulted in a large and unwieldy language.

30:08

🔠 APL: Expressive Yet Challenging

APL, designed by Ken Iverson at IBM, was noted for its powerful and expressive operators for scalar and array values. While APL programs could be written compactly, they were often difficult to read and debug. The language used a unique set of symbols, requiring special keyboards or overlays.

35:09

📝 SNOBOL: String Manipulation Pioneer

SNOBOL, developed at Bell Labs, specialized in string manipulation and pattern matching. Though revolutionary at its inception, SNOBOL was slower compared to other languages, limiting its widespread adoption. It is still used today for specific text processing tasks but remains less prominent.

40:12

🔍 Recap and Future Lectures

The lecture series continues to explore the history and development of programming languages, highlighting key features and impacts. Future lectures will cover additional languages, offering a comprehensive overview of the field's evolution.

Keywords

💡High-level programming languages

High-level programming languages are designed to be easy for humans to read and write, using syntax that is more abstracted from the machine code. In the video, languages like FORTRAN, COBOL, and ALGOL 60 are discussed as examples, highlighting their evolution and impact on programming.

💡ALGOL 60

ALGOL 60, or Algorithmic Language 1960, was a highly influential programming language that introduced concepts such as block structure and scope. Despite its influence on future languages, it was not widely adopted itself. The video explains its development and its role in shaping modern programming languages.

💡FORTRAN

FORTRAN, or Formula Translation, was the first high-level programming language and was designed for scientific computing. It is discussed in the video as a pioneering language that set the stage for subsequent developments in programming.

💡COBOL

COBOL, or Common Business Oriented Language, was designed for business applications. The video highlights its focus on readability and its widespread use in business environments, emphasizing its long-lasting impact.

💡LISP

LISP, or LISt Processing, is the first functional programming language, known for its use in artificial intelligence research. The video discusses its innovative approach to handling data structures like linked lists.

💡Time-sharing

Time-sharing is a computing technique that allows multiple users to share the same computer resources simultaneously, which was crucial for the development of languages like BASIC. The video explains how this concept enabled real-time feedback and accessibility in programming education.

💡Dynamic typing

Dynamic typing is a feature where the type of a variable is determined at runtime, not in advance. The video mentions this in the context of APL and SNOBOL, which are known for their dynamic features and flexibility.

💡Recursion

Recursion is a programming technique where a function calls itself to solve a problem. The video notes ALGOL 60 as the first imperative language to introduce sub-program recursion, marking a significant advancement in programming methodology.

💡Block structure

Block structure is a programming concept that involves grouping statements together, usually within 'begin' and 'end' blocks. This was introduced by ALGOL 60 and is fundamental in modern programming languages for defining scopes and managing variables.

💡BNF (Backus-Naur Form)

BNF, or Backus-Naur Form, is a notation technique for defining the syntax of programming languages. ALGOL 60 was the first to use BNF, which helped standardize the way languages were described and specified, as highlighted in the video.

Highlights

Introduction of ALGOL 60 as an influential yet not widely adopted programming language that impacted the development of subsequent high-level languages.

COBOL's distinction as the first programming language designed for business applications, highlighting its importance in the early days of business computing.

The significance of BASIC as an educational programming language aimed at teaching programming concepts to a broader audience.

PL/1's attempt as a general-purpose programming language capable of handling both scientific computations and business application development.

APL's innovative approach as an early dynamic language with a powerful set of operators for mathematical functions, despite its complexity and limited adoption.

Snowball's niche as a text processing language with custom notation for string pattern matching, illustrating the evolution of specialized programming languages.

The importance of understanding the environment in which programming languages like FORTRAN and LISP were developed to appreciate their design and functionality.

ALGOL 60's development as a machine-independent, universal programming language, marking a shift towards more portable code across different hardware platforms.

The unique design goals of COBOL, emphasizing English-like syntax and readability to cater to non-technical business users.

BASIC's design for ease of learning and use, reflecting its role in education and its impact on novice programmers.

PL/1's introduction of unit-level concurrency, exception handling, and pointer data type, showcasing its forward-thinking features in programming language design.

APL's use of a large set of operators for scalar and array values, demonstrating its expressive power despite readability challenges.

Snowball's specialized string manipulation capabilities, underscoring the development of programming languages for specific tasks like text processing.

The impact of time-sharing systems on the development of programming languages like BASIC, enabling faster turnaround times and private access for users.

The role of the US Department of Defense in mandating COBOL, illustrating the influence of military support on the adoption and development of programming languages.

The IBM System/360 project's requirement for a universal programming language like PL/1, reflecting the industry's shift towards more versatile computing solutions.

Transcripts

this is the second part of our

discussion

on chapter two where we will continue

looking

at the evolution and development of some

of the major

high-level programming languages

in the previous lecture we looked at

plan calcul

a prototype high-level programming

language that was never actually

properly implemented we also looked at

pseudo codes

languages intended for hardware

programming

that were not quite low-level machine

languages but

also not fully fledged high-level

programming languages

we then looked at the first two of our

proper high-level programming languages

fortran first of all which was the first

high-level programming language

and intended for scientific computing

and then we looked at

lisp which was the first functional

programming language

in this lecture we'll move on with

another five high-level programming

languages

we'll first look at algol 60 which was

a very influential programming language

and affected the development

of most other high-level programming

languages following

it but unfortunately wasn't very widely

adopted

itself we'll then look at cobol

which was the first programming language

intended for business applications

then we'll move on to basic which was a

programming language intended

for educational purposes to teach

programming we'll then look at pl1

which was the first attempt at a general

purpose

programming language that could do both

scientific

computations as well as business

application development and then we will

finish off our discussion

with a brief look at two early dynamic

languages

firstly apl or apple as some people call

it

and then snowball which was intended for

text processing

here we have the same diagram that i

introduced in the previous lecture which

illustrates

the evolutionary process of different

programming languages

and which languages influence the design

of other languages

so in the previous lecture we looked at

fortran over here and all of the various

versions of fortran all the way

to the most recent one and we also then

looked at the lisp programming language

over here which was the

first functional programming language

and affected the development

of subsequent functional programming

languages

the languages that we will be looking at

in this lecture

are underlined in red so we can see them

over here

you can see that they are all fairly

early programming languages still at

this stage

ranging from the 1950s into the 1960s

the first high-level programming

language we will consider in this

lecture

is algol 60. now when we were discussing

fortran

and lisp we saw that it was very

important for us to understand the

environments within which those

programming languages were developed

in order for us to understand the nature

of those programming languages

and the same is true for algol 60.

so the environment within which algol 60

was developed

was that fortran had been released but

it was still

a very new programming language and as

you should recall it was developed

specifically for the ibm

704 computer as well as subsequent

computers in the same line

now there were a number of other

high-level programming languages that

were being developed at the same time

and all of these languages much as was

the case with fortran

were designed for specific computers

now this meant that there was a little

bit of a problem potentially brewing

firstly none of these programming

languages were portable because they

were all designed for very specific

hardware

so this meant if you wrote a program on

one platform in one programming language

it was impossible to port that program

across to another programming language

and another hardware platform

so this meant if you wanted to port your

program to another platform you'd

essentially have to redevelop it from

the ground up

which was of course a huge waste of time

and effort additionally there was

potentially a communication

problem arising so programmers who were

used to working on one platform

with the programming language that was

specific to that platform

would not be able to very easily

understand programs written

in other languages for other hardware

platforms

and the reason for this is that as we

saw during our discussion on fortran

these programming languages were still

very much based

on the underlying hardware that they

were meant to

work with and so therefore the

control structures and the features

provided by the programming languages

were very much dictated by the hardware

and therefore

the features and structures within the

languages were vastly different from one

language

to the next so put another way there was

no programming language that could be

used universally as a means for

communicating

algorithms between programmers

so algo 60 then was developed from algol

58

and we'll talk about alcohol 58 in a

moment

um alcohol 58 was never intended to

actually be implemented

but algol 60 was meant to be implemented

as a fully featured programming language

and algol 58 and algol 60

were essentially then an effort to

design

a universal programming language now

universal in this context

means machine independence so in other

words a programming language that can

could work on any particular hardware

platform regardless of who the

manufacturer was

algol 60 was not a universal programming

language

in the sense that it had multiple

application areas it was still

a scientific language in the same way

that fortran

was because at this point the

application areas for all programming

languages were

essentially limited to scientific work

the design process for what would

eventually become the algol 58 language

specification

began in europe and was headed by

a german organization the society for

applied mathematics

and mechanics they later sent an

invitation to the acm

the association for computing machinery

which is based in the united states so

we can see that the design

effort of algol 58 which then eventually

led to algol 60 was the

first international attempt at least in

the sense of a collaboration between

europe and the united states

for the design of a programming language

the design process took place

within a meeting that ran over four days

so we can see that the design process

was fairly quick and that ran from the

27th of may to the 1st

of june in 1958

the programming language was first

called the

international algorithmic language or

ial

so you can see there once again the name

of the language focuses

on the fact that it was an international

collaboration

between europe and the united states

but fairly shortly after that the

language was renamed to the algorithmic

language

which was then shortened to algol

now the language design had three

main goals the first goal was that it

had to be close

to a mathematical notation the second

goal was that it had to be good for

describing algorithms

and the third goal was that it must be

possible to

translate the language down into machine

code now the first goal is

fairly obvious um once again as was the

case with fortran

this language was intended for

scientific applications therefore

it made sense that its notation had to

be close to a standard mathematical

notation

the third goal is also an obvious goal

because of course a high level

programming language must be

translatable down into machine code

so the first and third goals they're not

very interesting but the second goal

was quite unique and very important at

the time

so the language had to be good for

describing algorithms

which of course meant that the language

then had to be

more writable it had to be easier to

understand

and it also had to be machine

independent because it was intended for

describing

algorithms rather than the functioning

of a specific

computing platform the algol 58 language

specification

introduced quite a number of concepts

that were very revolutionary for the

time

now as we look at the language features

bear in mind that

the version of fortran that was

available at the time

was fortran one so first of all

algol 58 formalized the concept of type

and it introduced the notion of a type

declaration

recall that types were handled in

fortran

but there was a fairly simple type

system

and it was a fairly rudimentary

mechanism that was used to specify the

type

so fortran 1 did not use type

declarations

instead it used the first character of a

variable's name

to indicate the type of that variable so

a much more sophisticated much more

readable mechanism

used in algol 58 compared to fortran 1.

also names within algol 58 could be any

length

recall that in fortran 1 names were

limited

to 6 characters so much more flexible

approach in algol 58

and a much more readable approach as

well because

you could now use descriptive names for

your variables

and your sub programs arrays in algol 58

could also have any number of subscripts

in

fortran 1 arrays were limited to 3

subscripts

so once again a much more flexible

approach in algol 58.

parameters for subprograms in algol 58

were separated by mode namely in mode

and out mode parameters now we'll get

two parameter modes a little bit later

on in this course

but essentially in-mode parameters are

used to send data to a sub-program

whereas outmode parameters are used to

get results from

a sub program so you can think of out

mode parameters

as reference parameters or possibly

pointer parameters as they are used in c

plus algal 58 also

used brackets notation for its

subscripts which

is used in a lot of

modern high-level programming languages

still and this

is particularly the case in c based

programming languages like c

plus java and c sharp also

interestingly algol 58 allowed the

programmer to specify the lower bounds

for their subscripts so you could decide

for example

if you wanted your arrays to start at

subscript 0 or

subscript 1. in 4chan 1 all arrays

started at subscript 1.

so again a much more flexible approach

in algol 58.

algol 58 also supported compound

statements and it used

special words begin and end to indicate

the beginning and the end of these

compound statements

it also used a semicolon as a statement

separator

and this convention is still used today

in a lot of high-level programming

languages

once again in particular the c-based

programming languages

the assignment operator was the colon

equals operator as we can see over here

and the evolution of this operator

notation is quite

interesting so recall in plan calcul

that assignments took place from left

to right in other words the destination

that you were assigning to

appeared on the right hand side of the

assignment operator

it used an arrow notation so essentially

an arrow pointing from

left to right which was represented as

an equal symbol followed by

a greater than symbol now algol 58

used the assignment order convention

that fortran used so in other words an

assignment from

right to left with the destination

variable on the left hand side

of the assignment operator but it also

then

attempted to use the arrow notation that

was used in plan calcul

so that would have then been represented

as a less than symbol

followed by an equals symbol

however because punch card systems were

being used at the time

and the character sets for the punch

card systems were fairly often limited

at the time and the less than symbol

was often not included in the supported

character set

so therefore the less than symbol was

replaced with a colon

and that's how the eventual assignment

operates a notation that was used

was arrived at this colon equals

notation

is still used in some high-level

programming languages today

algol 58 also supported if statements

with an

else if clause so this allowed if

statements to be nested inside one

another

and this kind of nesting was not allowed

in fortran 1.

now the last point is quite interesting

the language specification for algol 58

did not

include any io operations

and this was done because the designers

of the language felt that it would make

the language machine dependent now

you should immediately be thinking that

this

is a little bit of a strange oversight

because the

emission of io operations from the

language specification

would mean that each implementation of

the algol 58 language for a particular

hardware platform

would require a different io

implementation

and this would by definition then make

the language implementations

not cross-compatible and would therefore

eliminate the possibility of

porting program code from one hardware

platform to another

so this essentially undermined then one

of the core

ideas underlying algol 58 that the

language should be

machine independent and universal

now algol 58 was never meant to be

implemented as a concrete programming

language

the specification was intended for

discussion which would later lead to

a formalized specification that would

then actually be

implemented despite this though some

variations of the language specification

were actually implemented

and two examples of this are mad and

jovial ibm was initially pretty

enthusiastic about

algol 58 but by the middle of 1959

they had dropped all support for the

language and the reason for this

was that they were focusing on fortran

so ibm had basically realized that

specifying

a high-level programming language

developing a

compiler that was efficient

and effective and then also convincing

users to use the language and the

compiler

took a great deal of effort and they

just weren't prepared to support

a second programming language so they

decided to refocus all of their efforts

on

fortran and its continued development

the algol 58 language specification was

extended into the algol 60 language

specification

which was then eventually implemented

now this extension of alcohol 58 took

place

over a six-day design meeting which was

hosted in paris

so the design process took two days

longer than the four-day design process

of algol 58

but still an incredibly short design

process

for a full programming language

as with algol 58 algos 60 introduced a

number of new features

and a lot of them were also very

revolutionary for the time

so the compound statements that were

included in algal 58

were extended into block structures and

these structures had

local scope for variables this

was a very revolutionary concept for the

time and it was only

finally introduced in fortran in the

2008 release of that language

algol 60 also had very sophisticated

parameter passing mechanisms

so it supported pass by value which you

will be familiar with

but it also supported pass by name which

you will not have encountered yet

pass by name is a very flexible approach

to parameter passing

however it can be fairly difficult to

understand

and we'll look at all of the parameter

passing techniques

later on in this course algol 60 also

introduced sub-program recursion

and it was in fact the very first

imperative programming language to

introduce

this concept algol 60 also supported

stack dynamic arrays

so these are arrays that allow the

size to be declared at run time

which means that these arrays are much

more flexible

in terms of how they can be used and how

their space can be allocated

again this feature was only introduced

much later within fortran

however the alcohol 60 language

specifications still didn't include

any i o operations at all and it also

didn't include

any string handling mechanisms so these

two emissions were major oversights

within the language specification

and major contributors to the fact that

algol 60 was not a very widely used

language

after it was released

so if we look at the overall evaluation

for algol 60

we see that it is a language that had a

lot of successes

in terms of features that it introduced

and

influences that it had on subsequent

programming languages

however unfortunately the programming

language overall was a failure

particularly in terms of its use

as a practical programming language so

if we look at the successes of algol 60

well it definitely succeeded in terms of

being

a communication system for algorithms

it was the standard way of publishing

algorithms

in journals for over 20 years

it was also the basis for all subsequent

imperative

programming languages a very very

influential language

you should have been able to tell from

the previous discussions

on the language features that most of

those features

are still present in modern programming

languages in one form

or another it was also the very first

machine independence programming

language

machine independence is a major focus of

modern programming languages

and then interestingly in terms of the

formal specification of the language

it was the very first high-level

programming language whose syntax was

formally defined and this syntax

specification

was in bnf the bacchus noir form

which is a very standard mechanism still

used today

for specifying the syntax

of programming languages despite

these successes algol 60 unfortunately

wasn't a very widely used programming

language and in that sense

was a bit of a failure it wasn't very

widely used particularly in the united

states

and even in europe where it was more

widely used it didn't become

a very dominant programming language now

there are a number of reasons for this

firstly

as i've previously suggested the

lack of input and output operation

support in the specification as well as

the lack for

string handling limited the portability

of the programming language and this of

course was one of the major goals behind

the design of

algol 60. in a lot of senses algol 60

was also a little bit

too flexible particularly for

programmers of the day

it was a bit hard to understand and the

compilers were a bit difficult to

implement

at the time particularly concepts like

the pass by name parameter handling

mechanism

were fairly difficult for programmers of

the day to wrap their heads around

also the formal syntax description in

bnf

was considered to be fairly confusing at

the time

now this of course has turned out in

retrospect

to not have been that much of an issue

bnf is very widely used today

to specify syntax however at the time it

was considered

confusing and this scared a lot of

people off

from the adoption of the programming

language

um also there was the entrenchment of

fortrans

so as i've previously mentioned ibm

focused all of their resources

on the development and promotion of

fortran

as a high-level scientific programming

language

and really at the stage that algol 60

became available

fortran was so widely used that algol 60

really couldn't make

a dent in that at all

ibm also dropped all of their support

for algol 60

so this meant essentially that the

european organizations

were attempting to promote the language

on their own

and this of course limited the success

of their efforts

the next high-level programming language

we'll consider

was the very first widely adopted

programming language

intended exclusively for the development

of business applications namely cobol

early on in the design process for cobol

the language was called the common

business language or cbl

but later on it was renamed to the

common business oriented language

from which cobol was derived now once

again we need to consider

the environment within which cobol was

developed

and what we see is that the majority of

high-level programming languages at the

time

were intended for scientific

applications

there were not many programming

languages that

were intended for more business-like

application areas

and the languages that did exist were

relatively rudimentary

and not very widely used there were also

proprietary languages so they were

developed by one

specific vendor for their specific

hardware platforms

so what we see at the time is that

univac was beginning to use

a language called phlomatic the united

states

air force had started using a language

called imaco

and ibm had begun development on a

language called

comtran but they hadn't yet implemented

it

so the closest to a fully featured

business oriented programming language

was flomatic at the time

and in fact cobol took a lot of ideas

from flomatic

and then developed those into a fully

featured

business oriented programming language

because cobol was based on flomatic

we need to first of all consider some of

the major features

of the phlomatic programming language so

what we see

is that phlomatic was designed with

business users in mind

in other words not scientifically

oriented users

and definitely not technically oriented

users

what this means is that the language set

out to be

more english-like in its structure

rather than

more mathematical so that it would be

easier

for these non-technical non-scientific

users

to write programs so we see that names

in phlomatic were allowed to be up to 12

characters long

so in other words generally much more

readable and much more descriptive than

one would see in a language like

fortran they also allowed embedded

hyphens within the names

which meant that you could separate

individual words from one another

interestingly no arithmetic operators

were supported so english names were

used for all of the arithmetic

operations in other words you would use

the word add rather than

a plus symbol so this meant that there

were no

arithmetic expressions and the intention

behind this

was that the mathematics of programs

written in phlematic

would be more readable to the lay person

rather than only understandable by

people with a mathematical background

the first word of every statement was

also a verb so again a much more

english-like syntax

and then very importantly the data that

the program would work on

and the code that would do the

processing were completely separate

from one another and this is an idea

that was carried

across into cobol which we'll talk about

in a moment

interestingly the early design process

of cobol

had quite a lot of military involvement

and this was because the united states

military required a business programming

language

in order to implement their

administrative systems

the first design meeting in fact took

place at the pentagon

and this was in may of 1959

so there were four major design goals

set out for the language

the language had to look like simple

english

the general belief at the time was that

business programmers were not

comfortable

with mathematical notation and the

language also had to be easy to use

even if it meant that the language was

less powerful because of this

so you can see much more of a focus on

the readability

and the understanding of programs

written

in the language less emphasis

on the power and the efficiency of the

compilers as we saw was the case in

fortran the language also had to broaden

the base

of computer users so that was then

beyond

the realm of very technical and

scientifically oriented programmers

and the language also had to not be

biased by

current compiler problems of the day

so the design committee members then

were from

the various department of defense

branches within

the united states military but also

there were representatives from all of

the various computer manufacturers

of the day and so there were lots of

then different

parties involved in the design process

each with their own particular

agendas so this then led to a fairly

difficult design

process with a lot of fights among the

various manufacturers

a lot of questions were raised such as

should arithmetic expressions be

supported or should they not

should only english-like words be used

for

the components of arithmetic expressions

should subscripts be supported

for arrays or should they not be

supported

and so all of these issues were hotly

debated

until eventually a complete design for

the language was

arrived at let's now look

at an overall evaluation of the cobalt

programming language

so we see a number of features

introduced by

cobol most of these features are not

very groundbreaking however

but there were a few contributions made

so

cobol introduced the very first support

in a high-level programming language for

macros

which we still see today in high-level

programming languages

but probably the most important

contribution

that cobol made to high-level

programming languages was support

for hierarchical data structures which

today we would call records

or structs it also supported nested

selection statements

which as you will recall were not

supported in early versions of

fortran names were also relatively long

so you could have names up to 30

characters long including hyphens

so again contrast that to the very

limited

naming conventions allowed within the

early versions of

fortran now typically cobalt programs

are constructed out of

two main parts this first of all the

data division that specifies the

structure of the data that the program

will operate on

and then there's a procedure division

that includes the actual program

code that will do the processing of the

data

so cobol is notable because the data

division

is incredibly detailed

it's separated from the rest of the

program so you can immediately see

all of the relevant pieces of data

you also have these hierarchical

nested data structures as i previously

mentioned which would be included

in the data division so for example you

might have

a structure that contains information

related

to the name of an individual including

the first middle and last name

and that could then be embedded in

another structure

that contains other information related

to the individual

so a very detailed data division however

the major drawback associated with cobol

is that the procedure division that

actually specifies

the computations is relatively

weak so as i mentioned before

there's a major reliance on english-like

structures

using words rather than operator symbols

and this makes the code very verbose

and there's also not support for a rich

set

of very powerful operations within the

procedure division

for example there was in the initial

specification of the cobalt programming

language

no support for sub-programs that

included parameters

so a major focus on the description of

data but less of a focus on

sophisticated processing

of that data so what i'd like you to do

at this point is pause the video

and consider why it was important for

kobold to have support for such a

detailed data division

but why it wasn't that important for the

procedure division

to be as powerful

now as i previously mentioned the us

military had a lot of involvement

in the early development of cobalt

through the u.s

department of defense or dod and in fact

kobold was the very first programming

language whose use was mandated by the

department of defense

and in fact cobalt probably would have

failed as a

programming language were it not for

this military support

the reason for this is that the first

cobol compilers

had very poor performance and this

increased

their cost of usage substantially

however because the programming language

was mandated by the department of

defense

this ensured that it had a user base and

so slowly over time better and better

compilers were developed

and eventually when the department of

defense dropped the mandate that ensured

the usage of

cobalt then the compilers were

sufficiently good

for the language to be more widely

adopted

today cobol is still probably the most

widely used business application

language according to some people this

is a testament to

how well designed the language is

according to

other people cobol is a relic of the

past

and is best forgotten i'll allow you to

draw your own conclusions on this

however

the next high-level programming language

that we'll very briefly consider

is basic which stands for the beginner's

all-purpose symbolic instruction code

so we can immediately tell just by

looking at the name of the programming

language

that it was intended for novice

programmers

basic was designed by kemeny and kurtz

at

dartmouth college which is now dartmouth

university

and dartmouth is a liberal arts campus

meaning that it doesn't focus on the

sciences

or on engineering this means that the

intended users of basic are very

different

to the users that previous programming

languages were developed for

and this meant that basic had a set of

fairly unique design goals

so firstly basic had to be easy to learn

and use for non-science students and it

also had to be

pleasant and friendly to use

so these two requirements indicate that

the language could not be very technical

it had to be fairly high level it had to

be fairly user friendly

the language had to be relatively

stripped down and not

very complex and it also

then had to be usable by people without

a very strong science

or mathematical background basic

also had to offer very fast turnaround

for homework

and this is a very important requirement

which we'll get back to in a moment

it also had to be free so in other words

not

tied to a particular vendor

such as fortran was tied to ibm for

example

and it also had to offer private access

so this meant

that individual students had to be able

to work on their homework work

assignments

on their own and they had to be able to

do that without

taking up resources from other students

also then finally basic had to

treat user time as much more important

than computer time

so this is in direct opposition to the

design

goals of fortran where the performance

of the compiler

was the most important thing

so we can see then a very different

focus area for basic compared

to the scientific programming languages

that had come before

and to understand the development of

basic and nature of basic we also then

need to consider time

sharing because time sharing and basic

go

hand in hand both were developed at the

same time

so this also then relates to the

requirement for

fast turnaround time and also private

access so what we see is prior to time

sharing usually the computers that we

used were very powerful computers

and they performed batch processing so

this means that a programmer would write

up their program they'd code their

program onto typically punch cards

which would then be loaded into the

computer by an operator

in a designated time slot and the

program

would then execute now this of course

does not facilitate

fast turnaround for homework and it also

doesn't facilitate

private access because of course as one

user

is running their program that prevents

other users

from running their programs

so time sharing then addressed this

problem

by introducing the notion of a single

powerful computer and then a number of

terminals connected to that computer

the terminals do not perform any major

processing on their own they are

essentially

only input terminals so

what this then means is that the central

computer can then

rotate through the users and allocate

each user

a small time block and this then gives

the illusion to the user that they are

interacting with the system in real time

when in fact what they are doing is

working in parallel with other users and

everybody

is sharing the central computers

resources

now what this then meant for basic was

that users

could use the time sharing system in

parallel

but also more importantly they could get

real-time feedback

on errors within their programs so no

longer did you write this batch program

wait for it to finish

executing and then see that there were

errors which you'd have to fix

you could make a small change to your

program re-run it

look at further errors that had occurred

correct those errors and continue that

way in an iterative

fashion so this was a very important and

very powerful concept

and this changed how high-level

programming languages

were used from this point on now basic

in its original form is not really used

today however there are some dialects of

basic

that do still exist and are fairly

widely used today and the two most

important of those are visual basic

and vb.net which is part of the.net

framework

we won't be looking at basic in any

further detail within this course

and the language is more interesting in

terms of the context that was developed

in

the kinds of programmers that it was

developed for

and its reliance on

time sharing systems

next we'll look at a programming

language called pl1

which is a shortening of the name

programming language one

now what we saw earlier on in this

lecture is that algol 60

was designed to be a programming

language

that was universal in the sense

that it was a hardware independent

programming language

so in other words programs written in

algol 60

could be ported to other hardware

platforms without

too much trouble however at its core

algol 60 was still a scientific

programming language

now pl1 also set out to be a universal

programming language

however it was intended to be universal

in the sense that it could be applied to

different programming domains and not

just

scientific computing so at the time

the two main programming domains that

were

possible were scientific computing and

business computing

and pl one set out to be equally

applicable

in both of those programming domains

so pl one then was developed at ibm it

also

involved share which was a user group

for

scientific computing at ibm and the user

group

essentially is a group of individuals

who are all working within the same

domain

they would maintain discussion forums

and mailing lists and so on

in order to communicate with one another

and help each

other out with problems that they

encountered

so in the early 1960s then from ibm's

perspective

there were two main programming domains

firstly scientific

computing as i mentioned and business

computing

and what we see within those domains is

that each of the domains had their own

particular hardware platforms in terms

of computers

that they were using so in the case of

scientific computing it was the ibm

1620 computer and the 7090 computer

in the case of business computing it was

the ibm

1401 computer and the 7080

computer we also see then that each

domain

had its own particular programming

language in the case of scientific

computing it was fortran

and cobol in the case of business

computation

and then finally each domain had its own

particular user group which was

share in the case of scientific

computing and guide

when it came to business computing so

what we see essentially is that

there was a separation that had

developed between scientific computing

and business computing

both domains required very different

tools and strategies they had their own

particular hardware platforms their own

programming languages

and the kinds of users in these domains

were very different and did not really

talk with one another

however in 1963 we begin

seeing new demands arriving from

both the field of scientific computing

and

business computing so scientific

programmers

were beginning to demand better input

output support

as was provided by the cobol programming

language

and business users were beginning to

develop

management information systems which

then required more sophisticated

computations and therefore support for

floating point numbers and arrays which

were provided by

fortran so we sort of see a kind of a

merging of the requirements of these two

fields however there was then of course

a problem that was developing within

organizations so basically

if you were in either one of these two

domains and you needed to then

support these additional requirements

that were developing it meant that an

organization would have to maintain

two different sets of computers as well

as two different sets of programming

languages

and then two separate sets of support

staff

and this was obviously turning out to be

very expensive

and in general it was becoming too

expensive for most

companies and organizations to handle

so the obvious solution to this at least

from ibm's perspective

was to build a new computer that was

applicable

to both the domains of scientific

computation

and business computation and this was

the ibm

system 360 line of computers

then of course they needed a new

programming language that was applicable

to

both application areas both scientific

and business

computing but in addition then just to

cover all of their bases they decided to

throw in

systems programming as well so

essentially systems programming involves

the development

of operating systems

which we spoke about in the first

chapter

and then they also decided to

incorporate list processing which you

would typically see

in artificial intelligence applications

of the day

the design process for pl one ran over

five months still a fairly short design

timeline however we can see that

the programming language designers had

realized

that the specification of a programming

language

should take longer than around six days

which was

the case for algol 60. so the design was

conducted by what was called the three

by three committee and this was because

three of the members of the committee

came from ibm

and three of the members came from the

share user group so you can see

involvement of the people who were

actually going to be using

the programming language the initial

concept behind pl1 was that it would be

an extension

of fortran four which would be called

fortran six

but they fairly quickly realized that

this was

a fairly large and complex task

and therefore they fairly

shortly after this initial idea

refocused their efforts into developing

an entirely

new programming language the language

was initially named

npl the very creatively named new

programming language

however fairly shortly after that the

name was changed to

pl1 and this happened in 1965.

now if we evaluate the pl1 programming

language

what we see is that it introduced a

number

of very important very revolutionary

features

which are still used today in modern

high-level programming languages

we also see that the programming

language was reasonably widely used at

least

initially however from a programming

language design perspective

the language was a bit of a failure

so if we look first at all at pl1's

major contributions

we see that the language introduced the

very first unit level concurrency

so essentially allowing different

portions of the program to execute

concurrently and then from a user's

perspective

it would appear as if these units were

executing at the same time of course

what was actually happening behind the

scenes

was that the computer's processor was

switching back and forth between the

tasks that were running concurrently

pl1 also introduced the very first

exception handling

mechanism for recovering from errors

and we see that this idea has been

developed further in modern programming

languages like java

and c-sharp and we also see that pl one

introduced the very first pointer data

type

also very important contribution now

with these three contributions

concurrency support for exception

handling and the pointed data type

while these ideas were very important

and influenced

subsequent programming languages these

three features were not

implemented very well their design

lacked

somewhat and they weren't very usable

however very

important ideas that were introduced pl1

also supported the very first array

cross

sections now we'll talk about array

cross sections later on in the course

in the context of array slicing but

essentially what cross sections allow

you to do is to retrieve

a portion of an array or a portion of a

multi-dimensional

array structure which means that that

portion is then more manageable to work

with from a programmer's perspective

also very interestingly pl one supported

recursion

but recursion was switch selectable

so what this meant was you could choose

to disable recursion

and in that case you would then have

less flexibility

because you wouldn't be able to write

recursive sub

programs however when your program was

compiled to an executable

then this executable would be much more

efficient in terms of execution time

so essentially this allowed the

programmer to decide whether they wanted

more flexibility at the expense of

performance

or vice versa and in this respect the

pl1 programming language

was very flexible from a programmer's

perspective

however there were two major concerns

when it came to the language design

of pl1 so firstly as we've just

seen a number of the features introduced

in the programming language were poorly

designed and very difficult

to use but most importantly

the programming language was very large

and very complex

and this was because the design

philosophy of pl1

was to incorporate every possible

structure

from the domain of scientific computing

as well as the domain of business

computing

and any feature that was potentially

useful

was crammed into the programming

language so essentially the strategy was

to include

everything and the kitchen sink and then

also

a number of new features were introduced

by the programming language

so what this meant then was a very

complex programming language

it was virtually impossible for

programmers of the day

to fully understand all of the features

provided by

the programming language and we'll get

to how this approach was then handled in

a different way in algol

68 which made algol 68 a much more

manageable

programming language the last

two programming languages that we will

consider in this lecture

are the apl or apple programming

language

and the snowball programming language

note that the name

of the second programming language is

pronounced snowball

not snowball so both of these languages

they're not characterized as dynamic

languages

and as we'll see later on in this course

dynamic

languages or languages that incorporate

features

that execute at run time

so both of these languages are

considered dynamic because they both

provide dynamic typing and dynamic

storage allocation

and essentially what this means then is

that both

the type of a variable as well as the

storage allocation in memory

for that variable are decided at

runtime only when a value is assigned

to that variable so this is a very

flexible feature within a high-level

programming language it's also

potentially a fairly dangerous feature

and we see dynamic type binding and

dynamic storage

allocation is supported in quite

a number of modern high-level

scripting languages dynamic storage

allocation

is also supported in languages that

don't support

dynamic typing for example we see its

support

in languages like c plus as well as java

and c but we'll speak about these

concepts in more detail

later on in the course let's first of

all

look at the apl or apple programming

language in some more detail

the name of the language is an

abbreviation of a programming language

so again you can see a very creative

title for this

programming language and a programming

language was actually the name

of the book in which the language was

specified and described

the language was designed at ibm by ken

iverson

around 1960 and it was originally

intended to be

a hardware description language however

its use

fairly quickly expanded beyond that

domain

now it's generally considered to be a

very expressive programming language

and the reason for this is it has a very

large set

of very powerful operators and these

operators

work for scalar values as well as array

values

with various dimensions

and so to give you an idea there is for

example

a single operator that can perform a

matrix inversion there's also an

operator

to transpose a matrix and there's

an operator for performing a product

between matrices so a very powerful set

of operators

very useful operators and therefore you

can write

fairly complex programs relatively

compactly

however and of course opinion differs on

this between programmers but in general

most programmers would say that an apl

or apple program is fairly difficult to

read and again this is because

of the large set of operators that one

has to keep track of

there are in fact so many operators in

apl

that there are not sufficient symbols

on a standard keyboard to support all of

those operators

and in the next two slides i'll show you

some examples of the operators as well

as

programs written in the apl or apple

programming language

the language is still used today it's by

no means a very widely used language

but it hasn't been changed much from its

original

specification

so over here we have some additional

material that i dug

up just to illustrate the nature of the

apl

or apple programming language on the top

left we have

a picture of an ibm's electric

typewriter which was a very popular

electric typewriter in the 1960s

next to that there is a print ball so

printables were basically elements

that contained a character set

and you could purchase different

printables for different application

areas you'd actually have to then

purchase a print ball specifically

designed

for the operator symbols that were used

by the

apl programming language

on the far right we have the ibm 2741

computer terminal and this was

essentially

a computer terminal with an ibm's

electric

typewriter attached to it

and this would have been the terminal

that was initially

used when one was programming in the apl

language at the bottom we have an

example

of a keyboard overlay

for the programming language and this is

what one would need to use

on a modern computer so you can see

we've got

a variety of non-standard symbols for

example

we have triangles over there

we have a square element we have arrows

and we even have some greek characters

over there so these are all character

symbols that would be used for

operators within the apl programming

language

and today one would have to purchase a

keyboard overlay

to label the keys appropriately so that

you can actually write programs

in the language so this gives you an

idea of the kinds of symbols that one

would have within

an apl program and on the next slide

i'll show

some examples of programs written using

these symbols

so over here i have found three examples

of simple programs written in the apl

or apple programming language the first

program

sorts a list of words according to word

length

the second program is somewhat more

complicated

and so it generates six non-repeating

pseudo-random integer values

between 1 and 40 and then it prints

these random values out

in ascending order and you can see that

this program is actually shorter than

the previous program the last program

finds all of the prime numbers from 1

to r so what we can see then

is that the programs are incredibly

short they consist of very few

characters and you can actually

construct

fairly complex programs that would be

much longer in a fully featured

traditional high-level programming

language

so this means in general that apl or

apple programs are considered to be very

writable

simply because you have fewer characters

that you need

to construct a fairly complex program

however in general and again opinion

does differ on this but

in general the apl or apple programming

language is considered to have

very poor readability and the reason

again for this

is that the programs are so incredibly

compact

and therefore fairly difficult to

decipher

so in general apl or apple programs

are usually considered to be right once

and forget

programs it's very difficult to debug

them so typically a programmer will just

throw one together for a specific task

and if that task needs to be adapted

then usually the program would be

rewritten from scratch again

the second dynamic language that we'll

consider and also the last programming

language that we'll talk about in this

lecture

is snowball so snowball is a bit less

interesting than the apl or apple

programming language

and it was designed at bell labs by

faber

griswold and polinski also in the early

1960s

specifically 1964. so snowball

is a string manipulation language it's

intended for

text processing and it has a number of

fairly powerful operators

for string pattern matching now this was

a reasonably revolutionary idea at the

time

these days most programming languages

for string pattern matching

will use the regular expression standard

now snowball didn't use regular

expressions it used its own

custom notation for string pattern

matching

initially it was intended for use for

writing text editors and its strength is

still in text manipulation string

pattern matching

and that sort of thing however it's much

slower than

other languages in the sense and

therefore it isn't very

widely used for this purpose anymore it

is however still used today

for certain text processing tasks but

its use is

fairly limited all right so

that then concludes um the second

lecture on chapter two

we will be moving on then in the third

lecture to the last

few remaining programming languages that

we will be talking about within this

chapter

there are quite a number of languages

that we'll cover but we won't be going

into as much detail

for each programming language