As important as it is to know the control structures of a programming language, it is just as important to be able to name their contexts and surroundings. Using the right vocabulary is particularly effective in code reviews as it supports us to put our thoughts into words.
Algorithms & Functions
An algorithm is a set of instructions to solve specific problems or to perform a computation. In TypeScript algorithms can be implemented with functions.
Algorithms have defining characteristics such as:
- Generality: The algorithm must apply to a set of defined inputs.
- Definiteness / Uniqueness: At any point in time, there is at most one possibility of continuation. Each instruction step is well-defined.
- Deterministic: Given a particular input, the algorithm will always produce the same output.
- Effectiveness: The algorithm terminates in a finite amount of time / steps. Every execution of the algorithm delivers a result.
- Finiteness: The algorithm is described in a finite amount of steps.
- Feasibility: It should be feasible to execute the algorithm with the available resources.
Imperative programming is a programming paradigm that uses statements to change an application’s state. In a nutshell, imperative programming defines a set of instructions from start to finish.
- Change UI behaviour by defining how to turn something off before turning it on
Declarative programming is a programming paradigm that defines the desired state of an application without explicitly listing statements that must be executed. In a nutshell, declarative programming defines an application’s execution from finish to start.
- Change UI behaviour by defining how it should look like based on its props
A deterministic function will always produce the same output given the same input. This makes the output of a deterministic function predictable as it does not rely on a dynamic state.
Pure functions are a subset of deterministic functions. A pure function always produces the same result given a particular input. In addition, it does not cause side effects by avoiding I/O operations like printing to the console or writing to the disk.
A pure function does not mutate its passed parameters and is referentially transparent.
Referentially Transparent Expressions
An expression is referentially transparent when it can be replaced with its return value.
sayHello function always returns the same text, so we can safely replace our expression with
const message = Hello! which makes it referentially transparent.
Referentially Opaque Expressions
An expression is referentially transaprent when it cannot be replaced with its return value.
At the time of writing the exection of
'2021-09-22T12:45:25.657Z'. This result will change over time, so we cannot replace
const isoDate = today() with
const isoDate = '2021-09-22T12:45:25.657Z' which makes this expression referentially opaque.
A function declaration gets hoisted and is written the following way:
A function expression is part of an assignment and does not get hoisted:
let keyword can be used. It makes variables unaccessible from the outside of their blocks:
By default, the TypeScript compiler does not know in which runtime environment (for instance Node.js v16, Electron v16, Chrome v94) our code will be executed later. That’s why we can help the compiler knowing that by defining an ambience / ambient context.
Example: If you run your code in an environment where there is a “world” object that TypeScript does not know about, you can define that context using