Main Navigation Home

Appearance

Sidebar Navigation

AI

AI (Artificial Intelligence)

Understanding LLMs: A Summary

Algorithms

Dp

LIS (nlogn)

Graph

Articulation Points

Bellman Ford Algorithm

Bipartite Graph Check (BFS)

Bipartite Graph Check (DFS)

Cycle Detection in a Directed Graph (BFS)

Cycle Detection in a Directed Graph (DFS)

Cycle Detection in an Undirected Graph (BFS)

Cycle Detection in an Undirected Graph (DFS)

Dijkstra's Algorithm

Eulerian Circuit

Floyd Warshall Algorithm

Kruskal's Algorithm

Longest Path in a Graph from a Source

Prim's Algorithm

Shortest Path in a DAG

Strongly Connected Components

Tarjan's Algorithm: Bridges

Topological Sort (BFS / Kahn's Algorithm)

Topological Sort (DFS)

Math

NCr

QuickSelect

Quickselect

Segment tree

Segment Tree

Sorting

Merge Sort

Quick Sort (Hoare)

Quick Sort (Lomuto)

Radix Sort

String

Knuth Morris Pratt (KMP) Algorithm

Rabin Karp Algorithm

Z Function

Trees

Construct a Tree from Postorder and Inorder Traversals

Construct a Tree from Preorder and Inorder Traversals

Construct a Tree from Preorder and Postorder Traversals

Inorder Traversal

Morris Inorder Traversal

Morris Preorder Traversal

Postorder Traversal

Preorder Traversal

Preorder, Inorder, and Postorder Traversal

CN

ARP (Address Resolution Protocol)

Authoritative DNS Server

Blocking vs Non Blocking I/O

C10K Problem

CIDR (Classless Inter Domain Routing)

Computer Networks Notes

Congestion Control in TCP

DDoS — Distributed Denial of Service

DHCP (Dynamic Host Configuration Protocol)

DNS Records

Flow Control in TCP (rwnd)

Forward Proxy vs Reverse Proxy

HTTP Keep Alive

HTTP Methods

HTTP/1.1 vs HTTP/2 vs HTTP/3

IPv4 and IPv6

Load Balancer (L4 vs L7)

Logical Addressing & IP Addressing

Long Polling vs Short Polling vs Keep Alive

MAC Addresses

MITM — Man in the Middle Attack

NAT (Network Address Translation)

OSI Model (Open Systems Interconnection)

Packet vs Circuit Switching

PDU Names (Segment / Packet / Frame / Bit)

Sockets

TCP vs UDP

TCP/IP Model

TLS / HTTPS

WebSockets

DBMS

ACID Properties

B+ Tree Index

BASE Properties

CAP Theorem

Checkpointing

Clustered vs Non Clustered Index

Commit & Rollback

Composite Index & Covering Index

Connection Pooling

Database Caching (Query Cache, Redis)

DBMS Interview Preparation — Notes Index

Deadlocks in Databases

Denormalization

Eventual Consistency

Hash Index

Index Selectivity

Isolation Levels

MVCC — Multi Version Concurrency Control

Normal Forms (1NF / 2NF / 3NF / BCNF)

Optimistic vs Pessimistic Locking

ORM Pros and Cons

Partitioning (Range / Hash / List)

Read Replicas

Replication (Master Slave / Master Master)

Serializability

Serializable Isolation & SSI

Sharding (Horizontal Partitioning)

SQL vs NoSQL

Transaction States

Two Phase Commit (2PC)

Two Phase Locking (2PL)

Vertical vs Horizontal Scaling

WAL — Write Ahead Logging

When to Use / Not Use Indexes

Dev

CORS: Cross Origin Resource Sharing

Cryptography

HTTP Cookies

HTTP Methods

OAuth 2.0

Preflight Request

RESTful API

Security During a Connection

Session Based Authentication and JSON Web Tokens

SPA vs. MPA

Javascript

Questions

== vs. ===

Async vs. defer

Bubbling and Trickling

Currying

Debouncing

Event Delegation

IndexedDB

Object vs. Map

Polyfill: apply

Polyfill: bind

Polyfill: call

Polyfill: filter

Polyfill: map

Polyfill: reduce

Property vs. Attribute

Random Hex

Service Worker

Sum Currying

Throttling

Ways to Create Objects in JavaScript

Web Storage

Window vs. Document

Arrays

Async/Await

Callbacks

Closures

Coercing

Const vs. Object.freeze()

Data Types

DOM

Errors

Eval()

Event Loop

Events

Execution Context

Fetch

For...in vs. for...of

Functions

Getters and Setters

JavaScript Map vs WeakMap

JSON

New

Obfuscation

Object.preventExtensions(), Object.seal(), and Object.freeze

Promises

Prototypes

Repaint and Reflow

Scope

Set vs WeakSet

Shadowing and Illegal Shadowing

Stack and Heap Memory

Strict Mode

Strings

Temporal Dead Zone

This

Tree Shaking in JavaScript

V8 Engine

OOPS

Pillars

Abstraction

Encapsulation

Inheritance

Polymorphism

Abstract Class vs Interface

Abstraction

Access Modifiers

Class vs Object

Composition over Inheritance

Constructor / Destructor

Constructors

Coupling vs Cohesion

Covariant Return Types

Deep Copy vs Shallow Copy

Dependency Injection

Destructors

Diamond Problem / Multiple Inheritance

Encapsulation

Final

Friend Class / Function

Functions

Getters / Setters

Immutable Objects

Inheritance

Method Resolution Order (MRO)

Object Oriented Programming

Object Oriented Programming: Final Notes

OOPS Notes

Polymorphism

Public / Private / Protected

SOLID Principles

Static Keyword

Static vs Instance Members

Struct and Class

Super / Parent Class Calls

The this Keyword

Virtual Functions / VTable

OS

01.Process vs Thread

02.Memory Layout Stack Heap Code Segment Registers PC File Descriptors IPC

03.Why Stack Grows Downward Heap Grows Upward

04.Context Switching

05.TLB Translation Lookaside Buffer

06.Logical to Physical Address Mapping

07.Why Offset is Used in Paging

08.Process States

09.User Mode vs Kernel Mode

10.PCB Process Control Block

11.Kernel Level vs User Level Threads

12.Multithreading

13.Multithreading vs Multitasking vs Multiprogramming

14.Monitors Condition Variables

15.Mutex vs Semaphore

16.Binary Semaphore vs Mutex

17.Race Condition Critical Section

18.Deadlock Avoidance Prevention Detection

19.Bankers Algorithm vs Detection Algorithm

20.Scheduling Algorithms Overview Preemptive vs Non Preemptive

21.MLFQ Multi Level Feedback Queue

22.Priority Scheduling

23.Which Scheduling Algorithm is Best

24.NEW Worked Example FCFS SJF SRTF Round Robin

25.NEW Boot Process Power On to Kernel Init

26.Inodes

27.Hard Link vs Soft Link

28.File System Structure

29.File Allocation Methods

30.Journaling

31.Virtual Memory Paging

32.Swap Space

33.Copy On Write COW

34.Fragmentation Internal External

35.Memory Mapped Files

36.IPC Pipes

37.IPC Shared Memory

38.IPC Sockets

39.IPC Message Queues

40.Signals

41.Blocking Non Blocking Async IO

42.Buffering Caching Spooling

43.Disk Scheduling SSTF SCAN etc

44.Interrupts Exceptions

45.Buffer Overflow

46.Privilege Escalation

47.Monolithic vs Microkernel vs Hybrid Kernel

48.NEW Virtualization Hypervisors vs Containers

React

Hooks

ForwardRef and useImperativeHandle

Hooks

UseCallback Hook

UseContext Hook

UseEffect Hook

UseLayoutEffect Hook

UseMemo Hook

UseRef Hook

UseState Hook

About React

Class and Functional Components

Element V/S Component

Error Boundaries

Lazy Loading and Code Splitting

React.memo

Synthetic Events

Virtual DOM, Reconciliation, and React Fiber

SQL

SQL Query Execution Order

System design

API Design & Architecture

Back of the Envelope Estimation & Capacity Planning

Blob & Object Storage Architecture

Caching: Architecture & Failure Modes

CAP Theorem & Distributed Consistency

Change Data Capture (CDC)

Consistent Hashing

Data Modeling & Schema Design

Database Sharding

Distributed Coordination, Consensus & Quorums

Distributed Systems Networking

Event Driven Architecture (EDA)

Long Polling

Message Brokers & Event Streaming

Serverless vs. Serverful Architectures

Time to Live (TTL)

Typescript

Compiler Pipeline

Utility Types

Contributing to Realm Notes 📚

Realm notes

On this page

Abstraction

Implementation hiding.

Pager

Previous pageRendering

Next pageEncapsulation

Abstraction ​

Abstraction