COBOL, LISP, and Python

Joseph Hoeppner

COBOL Background

Released in 1959

Grace Hopper

Industry, universities, and government collaboration

Cold War pressures

80% of business transactions

65% of all code is in COBOL

COBOL – Why?

Software Lifecycle

Cheaper to maintain

Y2K

Self-documenting code

Verbose

“IF a < b AND > c …”

Divisions

COBOL – Why?

Divisions

Identification Division

Environment Division

Data Division

Procedure Division

COBOL – Data Division

Data Division

Pictures

9 = digit

X = any character

A = alphabetic character

V = decimal point position

S = sign

Repeats

PIC 9 (4) = 9999

COBOL – Groups and Elementary data

COBOL

Reliability

Stood test of time

Has “ALTER X TO PROCEED TO Y” (a negative)

Uses GOTO statements (a negative)

Today

Cross platform: OpenCOBOL C translation

IDEs (Net Express)

COBOL - Summary

Readability

Writability

Reliability

Portability

LISP

LISt Processing

List-based language

2nd High-level language

1958 – John McCarthy for MIT

LISP - Syntax

Function call: “(fun arg1 arg2)”

(+ 1 2 3)

Lists

(list ‘3 ‘7 ‘apples)

(3 7 apples)

(list ‘13 list(‘3 ‘5))

(13 (3 5))

LISP – Innovations

Garbage Collection

If else statements

Recursion

LISP – Linked Lists

Car (first)

Cdr (rest)

LISP - Examples

If then else

(if nil

(list ‘2 ‘3)

(list ‘5 ‘6))

One line variant:

(if nil (list ‘2 ‘3) (list ‘5 ‘6))

LISP - Examples

Factorial

(defun factorial (n)

(if (<= n 1)

1

(* n (factorial (- n 1)))))

One line variant:

(defun factorial (n) (if (<= n 1) 1 (* n (factorial (- n 1)))))

LISP - Examples

Recursive List Size

(defun recursiveSize (L)

(if (null L)

0

(1+ (recursiveSize(rest L)))))

LISP - Examples

Recursive List Sum with “LET”

(defun sum (L)

(if (null L)

0

(let

((S1 (first L))

(S2 (sum (rest L))))

+ S1 S2)))

LISP- Summary and Comparison

Readability

Writability

Reliability

Python

Developed early 1990’s Guido van Rossum

ABC language

Python 2.0 2000

Community-supported -> reliability

Modular; community expandable

Python 3.0 2008

Python – Readability is Key

Design goal

One way to do things

Clarity over clever code

Whitespace over braces

“pass” for No-Op

Python

Writability

Similar to other OO languages

Verification support

Interpreted, assert, no statements in conditions

Clean style

Few keywords

Simple grammar -> few ways to do something

Python

Comparisons

== tests values, not references

A < b <= C works properly

Ternary operator readable

“a if b else c”

Python

System Requirements

Cross platform

Python Interpreter

Simplicity

Small core language

Large libaraies

Python - Examples

a = 15

if(a < 10):

print(“input less than 10”)

elif(10 < a < 20):

print(“input between 10 and 20”)

else:

print(“input greater than 20”)

Python - Examples

Function definition

def greatest(a, b, c):

largest = a if a > b else b

largest = largest if largest > c else c

print(largest)

Function call

greatest(7, 3, 14)

14

Python - Examples

Determine if prime

def isPrime(num):

prime = True

for i in range(2, (num / 2) + 1):

if num % i == 0:

prime = False

return prime

def tenPrimes():

list = []

count = 0

current = 2

#store the first 10 primes in a list

while count < 10:

if isPrime(current):

count += 1

list.append(current)

current = current + 1

#print the list

for element in list:

print(element)

Python - Summary and Comparison

Readability

Writability

Reliability

Python - Examples

Demo