programming language important

subprogram

descirbes an interface and actions to be performed

horn clause

a rule with at most one conclusion.

headed horn clause

has a head and things are facts ex if statement x :- a,b

headless horn clause

does not have a head and is just proving the body ex query ?-fun( ,)

tail recursion

recursive call is the last call in a recursive function and is the very last thing

referential transparency

when you can replace a function call with its results and it doesn’t cause errors ex. add(2,3) replaced with 5

dynamic linking

points to called activation revord in the runtime stack

dynamic binding

at runtime it binds the instance method call to the correct object allowing polymorphism

chooses method at runtime and is for calling an overridden method to execute the appropriate implementation at runtime

deadlock

processing waits indefinitely because of circular wait or resource holding

4 conditions of deadlock

mutual exclusion, circular wait, hold and wait, no preemption

von neumann

uses inttructions and has CPU, memory, and bus, and data is passed back and forth on bus

von neumann bottleneck

computer is limited on program execution speed caused by slow rate instructions get moved on the bus

imperative languages

based on von neumann

functional languages

based on math

Abstract data type

user defined type that includes:

representation is hidden so users cannot directly access the internal data structure

encapsulation: data and its operations are defined in a single unit

Activation record

A stack frame containing information needed to manage a subprogram call: return address, parameters, local variables, dynamic link, static link, etc.

concurrency

computer ability to handle multiple tasks at a time

physical concurrency

multiple cores used to execute things at same time

logical concurrency

single core and tasks are spliced and done at the same time

java better at exception handling

Java built into language, C++ needs library, C does not have

Java enforces checking exceptions and has a unified organized exception hierarchy

java exceptions are always objects

Java has a finally block, which ensures that cleanup code always runs