t

1. 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

2. COBOL – Why?
 Software Lifecycle
 Cheaper to maintain
 Y2K
 Self-documenting code
 Verbose
 “IF a < b AND > c …”
 Divisions

3. COBOL – Why?
 Divisions
 Identification Division
 Environment Division
 Data Division
 Procedure Division

4. 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

6. COBOL – Groups and Elementary data

8. 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)

9. COBOL - Summary
 Readability
 Writability
 Reliability
 Portability

10. LISP
 LISt Processing
 List-based language
 2nd High-level language
 1958 – John McCarthy for MIT

12. 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))

13. LISP – Innovations
 Garbage Collection
 If else statements
 Recursion

14. LISP – Linked Lists
 Car (first)
 Cdr (rest)

16. LISP - Examples
 If then else
 (if nil
(list ‘2 ‘3)
(list ‘5 ‘6))
 One line variant:
 (if nil (list ‘2 ‘3) (list ‘5 ‘6))

17. 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)))))

18. LISP - Examples
 Recursive List Size
 (defun recursiveSize (L)
(if (null L)
0
(1+ (recursiveSize(rest L)))))

19. LISP - Examples
 Recursive List Sum with “LET”
 (defun sum (L)
(if (null L)
0
(let
((S1 (first L))
(S2 (sum (rest L))))
+ S1 S2)))

20. LISP- Summary and Comparison
 Readability
 Writability
 Reliability

21. Python
 Developed early 1990’s
 Guido van Rossum
 ABC language
 Python 2.0
 2000
 Community-supported -> reliability
 Modular; community expandable
 Python 3.0
 2008

22. Python – Readability is Key
 Design goal
 One way to do things
 Clarity over clever code
 Whitespace over braces
 “pass” for No-Op

23. 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

24. Python
 Comparisons
 == tests values, not references
 A < b <= C works properly
 Ternary operator readable
 “a if b else c”

25. Python
 System Requirements
 Cross platform
 Python Interpreter
 Simplicity
 Small core language
 Large libaraies

26. 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”)

27. 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

28. 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

29. 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)

30. Python - Summary and Comparison
 Readability
 Writability
 Reliability