learning_topics.txt

js
  prototype chain
  inheritance and function prototyping
  closures
  event loop
    microtasks vs macrotasks
    threads, promises, async/await
  observables, promises, iterators, generators
    rxjs
  hoisting

frontend
  advanced typescript types
  why components exist
  frameworks (react, angular, vue, svelte, solid, web components, qwik)
  virtual dom vs incremental dom vs reactvity vs...
  why react context exists
    how context works
  why react hooks exist
    how hooks work
  storage mechanisms (redux, recoil, mobx, zustand, jotai)
  thunks vs sagas
  storage mechanisms in the browser
    local storage
    session storage
    indexed db
    cookies
      jwt
  service workers
  web workers
  connections
    HTTP
      http requests structure
      http response structure
      https and ssl
      get vs post vs others methods
      cors
      http 1.1
      http 2.0
      http 3.0 and quic
    web sockets
    webrtc
    server-sent events
  security
    csrf
    xss
  css (sass, scss, media and container queries, parent selector)
  perf
    critical render path (CRP)
    lighthouse, pagespeed
    FCP, TBT, LCP, CLS metrics

backend
  api
    rest
    graphql
    gRPC
    postman
  databases
    orm
    query builders
    databse migrations
    ACID vs BASE databases
    CAP theorem
    sharding
      vertical database splitting
      horizontal database splitting
      read replicas
      master-slave database replicas
    indexes, primary indexes, multipart indexes
      b-trees, hashes
    sql databses
      mysql
      postgres
    nosql databases
      mongo
      dynamo db
    key-value databases
      redis
      memcached
    full-text search
      elasticsearch
      algolia
    db patterns
      single-table inhteritance
      EAV tables
      Class Table Inheritance
      Concrete Table inheritance
    OLTP vs OLAP
    index / indices
  message brokers and message queues
    pubsub
    bull
    redis
    kafka
    rabbitmq

architecture (system design)
  orchestration vs choreography
    workflows
    sagas
    event-driven
  event-sourcing
  cqrs
  eventual consistency
  techniques
    authentication and authorization (many different methods, e.g. with jwt)
    rate limiting
    cron jobs
    versioning
    hierarhical structure (e.g. file/folder)
    permissions
    notifications
    caching
    aggregate information
  concensus algorithms
    two-phase commit (2PC)
    3PC
    sagas
    paxos
    multi-paxos
    raft
  documentation
    4+1
    arc42
    TOGAF
    C4

misc
  ci/cd (github actions, circle ci, jenkins)
  feature flags (launchdarkly)
  analytics, a/b testing (google analytics, mixpanel, amplitude)
  4 pillars of oop
    abstarction
    encapsulation
    inheritance
    polymorphism
  SOLID principles
    single responsibility principle
    open-close principle
    liskov substitution principle
    interface segragation principle
    dependecy injection
  patterns
    inversion of control (Ioc): dependecy injection vs service locator vs registry pattern
    active record vs repository pattern
    monad (https://www.youtube.com/watch?v=VgA4wCaxp-Q, https://www.youtube.com/watch?v=ENo_B8CZNRQ)