Tech Jargon - Decoded

What is HTTPS and how does it work? HTTPS is the secure version of HTTP. It ensures that all data sent between a browser and a server is encrypted and kept private. Problem it solves: Standard HTTP sends data in plain text. This allows hackers to intercept and read sensitive info like passwords. HTTPS prevents this "eavesdropping" by scrambling the data. How it works: • Handshake: The browser and server connect and agree to communicate securely. • Certificate Check: The server sends an SSL certificate to prove its identity. • Key Exchange: Both sides generate a unique "secret key" for the session. • Encryption: Data is turned into unreadable code before being sent. Only the receiver can unlock it using the key. Simple Scenario: When you type a password into a form, HTTPS converts it into a random string of characters before it travels across the internet, making it useless to anyone who steals it.

How does TCP/IP enable internet communication? It is a set of rules that governs how data is sent across networks. It ensures that information moves accurately between devices. The Working: • Packetizing: TCP breaks data into small pieces so they move easily. • Addressing: IP assigns a destination address to every piece. • Routing: Routers read the IP and forward data toward the destination. • Reliability: TCP waits for confirmation. If a piece is lost, it is sent again. • Sequencing: The receiver reorders the pieces to recreate the original data. Problem Solved: Fixes the issue of "unreliable networks." It handles data loss and packet congestion automatically so the user gets a perfect copy without errors. Scenario: When opening a website, your request is split into packets. Even if some packets arrive late or out of order, TCP/IP reassembles them so the page displays correctly.

What is TCP/IP? It is the standard set of rules that allows computers to communicate across a network. It acts as the basic "language" of the internet. How it works: • TCP (Transmission Control Protocol): Breaks data into small chunks called packets. It numbers them and ensures they arrive safely. If a packet goes missing, it requests a resend. • IP (Internet Protocol): Handles the addressing. It labels each packet with the source and destination IP addresses so routers know where to send them. Problem it solves: It prevents data loss and corruption. Without it, data sent over long distances would arrive scrambled or incomplete, and different types of hardware wouldn't be able to talk to each other. Simple Scenario: When you fetch a webpage, TCP breaks the page data into packets. IP routes these packets through various servers to your device. TCP then checks that every packet arrived and puts them back in the correct order to display the site.

What does it mean for a process to be CPU Bound? It refers to a situation where the speed of a task is limited by the processor's performance. The execution progress depends entirely on how fast the CPU can crunch numbers and run logic. How it works: • The CPU stays at nearly 100% usage during the task. • The program spends most of its time executing instructions in the register/cache. • It rarely waits for data from the hard drive or the network. • If you upgrade to a faster processor, the task completes in less time. Use Case Scenario: Performing heavy mathematical calculations or data encryption. The system is stuck waiting for the next logic cycle to finish before it can move to the next step of the algorithm. Problem it solves: It allows the system to maximize raw computational throughput when data is already available in memory, ensuring no processor cycles are wasted sitting idle.

What is I/O Bound? I/O bound refers to a state where the execution of a program is limited by the speed of Input/Output operations rather than the processor. • How it works: - The CPU executes its tasks extremely quickly. - It then makes a request to an external source, like a disk, a database, or a network. - The CPU must sit idle (wait) until that external source sends the data back. - The total time taken depends almost entirely on the speed of the I/O device. • Why it matters: - It helps you identify that upgrading your CPU won't improve performance. - It shows when to use asynchronous programming or multithreading to keep the CPU busy with other tasks while waiting. • Simple Scenario: A script fetching data from a web API. The CPU finishes its logic in 1ms but stays idle for 200ms waiting for the network response. The task is limited by the network speed, not the code speed.

What is a System Call? It is a programmatic way for a computer program to request a service from the Operating System's kernel. Think of it as a bridge between an application and the hardware. Problem Solved: User programs are restricted from touching hardware directly to prevent system crashes or security breaches. System calls provide a secure, controlled interface to handle these tasks. How it Works: • A program runs in User Mode. • To access a resource, it triggers a Trap (special interrupt). • The CPU switches from User Mode to Kernel Mode. • The OS looks up the request in a System Call Table and executes it. • Once finished, the CPU switches back to User Mode. Use Case Scenario: When a program needs to save a file, it cannot write to the disk itself. It issues an open() and write() system call. The OS verifies permissions, handles the physical disk movement, and returns a success message to the program.

What is a Warm Start? It is a technique where a system or process is kept in a "ready" state after its first execution. Instead of shutting down completely, it stays active in memory to handle the next request immediately. How it works: • The process loads all necessary files and libraries during the first run. • Once the task is done, the system keeps the environment alive instead of clearing it. • When a new command is received, the system skips the "setup" phase. • It directly executes the task using the pre-loaded resources. Problem it solves: It eliminates Cold Start latency. This is the delay or "lag" experienced when a system has to boot up and establish connections from scratch. Simple Scenario: In cloud computing, a function stays "warm" in the background for a few minutes after use. If triggered again, it responds instantly because the memory and connections are already active.

What is a Cold Start? It is the startup delay that happens when a system or function is triggered after being idle. Since no resources are active, the system must build the environment from scratch. How it works: • A request arrives but no active instance is running. • The platform allocates compute resources. • It downloads the code and initializes the runtime. • The system handles the request and stays "warm" for a short period. • If no more requests come, it shuts down to save resources. Problems it solves: • Prevents memory wastage by killing idle processes. • Lowers infrastructure costs by only running code when needed. Scenario: A cloud function is called after hours of inactivity. The system spends 2 seconds booting the environment before the code runs. Subsequent calls happen instantly because the environment is already prepared.

What is Cache Invalidation? It is the process of removing or updating data stored in a cache when the original data in the database changes. How it works: - When a "Write" or "Update" operation happens in the database, the system flags the existing cached version of that data as outdated. - The system then either deletes the cached entry (Purge) or replaces it with the new data (Update). - This ensures that the next "Read" request doesn't fetch old information. Problem it solves: - Data Inconsistency: It prevents the "Stale Data" problem where the cache shows old info while the database has the new version. - Sync Issues: It keeps the fast-access layer (cache) and the permanent storage (DB) synchronized. Scenario: You change your account password. If the old password stays in the cache, you might still log in with it or get errors. Invalidation clears that old password entry so the system checks the database for the new one.

What is a Cache? A cache is a high-speed data storage layer that sits between an application and the main storage (like a database or disk). It stores temporary copies of data so that future requests for that same data can be served much faster. Problem it solves: Retrieving data from primary storage is often slow due to hardware limitations or heavy processing. Cache reduces latency and prevents the main system from getting overwhelmed by repetitive requests. How it works: • Request: The system first checks the cache for the required data. • Cache Hit: If found, the data is delivered instantly to the user. • Cache Miss: If not found, the system fetches it from the slow main storage. • Storage: After fetching, it saves a copy in the cache for the next time. Simple Scenario: When you view a profile, the app fetches details from a slow database. If you refresh, the app pulls that same data from the Cache in milliseconds instead of hitting the database again.

What is a Buffer Overflow? It occurs when a program writes more data to a fixed-length block of memory (a buffer) than it can actually hold. How it works: • Memory is allocated in specific sizes for variables and data. • Without proper "bounds checking," extra input spills over the boundary. • This excess data overwrites adjacent memory addresses in the RAM. • It often targets the Return Address, which tells the CPU where to go next. What it achieves: • It allows an attacker to hijack the program's execution flow. • By overwriting system instructions, the software can be forced to run malicious code or crash. Simple Scenario: A program reserves 10 bytes for a "Username" field. If you send 60 bytes, the extra 50 bytes overwrite the program's internal logic, allowing you to bypass a login screen or gain control.

What is a Buffer? A buffer is a temporary storage area in memory (RAM) used to hold data while it is being transferred from one place to another. It acts as a middleman to manage the flow of information. How it works: • One component (the source) writes data into the buffer. • Another component (the target) reads that data from the buffer. • It holds the data until the receiving end is ready to process it. Problem it solves: It fixes the Speed Mismatch problem. Without a buffer, a fast processor would have to stop and wait for a slow device to finish, causing the system to freeze or lag. Simple Scenario: A hard drive is much slower than a CPU. Instead of the CPU waiting for every single byte, the hard drive fills a buffer with a large block of data. The CPU then pulls that whole block from the fast RAM instantly, saving time.

What is Stack Memory? It is a dedicated region in RAM used for temporary data storage while a program runs. It follows a LIFO (Last-In, First-Out) structure. How it works: • A Stack Pointer tracks the current top of the memory. • When a function is called, a "frame" is pushed onto the stack to store its local variables and return address. • As soon as the function finishes, that frame is popped off. • The pointer simply moves back, making that space available for the next operation. Problems it solves: • Manual Cleanup: You don't have to manually delete local variables; the system clears them automatically. • Execution Tracking: It remembers exactly where to return after a function finishes. Simple Scenario: If Function A calls Function B, B’s data is stacked on top of A's. Once B is done, its memory is wiped instantly, and the CPU resumes A right where it left off.

What is a Heap? A Heap is a specialized tree-based data structure that follows specific ordering rules. It is always a complete binary tree, meaning every level is filled except possibly the last, which is filled from left to right. How it works: • Max-Heap: The parent node is always greater than or equal to its children. The largest value stays at the root. • Min-Heap: The parent node is always smaller than or equal to its children. The smallest value stays at the root. • Restructuring: When you add or remove elements, the heap performs a "heapify" process to shift nodes up or down until the order is restored. Problem it solves: It eliminates the need to sort an entire list just to find the maximum or minimum value. You get instant access to the top element in O(1) time. Use Case Scenario: In a Priority Queue, if you need to process data based on the highest numerical rank, a Max-Heap ensures the largest value is always ready to be extracted next.

What is Garbage Collection? It is an automatic memory management process used by programming languages to handle system resources. How it works: • The system constantly monitors objects in the Heap memory. • It tracks "references"—if an object is no longer linked to any part of the running code, it is marked as unreachable. • The collector periodically pauses the program to delete these unreachable objects and reclaim their space. Problem it solves: • Memory Leaks: Prevents programs from filling up RAM with data that is no longer needed. • Manual Errors: Eliminates the need for developers to manually allocate and "free" memory, which often leads to crashes or security bugs. Simple Scenario: If you initialize a variable inside a function, that variable is only needed while the function runs. Once the function finishes, the variable becomes "orphaned." The Garbage Collector detects this orphan and wipes it from memory so new data can take its place.

What is a Memory Leak? A memory leak happens when a program reserves space in the system's RAM but fails to release it back once it is no longer needed. How it works: • The application requests a block of memory to store data. • After the task is finished, the code fails to "free" or delete that block. • Because the reference is lost but the space isn't cleared, the system thinks the memory is still active. • This occupied space remains unavailable for any other task. The Problem: It prevents efficient resource management. As leaks accumulate, the available RAM shrinks, causing the software to lag, stutter, and eventually crash due to Out of Memory errors. Scenario: A script that constantly creates new objects inside a loop and stores them in a global list without ever clearing the old entries. Over time, that list grows until it consumes all system memory.

What is Context Switching? It is the mechanism of storing the state of a running process so that it can be paused and resumed later from the same point. How it works: • The CPU pauses the active process. • It saves the current execution data (Registers, Program Counter) into a Process Control Block (PCB). • The OS then retrieves the PCB of the next process waiting in the queue. • It loads those saved values back into the CPU registers. • The CPU starts executing the new process exactly where it last left off. Problem it solves: It prevents a single process from hogging the processor. Without this, you couldn't run multiple programs simultaneously on a single CPU core. It enables Multitasking and efficient CPU utilization. Technical Scenario: When Process A needs to wait for a slow I/O operation (like reading a file), the OS performs a switch to Process B so the CPU doesn't sit idle.

What is a Race Condition? A race condition occurs when two or more threads/processes access shared data and try to change it at the same time. Because the threads "race" to finish their task, the final result depends on the order of execution, which is unpredictable. How it works: • Multiple threads read the same shared variable. • They perform a calculation locally. • They attempt to write the new value back to memory. • If one thread writes its result before another finishes, the intermediate data is lost or overwritten incorrectly. Simple Scenario: • Initial state: Value = 10 • Thread A reads 10. • Thread B reads 10. • Thread A increments it to 11 and saves it. • Thread B increments it to 11 and saves it. • Result: 11 (It should have been 12). Why it matters: Identifying race conditions is crucial for data integrity. It helps developers realize when to implement Mutual Exclusion (Mutex) or Locks to ensure only one thread can modify data at a time.

What is a Deadlock in OS? A deadlock is a situation where a set of processes are blocked because each process is holding a resource and waiting for another resource held by someone else in the group. None of them can proceed, causing the system to get stuck. How it works: It usually happens when these conditions are met: • Hold & Wait: A process holds at least one resource and waits for more. • No Preemption: The OS cannot forcibly take a resource back. • Circular Wait: Process 1 waits for Process 2, and Process 2 waits for Process 1. The Scenario: - Process A holds Resource 1 but needs Resource 2 to finish. - Process B holds Resource 2 but needs Resource 1 to finish. Since neither will let go of what they have, they wait forever. Why it matters: Studying deadlocks helps in building "Deadlock Avoidance" or "Detection" algorithms. It ensures that the Operating System can manage shared resources (like CPU time or memory) without freezing the entire system.

What is Parallelism? It is the simultaneous execution of multiple tasks or processes. Instead of waiting for one instruction to finish before starting the next, the hardware runs them at the exact same time. How it works: • A large computation is broken down into smaller, independent parts. • These parts are assigned to different CPU cores or separate processors. • Every core executes its assigned part concurrently. • The system then syncs the outputs to deliver the final result. Problems it solves: • Latency: It reduces the total time taken for heavy computations. • Resource Idling: It prevents multiple CPU cores from sitting idle while one core is overworked. Use Case: In data processing, if you need to filter 1 million rows, the system splits the rows into four blocks. Four cores process these blocks at once, finishing the task 4x faster than a single core.