Back to TSW Go

syntax is commonly specified using a formal grammar, constructs: variables, expressions, functions, models

semantic definitions may be written in natural language

assignment statement sets and/or re-sets the value stored in the storage location(s) denoted by a variable name; the assignment statement (or expression) is a fundamental construct.

• The expression is evaluated in the current state of the program.
• The variable is assigned the computed value, replacing the prior value of that variable.

the assigned value depends on a previous one

a = b = c = d = f = 0

the right-hand side of the assignment is a single variable (e.g. an array or structure)

share common resources

data type or simply type is an attribute of data which tells the compiler or interpreter how the programmer intends to use the data.

declaration is a language construct that specifies properties of an identifier: it declares what a word (identifier) "means".[1] Declarations are most commonly used for functions, variables, constants, and classes, but can also be used for other entities such as enumerations and type definitions.

expression in a programming language is a combination of one or more constants, variables, operators, and functions that the programming language interprets (according to its particular rules of precedence and of association) and computes to produce ("to return", in a stateful environment) another value.

In computer languages, identifiers are tokens (also called symbols) which name language entities.

With early binding, or static binding, in an object-oriented language, the compilation phase fixes all types of variables and expressions. This is usually stored in the compiled program as an offset in a virtual method table ("v-table") and is very efficient. With late binding the compiler does not read enough information to verify the method exists or bind its slot on the v-table. Instead the method is looked up by name at runtime.

Static binding (or early binding) is name binding performed before the program is run.

Dynamic binding (or late binding or virtual binding) is name binding performed as the program is running

local variables — variable names with limited scope, that only exist within a specific function

lexical scope; (also called static scoping or static scope) if a variable name's scope is a certain function, then its scope is the program text of the function definition: within that text, the variable name exist

dynamic scoping (or dynamic scope), if a variable name's scope is a certain function, then its scope is the time-period during which the function is executing: only while the function is running, the variable name exists, and is bound to its value

statement is a syntactic unit of an imperative programming language that expresses some action to be carried out.

value is the representation of some entity that can be manipulated by a program.