4080 Midterm

language with a 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 combine, and how simple these combinations are to understand

the features provided to create abstractions (C=simple with low lv of ab. while Java=not simple with high lv of ab)

to what degree can the program created in the language be moved from one system to another

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

how easy it is to come up with different solutions to a problem

most common form of computer architecture on modern machines

take source code and turn it into machine code

program that takes source code and executes it

code is compiled into byte code (instructions are sent to a simulated computer)

how we create the program

alphabet, rules for names, reserved words, case sensitive

rules to create valid sentences

the meaning of what is used to create the program

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

connection between a name and a property

(memory allocation) process of reserving and associating with a name

memory is allocated before execution by the compiler (fast runtime)

memory is allocated while program is running (overhead when finding memory during runtime)

stack/heap/data/text

association of a name to a type (lexical/syntactic/semantic/translation/optimization/transcription)

name are assigned a type before the program is run

name is assigned a type while the program is running

if the language requires the use of a syntactic feature to specify the type then the language is explicit

process of associating a name with he a scope

region/block area in the code where names are visible

(lexical scoping) the scope of a name is defines while the code is being written with lexical features

visibility of names is determined during run time by looking at the stack activation records.

symbol/l-value: value of the memory location that will hold the variable you want to store/r-value: actual value you want to store

sequence of symbols that yields a value (arithmetic / boolean)

deals with numbers

deals with relational and logical expressions

a syntactic feature in a language that represents a function that takes input and produces a value

deals with 1 operand ex: !

deals with 2 operands

deals with 3 operands ex: ?

deals with N amount of operands

operator is place before the operands ex: + 3 4

operator is place between the operands ex: 3 + 4

operator is place after the operands ex: x++

the … of a name is a property that describes the nature of the data associated with the name, and how it should be handled

part of the definition of the language, not made of other types, atomic (int, float, char, bool)

a type created by a user, mechanism used to create this type is high complexity can go from simple enumeration to abstract data types ADT

any expression that yields a numerical type ( + , - , / , ** , % )

in what order are operands evaluated L>R or R>L

a mechanism to sort ambiguous expressions by creating hierarchy of operands where the position of the hierarchy determines the relative binding strength of the operator (1. expo 2. mod 3. mul/dif 4. add/sub)

if order of evaluation and precedence yields an expression with semantics different from desired, this can be used to override and impose a particular order of operation

an expression is said to be … free (aka pure) if the evaluation results in visual change (destructive update) in memory

if substitution if the expression but the value it yields results in a program with the same semantics then it is…

if the operand performs more than one function depending on the type ex: in java, + can be used: (int + int)addition or (str + str)concatenation

when a program requires to convert a numerical type into another

conversion is implicit / automatic

(explicit type coercion) conversion is explicit and performed with syntactic features from the language

an expression where then is more than one type of operand

when an arithmetic expression results in a number greater than the maximum representable number in the current data format

occurs then a floating point operation results in a number that is less than the minimum representable number (mantissa + exponent)

greater than, less than, equal to, not equal to

and, or, not , implication

lazy evaluation which given a logical operation, if the evaluation of the first operand is enough to determine the value , then the second operand is not evaluated

a sequence of characters usually enclosed by some syntactical delimiters ex: “ “

implementation:

• array: fixed size

• linked list: slow access to characters

when it is possible to change string length and content

simplest data structure in most imperative languages and are indexed sequence of elements on the same type

• allocated in contiguous blocks of memory

• once located, size can not be modified