Chad Furman chadfurman

Speaker Introduction Part 1

@getify -- Kyle Simpson -- Teaches JS professionally
- 50-75% traveling and teaching, rest of time “community building” -- open source / speaking / meet-ups
LABjs -- dynamic script loader, 5-years old -- fast, ensure order for dependencies
- Concatenate everything, why script loader? Seeing a switch to HTTP2. Why is this important? HTTP2 changes the way we optimize page load -- persistent socket protocol. Parallel downlaoding.
“Grips” -- templating engine.
- There are “logicless” templating engines like mustache. Requires a brittle connection between backend and frontend. Lots of data massaging.
- Alternative -- whole programming language embedded into template. I.E. PHP, Dust, Handlebars. Causes mess of business logic leaked into template due to business pressure.
- “Grips” is an oppinionated templating engine

Scope and Execution Review:

var foo = "bar"; // LHS foo, RHS "bar", foo global scope

function bar() { // remember bar is a declaration in global scope
  var foo = "baz"; // LHS foo, RHS "baz", foo local to bar()
  
  function baz(foo) { // remember `foo` is declared here as local to baz
 foo = "bam";

Meeting Notes:

Discussed reviewing meeting notes at the end -- divide and conqueror? Putting together a nice writeup for each day?
Talked about note writing techniques
let hijacks block-scope -- differences between let and var is "block scope" and "hoisting"
let is cool, has some advantages, but is it really useful? Garbage collector? Security? "Hoisting" is important!
let-blocks are cool. Too bad they're not actually in JS. let-er is cool, but try/catch work-around is lame.
let is cool, but must be used with caution
Does let actually increase performance? let might be a bit more performant, due to stricter scope and better garbage collecting
Mozilla suggests "use let" with transpilers, even though let isn't supported yet.
let "is" hoisted? Just hoisted with a different value -- "undeclared" rather than the value you give it.

Dynamic Scope

Theoretical -- not used in JS

function foo() {
  console.log(bar); // bar is defined in baz, foo was called from baz, so bar is defined
}

function baz() {
  var bar = "bar"; // this is defined in foo because of the callstack
  foo();

The new keyword

When we put the new keyword infront of any funciton call, it turns the function call into a constructor call This isn't the same as a class There are 4 things that happen when a new keyword is put infront of a function call:

An empty object is created
The empty object gets linked to a different object
empty object gets bound as this for the purpose of the function call
if the function does not otherwise return anything, new will insert return this

Meeting notes

Module pattern is very common. Old way of wrapping with a function, new way of export/import
Module pattern is something many frameworks have been using for a long time.
A really useful pattern since in JS we don't have access modifiers
What about module ___ from 'module' ? I think it's actually import * as module from 'module'
What about multiple exports in a single file? I think this is legal
this keyword -- the four rules.
- new keyword
- explicit
implicit

Prototypes

object oriented JS has lots of complexity -- going to try to simplify common OO patterns prototypes "Inheritance" vs "behavior delegation" "There are no Classes in JS" -- we need a different syntax & design pattern for our software "OO vs OLOO"?

var Router = function() {
  // Singleton!

Prototypes

Prototype Links [[Prototype]]
proto vs .prototype
this being super unicorn magic
Singleton, Observer patterns? Anyone use?
It'll be good to squish our notes together into pages
Likewise, it will also be good to add some questions to Aurelian's tool