Please enable JavaScript.

Coggle requires JavaScript to display documents.

(Observability & Reliability, Lead Engineer Expectations, Cloud &…

- - - - Consistency vs availability
  - - - “Scale API to millions”
      - “Fix latency under load”
    - - Answers must include tradeoffs, not just solutions
- - - - Image optimization
  - - - Scaling + deployment
- - - - Factory / Builder
    - - Strategy / Observer
- - - - New → Runnable → Running → Blocked → Terminated
    - - synchronized keyword
        
        DEF: Intrinsic lock on object monitor
        
        Real-world
        
        Protect shared mutable state
        
        ⚠️ Risk
        
        Deadlocks when multiple locks acquired in different order
      - Locks API (ReentrantLock)
        
        More flexible than synchronized (tryLock, fairness)
    - - Race conditions
      - Deadlocks
      - Starvation
  - - - FixedThreadPool
      - CachedThreadPool
      - ForkJoinPool
    - - Control concurrency + resource usage
    - - Wrong pool size → CPU exhaustion or latency
  - - - DEF: Lightweight threads managed by JVM
      - Real-world
        
        Handle thousands of concurrent requests (IO-bound)
      - ⚠️
        
        Not ideal for CPU-heavy workloads
    - - DEF: Treat multiple threads as a single unit of work
      - Benefit
        
        Better error handling + cancellation
    - - Alternative to ThreadLocal (safe context sharing)
  - - - Chaining async operations
      - Real-world
        
        Non-blocking APIs
    - - Callback hell if poorly structured
  - - - Easy parallel data processing
    - - Not always faster (overhead + shared resources)
- - - - Default, balanced throughput/latency
    - - DEF: Low-latency GC (<10ms pauses)
      - Real-world
        
        Cloud-native apps
    - - Concurrent GC alternative
    - - Wrong GC choice impacts latency SLAs
  - - - Objects storage
    - - Method calls + primitives
    - - Class metadata
  - - - -Xms / -Xmx
    - - Pause time vs throughput tradeoff
    - - Tune based on workload (batch vs API)
  - - - Identify CPU/memory bottlenecks
  - - - DEF: Accurate microbenchmarking tool
    - - Avoid naive benchmarking (JIT optimizations)
- - - - Improve query performance
    - - Execution plans
  - - - Caching layer
    - - Document storage
  - - - N+1 query problem
  - - - Prevent dirty reads / race issues
  - - - Write-through / write-back
    - - Separate read/write models
- - - - Text generation / analysis
- - - - DEF: Immutable data carriers
      - Use case
        
        DTOs
    - - Restrict inheritance
      - Domain modeling
    - - instanceof + switch
      - Cleaner code
    - - Return values directly
  - - - Safer string interpolation
    - - Call native code safely
    - - SIMD operations (performance)
    - - Value objects (no object overhead)
  - - - map / flatMap / reduce
    - - Avoid null handling issues
    - - Overuse → unreadable code