Immutable Data Structures

Agenda for today

• 10:30 - 11:30  Lecture: Functional Programming
• 11:30 - 1:00    Workshop: Immutable Linked List
• 1:00 - 2:30      Break
• 2:30 - 3:00      Review: Immutable Linked List
• 3:00 - 4:00      Lecture: Git Internals
• 4:00 - 5:30      Workshop: FVS
• 5:30 - 6:00      Review: FVS

Programming paradigms

• Programming paradigms describe a particular approach to problem solving
• Some paradigms you may have heard of:
  • Procedural, Imperative, Object oriented, Declarative, Functional
• Paradigms/styles/techniques/patterns - these are all just tools for solving particular problems
  • Some tools are better suited for certain jobs

OO programming

• Object oriented programming: main unit of computation is an object, which has attributes and methods that are defined in a blueprint called a class
• Great for modeling real world entities

function Dog (name, breed) {
  this.name = name;
  this.breed = breed;
}

Dog.prototype.bark = function () {
  console.log('Arf, my name is ', this.name);
};

const cody = new Dog('Cody', 'pug');
cody.bark();

Functional programming

• Functional programming: main unit of computation is a function, which must produce the same output for the same input
• ​Avoids mutation of state and side effects
• Great for modeling transforms of data (ex. map and filter operations)

const arr = [1, 2, 3];

const newArray = arr
  .map(item => item * 3)
  .filter(item => item % 2 === 0);

console.log(newArray) // [6]

Other Features of Functional programming

• Pure functions
• "First class" functions
• Higher order functions
• Function composition
• Emphasis on recursion
• Immutability

Pure Functions

• Same input === same output
• No side effects
  • Logging to the console, file IO, network requests...you know, pretty useful stuff
  • We need effects to write useful applications - the trick is to know when to use a pure function vs. an impure function

First class functions

• Functions can be treated the same way as any other value (can be stored in a variable, passed around, etc)

Higher order functions

• Functions that return functions, and/or take a function as an argument

Composition

• Two or more functions can be composed together into a new function
• The output of one becomes the input of the other
• Opens the door to reasoning about your functions using established mathematical laws
• Requires using unary functions (functions that accept one and only one argument)

const composedFunction = compose(f, g)

composedFunction(x) === f(g(x))

Recursion

• Replaces for/while with recursion
• Any problem that can be solved iteratively can be solved recursively

function factorial (x) {
  let result = x;
  for (let i = x - 1; i > 1; i--) {
    result *= i;
  }
  return result
}

function factorial(x) {
  return x === 1 ? x : x * factorial(x - 1);
}

JavaScript & Fn Programming

• Some languages (like Java) were designed to adhere very strictly to the object-oriented paradigm, so until very recently, functional programming has been extremely difficult
• Other languages, like Haskell, Erlang and Elixer are purely functional
• JavaScript supports both! This is great because that means you can be flexible, but challenging because you have to be careful not to "break the rules"

Immutability & JS

• Immutability: State cannot be modified after creation
• In JavaScript, primitive types like numbers, strings and booleans are immutable
• Objects, including Functions and Arrays, are mutable
  • You can push, pop, attach properties and methods, etc.

Numbers, strings, booleans

Objects, arrays

let obj = {a: 'someData'};

lolFunction(obj);

console.log(obj) // what are we going to get?

Immutable Data Structures

• What if, instead of mutating an array, using push or pop behaved like map or filter, and returned a new array?
• What if assigning a new key-value pair in an object was an operation that returned a new copy of the object?

let obj = {a: 'someData'};

let newObj = lolFunction(obj);

// now I know that if I want to use obj, I'm using obj
// and if I want to use newObj, I'm getting newObj

Advantages of immutable data

• Predictability, of course
• Easier to debug, since you could have physical access to the history of state changes
  • "Undo" becomes a trivial operation
• Gain the ability to treat a collection of data like a value

Performance and Memory

• Memory
  • Structural sharing: re-use existing nodes via references - don't just copy/paste all the time
  • Some dependency on garbage collection in your environment
• Performance
  • Performance benefits can depend on what you're trying to do, and is often comparable to mutable data structures

Immutable Linked List Operations & Structural Sharing

Prepend

Prepend

Prepend

Append

Append

Append

Insert

Insert

Insert

This is structural sharing!

Copy (Mutation)

const arr1 = ["green", "pink", "blue"];

Copy (Mutation)

Copy (Mutation)

var arr1 = ["green", "pink", "blue"];
var arr2 = ["green", "pink", "blue"];

arr1 === arr2 // false

// remember that === between two objects compares 
// address in memory

Copy (Immutable)

const arr1 = [1, 2, 3];

Copy (Immutable)

..........um, we're done?

const arr1 = [1, 2, 3];
const arr2 = [1, 2, 3];

arr1 === arr2 // true

// we could just re-use the memory 
// we've already allocated

Mutable v Immutable

• Mutable single-linked list (assuming front, back and insertion nodes are known):
  • ​Prepend: O(1)
  • ​Append: O(1)
  • Insert: O(1)
  • Find: O(n)
  • Copy: O(n)
• Immutable single-linked list (assuming front, back and insertion nodes are known):
  • ​Prepend: O(1)
  • Append: O(n)
  • Insert: O(n)
  • Find: O(n)
  • Copy: O(1)

Git & Immutability

Git

• Each commit is a small text file that references a directory (also called a "tree" - don't get confused), and the commit that came before

• Each "tree" (directory) references the files in that directory, or the subdirectories (other "trees")
• Each file is identified by a hash of its contents
• By using structural sharing, Git creates the minimum number of objects necessary
  • Git is an immutable linked structure!

Commit B

(message: "I just commited some changes!")

Tree (/my-prj)

Tree (my-prj/js)

Tree (my-prj/css)

Blob (my-prj/js/app.js)

Blob (my-prj/js/utils.js)

Blob (my-prj/css/style.css)

Commit C 

Commit A 

/my-prj
  /js
    app.js
    utils.js
  /css
    style.css

Commit B

(message: "I just commited some changes!")

Tree (/my-prj)

Tree (my-prj/js)

Tree (my-prj/css)

Blob (my-prj/js/app.js)

Blob (my-prj/js/utils.js)

Blob

(my-prj/css/style.css)

Commit C

(message: "I just changed style.css!") 

/my-prj
  /js
    app.js
    utils.js
  /css
    style.css (CHANGED!)

Tree` (/my-prj)

Tree` (my-prj/css)

Blob`

(prj/css/style.css)

Content Addressable

• How does git know when to create a new node?
• Git "objects" (commits, trees and file "blobs") are content addressable
  • Identified using a hash of its contents
  • Objects with the same content will have the same hash
  • Collision is highly unlikely
• Remember: hashing algorithms use modular math to return a value that uniquely identifies the input, no matter how long it is

SHA1

• "Secure hashing algorithm 1"
• The primary hashing algorithim used by Git
• Exposed in Node via the crypto module
  • Look out! Feb 23 2017: https://security.googleblog.com/2017/02/announcing-first-sha1-collision.html

Workshop

Your task

• Create an immutable linked list
• Specs: 1-functional-linked-list/list.spec.js
• Work in 1-functional-linked-list/list.js
• Hint: I highly recommend recursion

git clone https://github.com/FullstackAcademy/fvs