exam

special words issues

(while, class, for) most statements with these special words always terminate in the same way, which makes it difficult to determine which state is being ended (end if, end) better at this ADA FORTRAN 95. Using more reserve words can improve readabilty

type checking

* is simply testing for type errors in a program, either by the compiler or during program execution. very important for reliability because run-time type checking is expensive, compile-time checking is more desirable; the earlier the errors are detected the less expensive to repair it. * We need to make sure the types of the operands (or arguments) of an operation are compatible Operations are compatible.

How can user-defined operator overloading harm the readability of a program?

By using the same operator for multiple uses (+) adding number or concatenated strings is helpful reducing the number of unique symbol but can detract readability and Type Checking is an important because the earlier errors in program are detected, the less expensive it is to make the required repairs.

types of programming languages (4)

Imperative (c, c++, java) Functional (Lisp) logic Object Oriented

What are the arguments for and against Java's implicit heap storage recovery, when compared with the explicit heap storage recover required in C/C++? Consider real-time systems.

Implicit eliminates the creation of dangling pointers. Disadv: cpu-time to do recovery, sometimes when there's plenty of heap storage so recovery isn't necessary. in Java there is not dangling pointer because there is not free( ); function to free memory or unallocated it when is allocated.

Reasons for Studying Programming Languages

Increased capacity to express ideas. Improved background for choosing appropriate languages. Increased ability to learn new languages Better understanding of the significance of implementation Better use of languages that are already known Overall advancement of computing

Why is it useful for a programmer to have some background in language design, even though he or she may never actually design a programming language?

It is useful for a programmer to have some background in language design because it increased capacity to express ideas, improved background for choosing appropriate languages, increased ability to learn new languages, better understanding of the significance of implementation, better use of languages that are already known and overall advancement of computing.

Strings

Must be represented as an array of characters, Operations: remove, insert, concatenate, tokanize, slice, I/O, is empty, substring, search, assignment, comparison (< > => <= == !=

variable attributes

Name type Address value scope lifetime

cost

The cost of a programming language is a function of many of its characteristics: training programmer to use the language writing programs in that language compilation execution time implementation. Expensive or runs on expensive hardware Maintainability testing/debugging

Why is type checking the parameters of a subprogram important?

Type checking is basically testing for type errors in a program. When the parameters doesn't match the type, then the language is less readable. Furthermore, failure of type checking has led to lots of program errors.

reliability

a program is said to be reliable if it performs to its specifications under all conditions: exception handling type checking, readability and writability * pointers can detract from reliability

variables

an abstraction of a memory cell that can hold some values and can be changed there are 6 attributes for each variable

explicit heap dynamic variables

are nameless (abstract) memory cell that are allocated and deallocated at run-time with instructions written by the programmer. can only be referenced by pointers or reference variables ( int *intnode // creates pointer) (intnode = new int;// creates the heap dynamic variable) (delete intnode deallocates)

design issues

are names case sensitive is there a maximum length is there a connector are the special words of the language reserved words or keywords

intrinsic attributes

are synthesized attributes of leaf nodes whose values are determined outside the parse tree

denotational semantics

are the most rigorous and most widely known formal method for describing the meaning of programs. based on recursive function theory

static variables

are those bounded to memory cells before program execution begins and remains bound to the same memory cell until program execution terminates ( static public int number;) in java

stack dynamic variables

are those whose storage binding takes place when their declartion statement are elaborated but are statically bound.. when execution reached the code to which the declaration is attached

special words

are used to make programs more readable by naming actions to be performed, some are reserved words or keywords

readability and writability

both can influence reliability. the easier a program is to write the more likely it is to be correct. programs that are difficult to read and difficult both to write and modify

dynamic vs static scoping

both uses stack, static is better in readability and its more flexible to call functions

narrowing converstion

converting one type to another where the new type doesn't include all the values of the old type (double to float) float larger range

widening conversion

converting one type to another where the new type includes all of the values of the old type (integer to float) integer smaller range

implicit heap dynamic variables

created on the heap with out explicit operations, only when assigned to values. HEAP POINT down STACK POINT UP

tuple

data type similar to a record except that the elements are not named

operational semantics

describes language construct in simple, obvious and unambigouos intermediate steps describes the meaning of a statement

explicit vs implicit binding declation

explicit is a statement in a program that list variable names and specifies that they are of a particular type, Implicit is a means of association of variables with types through default conventions

rules for static scoping (symbol reference)

find it in the block or local if its not there then is in the dynamic block, this also called lexical scoping

rules for dynamic scoping (symbol reference)

first look for a local definition of a variable name, if its not found, we look up the calling stack for a definition (variable name exist only when executing after that does not exist)

whats the difference between stack dynamic and fixed dynamic arrays

fixed stacks dynamic dimensions sizes are known at compile time to make more efficient and to reduce time and to optimize access to array FORTRAN use static arrays. wont go away java uses heap arrays int [][][]= new int [n1] [n2][n3];

reserved words

have certain meaning and cant be redefined, always the same (if, then, for)

key words

have different meaning in context, and they can be redefined ( real, real integer, integer real)

short circuiting

having a result without evaluating all operands

Aliasing

having two or more distinct names that can be used to access the same memory cell. very dangerous. some language allow it. exp. Pointers. can be used to overcome deficiencies in the language data extraction facilities. can reduced reliability

Tokenizing

identifying words/Symbols described with a regular expression processed with a finite state machine

when a language is said to be strongly type

if all type of errors are detected and caught : python

static vs dynamic binding time

if it occurs before run time begins and remains unchained througthout the program execution then is said to be static, if it occurs during run time or can change in the course of the program execution then its said to be dynamic

Orthogonality

in a programming language means that a relative small set of primitive constructs can be combined in a relatively small number of ways to build the control and data structures of the language; every possible combination is legal and meaningful

writability

is a measure of how easily a language can be used to create programs for a chosen problem domain

preprocessor

is a program that processes a program immediately before the program is compiled

name

is a string of character used to identify some entity in a program: variables, functions, methods, constants, classes, programs

binding

is an association between an attribute and an entity

Attribute Grammar

is an extension to a context grammar ( add attributes to a grammar to add context

coersion

is an implied conversion of one type to another widening vs narrowing

feature simplicity

is having more than one way to accomplish a particular operation. can affect readibility

address

is the machine memory address with which it is associated

lifestime

is the time during which the variable is bound to a specific memory location until unbound from it

type

it specifies set and range of values and operations applied to those values

issues with strings

length, case sensity

expressitivity

means that a language has relative convenient , rather than cumbersome, ways of specifying computations. exp. in C count++ is more convenient and shorter than (count= count + 1), also (and and then) or (for and while)

abstraction

means the ability to define and then use the complicated structures or operations in ways that allow many of the details to be ignored.

Functional languages

offer a good combination of simplicity and orthogonality (LISP) computations are made primarily by applying functions to given parameters. java c c++ are imperative languages that computations are specified with variables and assignment statements.

static array

range is bound and allocated before run time advantage array efficency

What is the disadvantage of having too many features in a language?

reduces readability. * It tends to lead to knowing only a subset. *It also means that a programmer may not be familiar with all the features. This may lead to an abuse of some, disuse of others and even an accidental use of an unknown feature.

fixed heap dynamic array

same as stack fixed after storage is allocated, but done during execution, storage allocated from heap instead.. advantage is array flexibility

reference type

similar to a pointer but instead of referring an address in memory referes to an object or a value in memory

static semantic

state the language type constrains, analysis check is done at compile time

exception handling

the ability of a program to to intercept run-time errors as well as other unusual conditions detectable by the program ( not available in C and Fortran)

Fixed stack- dynamic array

the array size is know at compile time and cannot change. advantage is space efficiency

advantages of orthogonality

the more orthogonal the design of a language; the fewer exceptions, the fewer exceptions means higher degree of regularity, which makes the language easier to learn, read and understand. too much can cause problems. (ALGOL 68) and can lead to unnecessary complexity

optimization

the name giving to the collection of techniques programmer use to decrease the size and increase the execution time of the code they produce

overall simplicity

the overall simplicity of a programming language strongly affects tits readability. A language with large number of basic constructs is more difficult to learn than one with a smaller number

deallocation

the process of placing a memory cell that has been unbounded from a variable back to into the pool of available memory

scope

the range (or set) of program statements where a variable is visible , valid and accessible (spatial)

stack dynamic array

the size and bound are not known until run time , but still doesn't change

binding time

the time at which binding takes place and can taake place at: design time implementation time compile time load time link time or run time

Parsing

translate into program statements grammar describe the semantics parse with a push down Automata PDA Creating a parse tree

compilation

translating the program into machine language (compiler) tokenizing Parsing

overloading

two methods with the same name. but behaves differently. using the same operator for multiple uses (+) adding number or concatenated strings is helpful reducing the number of unique symbold but can detract readability

pointers

two operations dereference: go to address reference: take the address of

primitive types

types that are not defined in terms of other types: booleans, char, int, double, float, short, long, long double, unsigned int, byte

What are the arguments for and against representing Boolean values as single bits in memory?

using a single bit instead of an entire byte will conserve memory

pointer

variable that has a range if values that consist of memory addresses and a special value NIL

operator overloading

when a single operator symbol has more than one meaning, this can reduce readibility

allocation

when a variable is bound to a memory cell and somehow must be taken from a pool of available memory

arrays

when we create arrays we need to be able to to find the location of a reference to the array such as A[I][J][K]