note of functional thinking

Learning a new programming paradigm, is not only about mastering a new language, but also thinking in a new way.

OO makes code understandable by encapsulating moving parts. FP makes code understandable by minimizing moving parts.
By Michael Feathers

• Resusability
  OOP: messages between classes
  FP: data struct and workflow ?

• Imperative Processing
  A sequence of commands
  for iteration

• Functional
  Expression and Transformation
  Model mathematical formula
  Avoid mutable states

• filter
• map
• reduce/fold(foldLeft/foldRight)

Scala: implicit parameter

1

numbers filter (_ % 3 == 0)

Ceding control to the language/runtime

• Higher-Order function over iteration
• Closure
  A feature implemented by all functional language
  Definition:
  

  A function
  A special function
  Wrap all its reference in a context

Lazy execution?

Hold context, instead of states
Leave states management to language

• Currying and Partial Application of function
  Currying: process of Transformation

Partial Application: apply part of parameters ?

Do not confuse with Partial Function in Scala

• Recursion
  Another perspective on Linked List: head and tail

Tail-call optimization: avoid stack growth

Method level inner cache
Only for pure function

Lazy evaluation
Compute element when use

Pro:
Delay expensive calculation
Infinite collection
Help map, filter

Few data structures, many operations

Dispatch mechanism:
dynamically choose the behavior
e.g. pattern match in Scala, switch case

[In Java, switch case only supports constant value]
Java may use Factory/Abstract Factory patterns

Clojure has multimethod, like polymorphism

1. Operator Overload

2. Functional Data Structure
   Referential transparency

Exception handle:
Either
Option

Architecture
Groovy @Immutable

CQRS
Command-Query Responsibility Segregation
Will use Eventual Consistency instead of transaction
BASE instead of ACID

Functional Database
Datomic
Immutable Data
Record all schema and data updates
Separate read and write
Immutable valud and timestamp in event-driven architect

Meta programming