Please enable JavaScript.
Coggle requires JavaScript to display documents.
The agnostic JavaScript - Coggle Diagram
The agnostic JavaScript
JavaScript Internals
Single threaded js
Garbage collection
Interpreter/Compiler
JIT Compiler
Call stack
Event loop
Memory heap
JavaScript runtime
JavaScript engine
Testing
Integration testing
Unit testing
BDD
TDD
Mocks
Coding Paradigms
OOP
Four pillars
Polymorphism
Encapsulation
Inheritance
Abstraction
Classes
Objects
Constructors
Static properties
Access modifiers
Setters
Getters
Prototypes
Factories
Prototypal inheritance
__proto__
Functional programming
Introduction
What is FP?
The four pillars of FP
Coding styles
Recursion
What is recursion?
Recursive functions
Recursion flaws
Why to use recursion
Recursion anatomy
Recursion workflow
Recursion optimiziation
TCO
STC
PTC
Trampolines
Nesting functions
The unix philosophy
Math & OOP Philosophy
FP Philosophy
Piping and composition
Composition associativity
Revisiting point free
Immutability
What is immutability?
Primitive Immutability
Rethinking const keyword
Object.freeze
Copying values, not mutating
Immutable data structures
Immutable libraries
Functions
HOFS
Map
Reduce
Filter
Functions purity
What is a function?
Point free functions
Equational reasoning
Procedures
Side effects
Extracting impurity
Containing impurity
Functions arguments
Scopes
Global scope
Script scope
Block scope
Local scope
Lexical scope
Closures
Lazy vs Eager execution
Memoization
Referential transparency
General to special
Currying
Partial applications
Shaping functions
Module pattern
IIFEs
Functors
What is a functor?
A container functor
Revisiting map & filter
Revisiting reduce
Advanced list ops
unique
uniqueMap
flat
flatMap
zip
merge
Fusion
Transduction
Higher order functions
What is a higher order function?
The map function
The filter function
The reduce function
The mapReduce function
Design Patterns
Structural patterns
Proxy
Flywieght
Facade
Composite
Decrator
Adapter
Bridge
Behavioral patterns
Chain of responsibility
Command
Mediator
Iterator
Observer
Memento
State
Strategy
Visitor
Template method
Creational patterns
Factory method
Abstract factory
Builder
Prototype
Singleton
Solid Principles
Single responsibility
Open closed
Liskov substitution
Interface segregation
Dependency inversion
Algorithms
Recursion
Sorting algorithms
Bubble Sort
Insertion Sort
Merge Sort
Selection sort
Quick sort
Radix sort
Selection algorithms
Searching algorithms
Linear search
Binary search
Dynamic programming
Data Structures
Hash table
Graphs
Trees
Non-Linear
Heaps
Binary Heaps
Priority Queue
BinarySearchTree
BalancedTrees
AVL Tree
RedBlack tree
BinaryTrees
Tries
Linear
Singly Linked List
Doubly Linked List
Circular
Tree Traversal (Lookup)
Breadth First Search (BFS)
Graph Traversal
Depth First Search (DFS)
Post order
Pre order
In order
Directed
Undirected
Acyclic
Weighted
Cyclic
Unwieghted
Queues
Linked List
Arrays
Stacks
Arrays
Big(O) Notation
O(1)
O(n)
O(log N)
O(n^2)
O(n log N)
JavaScript Foundation
Types
Type coercion
Type equality
Static typing
Scopes
Array destructuring
Object destructuring
ES new features
Hoisting
Execution context
Reactive Programming
Asynchronous JavaScript
Prerequisites
JS async model
Single threaded javascript
callstack
Event loop
Microtask Queue
Callbacks
Thunks
Promises
Iterators
Object iterating
Generators
Recursive Generators
Async await keywords
Async Generators
Async iteration
Top level awaits
Async generators looping
Observeables
Channels
TypeScript