Cs280 stuff

Plankalkül

Plankalkül

A programming language designed in 1945, featuring advanced data structures, floating-point arrays, records, and invariants.

Fortran

A programming language developed in the 1950s for scientific computing, notable for its use of compiled programming languages.

LISP

A functional programming language developed in the late 1950s for artificial intelligence research, using lists as its primary data structure.

COBOL

A programming language developed in the 1960s for business data processing, designed to be readable by non-programmers.

BASIC

A programming language developed in the 1960s for beginners, designed to be easy to use for non-science students.

PL/I

A programming language created by IBM in the 1960s, combining features from scientific and business programming languages.

Prolog

A logic programming language developed in the 1970s for artificial intelligence and computational linguistics.

Ada

A programming language developed in the 1970s by the US Department of Defense, supporting object-oriented, concurrent, and systems programming.

Short Code

A programming language developed in 1949 for BINAC computers, using left-to-right expression coding and an early form of pseudocode.

Speedcoding

A programming language developed in 1954 for the IBM 701, featuring pseudo operations for arithmetic and conditional branching.

ALGOL 60

A programming language refined from ALGOL 58, introducing block structure, subprogram recursion, and stack-dynamic arrays.

ALGOL 68

A more complex version of ALGOL 60, featuring user-defined data types and a strong type system.

Pascal

A programming language developed in the late 1960s for teaching programming and structured programming, widely used in academia.

C

A general-purpose programming language developed in the early 1970s at Bell Labs, providing low-level access to memory.

Smalltalk

An object-oriented programming language developed in the 1970s, introducing classes and message passing.

C++

An extension of C developed in the early 1980s, adding object-oriented features suitable for large-scale software development.

Regular Grammars

Define rules directly mappable to states and transitions of a Finite State Automaton (FSA).

Context-Free Grammars

Recognizable by Pushdown Automata (PDAs) using a stack for nonterminal expansions.

Top-Down Parsers

Construct parse trees in leftmost derivation order using Recursive Descent or LL Parsers.

Bottom-Up Parsers

Utilize LR Parsers (e.g., SLR, LALR) to build parse trees from input symbols towards the start symbol.

Automaton

Mathematical model with a finite number of states processing symbol sequences from an input alphabet.

Special Characters in Variable Naming

Symbols like $ in PHP, @ in Ruby for variable naming conventions.

Binding

Association between entities and attributes like variables and types, categorized as Static or Dynamic Binding.

Lifetime vs

Lifetime is the duration a variable is bound to memory, while scope defines its visibility in statements.

Compile Time

Phase translating source code to executable form, performing syntax and type checking.

Runtime

Period when the program executes after compilation, utilizing CPU and memory resources.

Rectangular Array

A multi-dimensioned array where all rows have the same number of elements and all columns have the same number of elements.

Jagged Matrix/Array

An array with rows containing varying numbers of elements.

Associative Arrays

Unordered collections of data elements indexed by keys.

Record Types

Aggregate of data elements where individual elements are identified by names.

Tuple Types

Data type similar to a record but with unnamed elements.

Union Types

Type allowing variables to store different type values at different times.

Pointer and Reference Types

Variables storing memory addresses and providing indirect addressing.

Strong Typing

Language where type errors are always detected.

Type Equivalence

Equivalence based on name or structure of types.

Arithmetic Expressions

Consist of operators, operands, parentheses, and function calls.

Overloaded Operators

Use of an operator for multiple purposes.

Type Conversions

Narrowing and widening conversions, mixed-mode expressions, and coercions.

Relational Expressions

Use relational operators and operands, evaluating to Boolean.

Boolean Expressions

Operands and results are Boolean.

Control Structure

Control statement and the statements it controls.

Selection Statements

Provide means of choosing between paths of execution.

Iterative Statements

Repeated execution of statements through iteration or recursion.

Unconditional Branching

Transfer execution control to a specified place in the program.

Guarded Commands

Designed by Dijkstra to support verification during development.

Subprograms

Have a single entry point, suspend the calling program during execution, and return control to the caller upon termination.

Subprograms

Functions or procedures that can be passed as parameters and can be nested within other subprograms.

Referencing Environment

The context in which a passed subprogram executes, determining its access to variables and functions.

Overloaded Subprograms

Subprograms with the same name but different parameters within the same referencing environment.

Generic Subprograms

Subprograms that can take parameters of different types on different activations.

Closures

A subprogram along with the referencing environment where it was defined, supporting nested functions.

Local Referencing Environments

Environments where local variables can be stack-dynamic or static, affecting storage and access.

Parameter-Passing Methods

Techniques like pass-by-value, pass-by-result, and pass-by-reference for passing parameters to subprograms.

Shallow Binding

The environment of the call statement that enacts the passed subprogram, common in dynamic-scoped languages.

Deep Binding

The environment of the definition of the passed subprogram, typical in static-scoped languages.

Ad hoc Binding

The environment of the call statement that passed the subprogram, providing flexibility in binding contexts.