Please enable JavaScript.

Coggle requires JavaScript to display documents.

interview - Coggle Diagram

- - - - every time
  - - - exception handling
      - https
      - use routing
      - use authorization
      - map controllers
  - - - result filter
  - - - create HttpContext.User
    - - Verify what is possible
        
        Roles
        
        admin/use
        
        Policies
        
        read.report
        
        create.report
        
        claim is what is storing in jwt
        
        contains of claims
- - - - receive props
      - return jsx
      - hooks
        
        useState
        
        useEffect
        
        To run something after commit phase
        
        calls after paint
        
        useMemo
        
        To record complex execution
        
        useRef
        
        To remember reference to the dom object
        
        useLayoutEffect
        
        calls before paint
    - - useState
      - props
    - - when parent change
      - When props change
      - When state change
      - Force update
      - react.memo
    - - Trigger
        
        runs when
        
        component mounts (first render)
        
        setState / dispatch is called
        
        props change
        
        context value changes
        
        parent re-renders
      - Render/Rerender
        
        hookc calling
        
        useState – reads current state, returns setter
        
        useReducer – reads state, returns dispatch
        
        useContext – reads current context value
        
        useRef – returns the same ref object
        
        useMemo – may execute its function during render
        
        useCallback – may execute during render (creates/memoizes function)
        
        useId – generates stable ID
        
        useDebugValue – DevTools only
      - Reconciliation
      - Commit
      - useLayoutEffects
      - Browser paints
      - UseEffects
      - cleanup/unmount
    - - Reducer
        
        accepts action
        
        Returns new state
        
        useReducer
        
        state
        
        dispatch
        
        reducer
        
        initialState
        
        function accepts current state
        
        redux
        
        Zustand
      - pass properties from up to down
        
        better not deeper thatn 1-2 levels or when all are using
      - use UseContext
        
        declare context outside
        
        use it in the component
      - context API
        
        global data
    - - does react remember state of all the page or not
    - - state
        
        this.setState
      - lifecicle
        
        Component did mount
        
        Component did update
        
        Component will unmount
  - - - rendering
      - network requests
  - - - Classes
      - Interface
        
        compile time
      - Types
        
        Primitive types
        
        number
        
        string
        
        boolean
        
        Special types
        
        any
        
        void
        
        unknown
        
        never
        
        Object
        
        Array
        
        Enums
        
        Function types
- - - - covariance
        
        Collections
        
        No
        
        Interfaces IEnumerable<T>
        
        Yes
      - contrvariance
  - - - events
    - - equals
      - gethashcode
      - gettype
    - - deep
      - shallow
  - - - constant
      - readonly
      - volatile
  - - - O(1)
      - O(n)
      - O(log)
      - Time complexity
      - Space complexity
    - - Except
      - Intersect
      - Where
      - Contains
      - Select
      - SelectMany
      - First
      - Single
        
        throws exception if number of items more than 1
      - Cast
      - OfType
        
        not throw exceptions
  - - - ThreadPool
      - Semaphor
        
        SemaphorSlim
        
        inside one process
      - Countdown
      - ManualResetEvent
        
        to sync phases
        
        keeps open after opening
      - AutoResetEvent
        
        Auto close
      - states
        
        Running
        
        Wait
        
        Ready
        
        did not get cpu but ready
        
        Suspended
      - Mutex
        
        crossprocess
      - Foreground / Background
      - passing data between threads
        
        Interlock.increment
        
        concurrent collections
        
        channel for async
    - - deadlock
      - Monitor
      - Mutex
    - - task based async pattern (TAP)
        
        async/await
        
        Method should return Task to be awaitable
        
        Task<T>
        
        For long running tasks
        
        ValueTask<T>
        
        Use when result is ready sync
        
        .GetAwaiter
        
        Task
        
        CancellationToken
        
        exception should be catched outside
      - Async programming model
        
        begin/end
      - event based async pattern
- - - - Mapping
        
        Attributes
        
        FluentDB
      - DBContext
        
        Unit of work
        
        DBContext
        
        DBSet<Entity>
        
        Entity state
        
        Tracked
        
        To modify
        
        Not Tracked
        
        To load entity for return to views
        
        Attach
        
        To attach entity
        
        Session
      - Migrations
  - - - Partition+Consistent
    - - Clustered
      - Not clustered
    - - select for update
      - advisory lock
      - Optimistic lock
  - - - Parttition + Consistency
  - - - Deadlocks
        
        how to avoid
        
        use optimistic concurrency
        
        not use select for update
      - Advisory locks
      - Database
      - Table
      - Row
      - Locking
        
        Optimistic
        
        Check timestamp
        
        Pessimistic
        
        Lock via FOR UPDATE
        
        release when transaction ends
    - - Read uncommitted
      - Read Committed
      - Repeatable Read
      - Serializable
  - - - Atomicity
        
        Changes have to be done on atomic level
      - Consistency
        
        all data should be consistent
      - Isolation
        
        each transaction isolated
      - Durability
        
        Data stored if something happened
- - - - not idempotent
      - creates something new
      - to create only
    - - there is id
      - idempotent
      - to create or update
    - - repeat is safe
    - - Http 1/2/3
      - Websocket
  - - - Via keys in the request, store request hash, key and response and hav TTL
    - - JWT token
        
        Contains info and hash
        
        Hash created with using private key
    - - TLS
        
        use client and server ephemeral key
        
        get shared secret
        
        (privateA × publicB) == (privateB × publicA)
        
        each part has private and public ephemeral keys
      - RSA
        
        Old
    - - how much requests allowed
        
        fixed window
        
        sliding window
        
        token bucket
        
        leaki bucket
    - - client caching
      - server caching
      - CDN
        
        close to user
      - Reverse proxy
        
        before application to cache response
      - application cache
        
        in memory
        
        distributed
        
        redis
  - - - 200
      - 400
        
        4xx
        
        400
        
        Bad request
        
        429
        
        too many requests
      - 30x
        
        301
        
        moved permanently
        
        302
        
        moved temporary
- - - - reference types
      - small object heap
      - large object heap
      - Task
    - - value types
    - - IDisposable
    - - calls last before destroy
    - - Allow to have reference, but GC can delete the object
- - - - Sync
        
        API
        
        grpc
        
        graphql
      - Async
        
        Queues
        
        Kafka
        
        Rabbit
        
        Ack/Nack
        
        AWS Queue Bus
    - - Threads
    - - CPU
      - Memory
    - - Scalability
        
        Horizontal
        
        Vertical
      - Availability
        
        if one process down, are others are wokring ?
      - Reliability
        
        No memory and other leaks
      - Fault isolation
        
        deadlock blocks everything or only peace
      - Performance
      - Deployability
      - Observability
  - - - MVC
      - MVVM
    - - Clean architecture
        
        Domain <- Application <- Infrastructure <- Presentation
      - Layered
        
        UI -> Services -> Data and Common
      - Hexagon
      - Onion
      - CQRS
        
        Command Query Responsibility Segregation
        
        Controller -> Command -> Handler -> Aggregate -> Repository
        
        Aggregate contains domain logic and service
        
        Aggregate is in domain layer
      - DDD
        
        Entity
        
        ValueEntity
        
        AggregateRoot
        
        Mutable Aggregate
        
        Immutable Aggregate
        
        DomainService
        
        to hold business logic not related to aggregate
        
        Domain Event
        
        Bounded Context
        
        Integration Event
    - - Observer
      - Singletone
      - Decorator
      - Adapter
      - Facade
      - Mediator
      - FLightweight
      - Outbox
      - chain of responsibilty
      - command
    - - Single responsibility
      - Open/Closed
        
        Open for externsions and closed for modifications
      - Liskov principle
        
        I can replace interface by implementation without an issue
      - Interface segregation
        
        Do not implement interface if it's not needed
      - Dependency inversion
        
        higher should not depend on lower other than through the abstraction
    - - Dependency Injection
        
        Scoped
        
        One per request
        
        scope during http request
        
        create new scope
        
        Singletone
      - Service Locator
        
        antipattern