CS4080 Final

Scientific Computation - Fortran

AI - Lisp python

Enterprise - Java Cobalt

Systems programming - C Pearl

Web applications - Javascript, Typescript, PHP

languages that follow the designed of a computer’s architecture can be followed easily, while languages that use abstractions are harder to translate. This is why early languages followed computer architecture.

compiler: take source code and turns it into machine code

interpreter: program that reads source code and executes it

virtual machine: code is compiled into byte code, instructions are simulated in software

syntax: rules to write valid words in the language

semantics: the meaning of sentences within the language

set of all valid symbols in the language

reserve words: words that may or may not be used by the language (could be used in future updates)

key words: reserved words with functionality in the language

keywords, variables, function names, and other identifiers must always be typed with a constant capitalization of letters

EX:

“while” != “While”

the language can ignore the differences between upper and lowercase letters

EX:

“while” = “WHILE”

LSSTOT

Lexical analysis

Syntax analysis

Semantic analysis

Translation

Optimization

Transcription

a name for memory location that holds a value of a particular data type that can be destructively updated

L-value: value of memory location that holds the value you are storing in the variable

R-value: the actual value you are storing in the location

when a memory location can be accessed through more than one name (when 2 or more variable have the same L)

the associating of a name with a specific value/property (memory, type, scope)

when a name is connected to a property before execution

when a name is connected to a property during exection

when memory is allocated before execution, typically done by the compiler

the .data section / segment

when memory is allocated during execution, usually incurs overhead

the .heap section / segment

name is assigned a type before execution

name is assigned a type during execution

if the language requires the use to explicitly specify the type of an element with a syntactic feature the it has explicitly typing, otherwise it is implicit

(lexical scoping) when the scope of a name is defined at programming / writing time with lexical features

The scope of a name is defined while the program is run by looking at the current state of the stack of activation records.

(all in bytes)

int - 4

long - 8

char - 1-4

float - 4

short - 2

boolean - 1

byte - 1

can be implemented with arrays and may or may not be immutable, these are very fast to access and travers. modifying it may involve allocating a new string which is expensive

can be implemented with buffered arrays or linked-lists, these are slower to read (not so much if buffered array is used)

in order to iterate though an array all elements must be the same type and size in terms of bits

arrays are usually stored in contiguous blocks of memory, once the block of memory is allocates it is hard to iterate though is you want to add more space

arrays where the subscript is not an integer, but a string or some other type, these are maps in which a string is a key that must be unique for every element that it is mapping.

array is stored in an array, which allows for contiguous allocation which is fast since it is all in one block.

EX:

Array [ref1, ref2]

Ref1 = [2,3]

Ref2 = [4,6]

array is stored all in one block, the first element tells where to jump to and the second tells which element is implemented

EX:

Array[[1,2][4,6]]

arrays in which at least one dimension is variable instead of constant

relational expression

logical expression

the number of operands in which an operator operates.

operator is placed before the operand (+3,4)

operator is placed between the operands (3+4)

operator is placed after the operand (x++)

when evaluation happens starting from the left reading to the right

EX:

x + 3 - 2 = (x+3)-2

when evaluation happens starting from the right reading to the left

EX:

x + 3 - 2 = x+(3-2)

a mechanism to sort ambiguous expressions by creating a hierarchy of operators where the position of the hierarchy determines the binding strength

the evaluation results in a visual change or destructive update of memory

when an expression is side effect free

if the substation of the expression by the value it yields results in a program with the same semantics

and expression with more than one type of operand

the conversion is implicit / automatic

the conversion is explicit and performed with some syntactic feature in the language

a form of lazy evaluation given a binary operation, is the evaluation of the first operand is enough to determine a value, the second is not evaluated

the cornerstone of imperative languages since they are used to perform destructive updates

simple: x=e

parallel: x,y = 1,2

multiple: x,y,z=42

compound: x+=1

unary: x++

conditional: x=if b then E1, else E2

similar to goto, it allows one to jump unconditionally to a target instruction

EX:

(i) x=y+1

Goto (i+j)

…

(i+j) z=42

when you make a copy of the value and pass it, this does not affect the original value

when you pass the memory location of the value, this will change the original value even outside the function

variables that are defined when the function is declared

EX:

func int x: {}

variables that are declared when the function is called

EX:

number(12)

arguments are passed into the function and parameters are what the function takes in as an argument

arguments bind to the parameter according to the position

EX:

int f(x,y,z)

return x,y,z

int r call f(1,2,3) //x=1,y=2,z=3)

arguments binding is explicitly specified using the name of the parameter

EX:

s = call f(y=2, x=1, z=3)

when the language allows you to specify default values for the parameters

EX:

fun int f(x,y=2,z)

int t = call f(x=1, z=3)

simplicity

orthogonality

lv of abstraction

portability

cost

expressivity

language with minimal set of features with rules on how to apply them and combine them as simply and clearly as possible

the way different constructs can be combined, and how simple these combinations are to understand

the features provided to create abstraction

how easy it is for a program to be created in the language can be moved from one system to another

cost of using language in a project (development, maintenance, execution)

function

imperative

logical