These examples are presented in an attempt to show how each coding styles attempts to or does not attempt to isolate side-effects. There are only 2 semantic elements in a barebone "Hello World" implementation: 

* Invocation of `console.log`
* Declaration of `HELLO_WORLD`

Since every coding style can abstract away data into a parameter or variable, there is no point for us to show that. All implementations assume `HELLO_WORLD` is a constant that is always inline. This way it reduces the variations we need to present. 

All implementations also assume `console` is static. In case of OOP, `Console` is assumed to be extendable. In case of functional programming, `console.log` is asumed to be a function that can be passed around without further modification. 

## Declarative ##
```jsx
const HelloWorld = (<div>{HELLO_WORLD}</div>);
// usage
React.render(HelloWorld, doment.body)
```

## Imperative ##
### Procedural ###
#### Direct invocation ####
```js
// no implementation
// usage
console.log(HELLO_WORLD);
```
#### Subroutine ####
Subroutine does not return value. 
```js
function printHelloWorld() {
  console.log(HELLO_WORLD);
}
// usage
printHelloWorld();
```

#### Context-passing ####
This is a technique often used to emulate OOP when OOP is not available such as in languages C and Bash. 
It is also often used when OOP is not practical, for example when recreating the object is an overhead. 
```js
function hellWorld(ctx) {
  ctx.log(HELLO_WORLD);
}
// usage
hellWorld(ctx);
```

### Static-typed object-oriented ###
#### Static ####
##### Static method #####
```js
class HelloWorld {
  static print() {
    console.log(HELLO_WORLD);
  }
}
// usage
HelloWorld.print();
```

##### Static invocation from method #####
```js
class HelloWorld {
  print() {
    console.log(HELLO_WORLD);
  }
}
// usage
new HelloWorld().print()
```

### Inheritance ###
#### Classical Inheritance ####
```js
// following code would not work as Console is not publically initializable
class HelloWorld extends Console {
  print() {
    this.log(HELLO_WORLD);
  }
}
// usage
new HelloWorld().log();
```

#### Prototypical inheritance ####
```js
let myConsole = Object.create(console);
myConsole.print = function () {
  this.log(HELLO_WORLD);
};
// usage
myConsole.print();
```

#### Old-school class pattern ####
```js
// following code would not work as Console is not publically initializable
function HelloWorld() {
}
HelloWorld.prototype = new Console();
HelloWorld.prototype.print = function () {
  this.log(HELLO_WORLD);
};
// usage
new HelloWorld().log();
```

#### Injection-based ####
##### constructor injection #####
```js
class HelloWorld {
  constructor(console) {
    this.console = console;
  }
  print() {
    this.console.log(HELLO_WORLD);
  }
}
// usage
new HelloWorld(console).print();
```

##### Parameter Injection #####
```js
class HelloWorld {
  print(console) {
    console.log(HELLO_WORLD);
  }
}
// usage
new HelloWorld().print(console);
```

##### Autowired Injection #####
```js
class HelloWorld {
  $console;
  print(console) {
    this.$console.log(HELLO_WORLD);
  }
}
// usage
Singleton.get(HelloWorld).print(console);
```
#### Factory ####
##### Constructor Injection #####
```js
function createHelloWorld(f) {
  return {
    print() {
        f.log(HELLO_WORLD);
    }
  }
}
// usage
createHelloWorld(console).print();
```

##### Parameter Injection #####
```js
function createHelloWorld() {
  return {
    print(console) {
      console.log(HELLO_WORLD);
    }
  };
}
// usage
createHelloWorld().print(console);
```

##### IIFE / old-school module pattern #####
```js
const HelloWorld = (function createHelloWorld() {
  return {
    print(console) {
      console.log(HELLO_WORLD);
    }
  };
})();
// usage
HelloWorld.print(console);
```

### Dynamic-typed object-oriented ###
#### Mixin ####
##### Static invocation #####
```js
const HelloWorldMixin = {
  printHelloWorld() {
    console.log(HELLO_WORLD);
  }
};
// usage
const obj = Object.assign({}, HelloWorldMixin);
obj.printHelloWorld();
```

##### Parameter injection #####
```js
const HelloWorldMixin = {
  printHelloWorld(console) {
    console.log(HELLO_WORLD);
  }
};
// usage
const obj = Object.assign({}, HelloWorldMixin);
obj.printHelloWorld(console);
```

#### Monkey-pactching ####
##### Monkey-pactching with mixins #####
```js
const HelloWorldMixin = {
  printHelloWorld() {
    console.log(HELLO_WORLD);
  }
};
// usage
Object.assign(console, HelloWorldMixin);
console.printHelloWorld();
```

##### Monkey-pactching with method #####
```js
console.printHelloWorld = function() {
   this.log(HELLO_WORLD);
}
// usage
console.printHelloWorld();
```

## Functional programming ##
### Eager Eval ###
#### Side-effect on usage ####
```js
function helloWorld() {
  return HELLO_WORLD;
}
// usage
console.log(helloWorld());
```

#### Side-effect on binding ####
```js
function helloWorld(console) {
  return console.log(HELLO_WORLD);
}
// usage
helloWorld(console);
```

### Lazy Eval ###
#### early binding ####
```js
function helloWorld(f) {
  return () => f.log(HELLO_WORLD);
}
// usage
helloWorld(console)();
```

##### Late Binding #####
```js
function helloWorld() {
  return (f) => f.log(HELLO_WORLD);
}
// usage
helloWorld()(console);
```