Backend Engineering

Concepts

• Understand Protocols

  • TCP

  • UDP

  • HTTP

• Remote procedure call (RPC) styles

  • Rest style

  • GraphQl

  • Websockets

  • gRpc

• Object-Oriented Design

  • Abstraction

    • Only relevant, client tailored API is exposed to clients

  • Polymorphism

    • Method changes behavior at runtime

  • Inheritance

    • Reusing parent class functionality

  • Encapsulation

    • Hiding information and keeping related functionality together

  • Composition, Aggregation

    • Instead of inheritance, composition uses the object to achieve code reuse

    • Aggregation: Relation where A has B and B can exist without A

    • Composition: Relation where A has B and B can NOT exist without A

  • https://github.com/iamitshri/design-patterns

• Open API

  • Contract Driven Design

• Domain Driven Design

  • Domain

    • Subdomain

    • Domain Modelling

    • Domain experts

  • Context Map

  • Ubiquitous Language

  • Application service, domain layer, Infrastucture layer

  • Aggregate, Entity, Value

  • Big ball of mud

• Service Oriented Architecture (Microservices)

  • Service interacts with each other using well-defined API

• Concurrency

  • Process vs Thread.

    • Process is instance of program in execution. Has a separate address space. Can not access data of other process directly

    • Thread: A thread is a particular execution path of a process

  • Semaphores vs mutexes

    • A mutex is a locking mechanism used to synchronize access to a resource while a semaphore is more like a signaling mechanism

    • A semaphore is a signalling mechanism that restricts the number of simultaneous users for a shared resource up to a maximum number. Threads can request access to the resource (by decrementing the semaphore) and can signal that they have finished using the resource (by incrementing the semaphore).

    • A mutex provides mutual exclusion. For example, either a producer or a consumer can have the key (mutex) to proceed with their work. As long as the buffer is being filled by the producer, the consumer needs to wait and vice-versa.

  • Starving

    • Thread can not make progress due to greedy or high prioritized threads getting access to resource before starved thread

  • Deadlock

    • Threads waiting on each other for releasing the resource

  • LiveLock

    • Thread is too busy responding events than doing progressing or doing useful work

• Database

  • Relational

    • popular choices: mysql, postgres, oracle, sqlserver

  • Indexes

  • Sharding

  • Consistent Hashing

  • Partitioning

  • CAP

  • Document Oriented Database

    • Key Value Paradigm

      • MongoDB

      • Cassandra

      • Dynamodb

      • CouchDB, RethinkDb

  • Graph databases

  • Neo4j

  • Transaction.

  • Transaction Isolation Levels

    • Read Committed

    • Repeatable Read.

    • Read Uncommitted

    • Serializable

  • ACID

    • Atomic

    • Consistent

    • Isolated

    • Durable

• CORS

  • Cross Origin Request

  • All CORS request have an Origin header

  • Host: Domain where request will be handeled

  • Origin: Domain from where request is originated

    • Access-Control-Allow-Credentials

    • Access-Control-Allow-Headers

    • Access-Control-Allow-Methods

    • Access-Control-Allow-Origin

    • Access-Control-Expose-Headers

    • Access-Control-Max-Age

    • Access-Control-Request-Headers

    • Access-Control-Request-Method

• Caching

  • Redis, Memcache, aws Elastic Cache

  • Eviction policies

  • LRU

  • Least Frequently used

  • Caching Strategies

  • app reads from cache, if miss read from db

  • app write to db, write to cache

  • app write to cache, write to db

  • app write to cache, cache asynchrnously saves to db

• Testing

  • Unit testing the logic

  • Integration testing

  • Contract Driven Testing

    • pact.io

    • spring cloud contract

• Tools for Application Performance Monitoring (APM)

  • New Relic, Datadog, Appdynamics, Promethus

  • API Performance Monitoring

  • Infrastructure Monitoring

  • Alerting (OpsGenie, Pagerduty)

• Log or events Aggregation

  • Querying

  • Visualization

• DevOPs

  • Developer knows how to create, deploy and maintain their infrastructure resource

  • Continuous Integration and Continuous deployment(CICD)

  • Manual deployment is avoided

  • Manual testing is minimized

  • Process are optimized for faster release cycle

    • Bugs are inevitable, so we embrace them by optimizing our processes to fix them faster

References

• https://github.com/SuyashLakhotia/TechInterview

• https://docs.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/ddd-oriented-microservice