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

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.

- Augmented assignment

the assigned value depends on a previous one

- Chained assignment

a = b = c = d = f = 0

- Parallel assignment

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

-- Bridging

share common resources

-- Closure
-- Data type

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

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

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.

-- Indentifiers

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

-- Binding

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

-- Scope

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

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

-- Value

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