Please enable JavaScript.

Coggle requires JavaScript to display documents.

Javascript (ES6 (ECMAScript: It was created to standardize JavaScript, so…

- - - - CommonJS modules - require
      - ES modules - import
        import X from Y = import { default as X } from Y
  - - - comparator is a higher-order function (because it takes a function and returns a new function)
    - - very often the data needs of a JavaScript application are much simpler than is served by classes.
      - Historically, functional programming has centered around building functions that work to achieve higher-level behaviors and work on very simple data constructs. keep the data needs as simple as possible and build abstract functions that operate on them. Constraining myself to functions operating on simple data, interestingly enough, increases my flexibility.
    - - OO: the interactions between objects cause internal change to each object, leading to an overall system state that is the amalgamation of many smaller, potentially subtle state changes. These interrelated state changes form a conceptual “web of change” that, at times, can be confusing to keep in your head.
      - FP: A functional system, on the other hand, strives to minimize observable state modification. Therefore, adding new features to a system built using functional principles is a matter of understanding how new functions can operate within the context of localized, nondestructive (i.e., original data is never changed) data transformations.
      - Whereas the object-oriented approach tends to break problems into groupings of “nouns,” or objects, a functional approach breaks the same problem into groupings of “verbs,” or functions.
    - - Functional Programming:
        does very little on its own.
        Functional programming is about pulling programs apart and reassembling them from the same parts, abstracted behind function boundaries.
        allows you to separate out domain logic
        The Two Pillars of JavaScript Part 2
        FP v.s. IP
        https://medium.com/@cscalfani/goodbye-object-oriented-programming-a59cda4c0e53
      - Imperative Programming:
        Because imperative code operates at such a precise level of detail, they are often one-shot implementations or at best, difficult to reuse. Further, imperative languages are often restricted to a level of detail that is good for their compilers rather than for their programmers
      - Prototype-based object-oriented programming
        JavaScript instances use existing objects to serve as prototypes for specialized instances. Object specialization, together with a built-in dispatch logic that routes calls down what’s called a prototype chain, is far more low-level than class-oriented pro‐ gramming, but is extremely elegant and powerful.
        In most programming languages offering both functional and object-oriented styles, a trade-off is made in the way that self-reference is handled.
        you’ll notice a fundamental tension between an object-oriented style and a functional style
        The Two Pillars of JavaScript Part 1
      - Metaprogramming
    - - Collection-Centric Programming
        The point of a collection-centric view, as advocated by Underscore and functional programming in general, is to establish a consistent processing idiom so that we can reuse a comprehensive set of functions.
      - the calling by function B of a function A, supplied as an argument to function B originally, e.g. map, reduce, and filter
  - - - _.chain(obj).xxx().tap().yyy().value()
      - _(obj).xxx().yyy()
      - The “magic” that allows method chains is that each method in the chain returns the same host object reference (Stefanov 2010)
        method chaining is the act of writing object methods to all return a common this reference so common methods can be called in sequence
      - :red_flag: implement a lazy chain
        
        _target
        
        _calls: array of thunk (A function that wraps some behavior for later execution)
    - - Pipelines, unlike chains, work against data such as arrays and objects rather than a common reference.
      - pipelines are meant to be pure—no data was harmed by running it through