Lecture 8: Programming Languages

• it's hard to do the programming to get something done

• details are hard to get right, very complicated, finicky
• not enough skilled people to do what is needed
• therefore, enlist machines to do some of the work
– leads to programming languages

• it's hard to manage the resources of the computer

• hard to control sequences of operations
• in ancient times, high cost of having machine be idle
• therefore, enlist machines to do some of the work
– leads to operating systems
The important ideas
• programming languages evolve
• as we get more understanding
• and have more computing resources
– so the computer can do more of the work
• there is a lot of religious fervor about languages
• but all are equivalent in the Turing sense

• you can ignore syntax details completely

– but pay attention when we talk about Python

• you should understand the processes by which the programs we

write get to do actual computing
Evolution of programming languages
• 1940's: machine level
– use binary or equivalent notations for actual numeric values
• 1950's: "assembly language"
– names for instructions: ADD instead of 0110101, etc.
– names for locations: assembler keeps track of where things are in memory;
translates this more humane language into machine language
– this is the level used in the "toy" machine
– needs a total rewrite if it's moved to a different kind of CPU

loop get # read a number

ifzero done # no more input if number is zero assembly lang
add sum # add in accumulated sum
store sum # store new value back in sum
program
goto loop # read another number
done load sum # print sum
print assembler
stop
sum 0 # sum will be 0 when program starts
binary instrs
Evolution of programming languages, 1960's
• "high level" languages: Fortran, Cobol, Basic
– write in a more natural notation, e.g., mathematical formulas
– a program ("compiler", "translator") converts into assembler
– potential disadvantage: lower efficiency in use of machine
– enormous advantages:
accessible to much wider population of users
portable: same program can be translated for different machines
more efficient in programmer time

sum = 0 Fortran program

10 read(5,*) num
if (num .eq. 0) goto 20 compiler
sum = sum + num
goto 10
20 write(6,*) sum
assembler
stop
end binary instrs
Evolution of programming languages, 1970's
• "system programming" languages: C
– efficient and expressive enough to take on any programming task
writing assemblers, compilers, operating systems
– a program ("compiler", "translator") converts into assembler
– enormous advantages:
accessible to much wider population of programmers
portable: same program can be translated for different machines
faster, cheaper hardware helps make this happen
C program
#include <stdio.h>
main() {
C compiler
int num, sum = 0;

while (scanf("%d", &num) != -1 && num != 0)

assembler
sum += num;
printf("%d\n", sum);
} binary instrs
C code compiled to assembly language (x86, Mac)
Ltmp2:
movl $0, -8(%rbp)
#include <stdio.h>
movl $0, -12(%rbp)
main() { jmp LBB1_2
int num, sum = 0; LBB1_1:
movl -12(%rbp), %eax
while (scanf("%d", &num) != -1 movl -8(%rbp), %ecx
addl %eax, %ecx
&& num != 0)
movl %ecx, -8(%rbp)
sum = sum + num; LBB1_2:
printf("%d\n", sum); leaq -12(%rbp), %rax
xorb %cl, %cl
}
leaq L_.str(%rip), %rdx
movq %rdx, %rdi
movq %rax, %rsi
movb %cl, %al
callq _scanf
(You are not expected to movl %eax, %ecx
understand this!) cmpl $-1, %ecx
je LBB1_4
movl -12(%rbp), %eax
cmpl $0, %eax
jne LBB1_1
LBB1_4:
Evolution of programming languages, 1980's
• "object-oriented" languages: C++
– better control of structure of really large programs
better internal checks, organization, safety
– a program ("compiler", "translator") converts into assembler or C
– enormous advantages:
portable: same program can be translated for different machines
faster, cheaper hardware helps make this happen

#include <iostream>
main() {
int num, sum = 0;

while (cin >> num && num != 0)

sum += num;
cout << sum << endl;
}
Bjarne Stroustrup
1950-
Java (1995)
import java.util.*;
class Addup {
public static void main (String [] args) {
Scanner keyboard = new Scanner(System.in);
int num, sum;
sum = 0;
num = keyboard.nextInt();
while (num != 0) {
sum = sum + num;
num = keyboard.nextInt();
}
System.out.println(sum);
}
}
James Gosling 1955-
JavaScript (1995)
var sum = 0; // javascript
var num = prompt("Enter new value, or 0 to end")
while (num != 0) {
sum = sum + parseInt(num)
num = prompt("Enter new value, or 0 to end")
}
alert("Sum = " + sum)

Brendan Eich
1961-
Python (1990)
sum = 0
num = input()
while num != '0':
sum = sum + int(num)
num = input()
print(sum)

Guido van Rossum

1956-
Programming languages in the 21st century?

• new(ish) general-purpose languages

– Go, Rust, Swift, Scala, Kotlin, Julia, ...

• ongoing refinements / evolution of existing languages

– C, C++, Fortran, Cobol, Javascript all have new standards in last few years

• specialized languages for specific application areas

– e.g., R for statistics

• old languages rarely die

– it costs too much to rewrite programs in a new language
Why so many programming languages?
• every language is a tradeoff among competing pressures
– reaction to perceived failings of others; personal taste
• notation is important
– "Language shapes the way we think and determines what we can think
about."
Benjamin Whorf
– the more natural and close to the problem domain, the easier it is to get
the machine to do what you want

• higher-level languages hide differences between machines and

between operating systems

• we can define idealized "machines" or capabilities and have a

program simulate them -- "virtual machines"
– programming languages are another example of Turing equivalence