Tech Jargon - Decoded

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.

What is Concurrency? It is the system's ability to handle multiple tasks by overlapping their execution. It doesn't mean tasks run at the exact same instant, but rather that they are all "in progress" at the same time. How it works: • The CPU manages several tasks by switching between them very fast. • It executes a small part of Task A, pauses it, moves to Task B, then back to A. • This "context switching" happens so quickly that it creates the illusion of simultaneous execution. Problem it solves: It prevents Idle Time and Blocking. Without it, if one task (like waiting for a database) takes time, the entire program would freeze. Concurrency lets the CPU work on other things while waiting. Simple Scenario: In a software app, one process can fetch data from a server in the background while another process keeps the user interface responsive and clickable.

What is Multithreading? It is a technique where a single process is divided into multiple independent units called threads that run concurrently. How it works: • The CPU allocates small time slices to each thread. • It switches between these threads rapidly, creating the illusion of parallel execution. • All threads within the process share the same memory and resources but execute different instructions. Problem Solved: • It fixes Process Blocking. In single-threaded systems, a heavy task stops the entire program. • Multithreading allows background tasks to run without pausing the main execution. Simple Scenario: In a software application, one thread handles the User Interface (clicks/typing) while another Worker Thread handles a large data download in the background.

What is a Process? A process is simply a program in execution. While a program is just a static file on your disk, a process is that code actively running in the system memory. How it works: • The OS loads the code from storage into the RAM. • It assigns a unique Process ID (PID) to track it. • The CPU executes instructions one by one using a Program Counter. • The OS allocates specific memory (stack and heap) for the task's data. Problem it solves: It enables multitasking. It provides "isolation," ensuring that multiple tasks can run at the same time without one task accessing or corrupting the memory of another. Simple Use Case: If you run a script to calculate logic and another script to log data, the OS treats them as two separate processes. If the logic script crashes, the logger process continues to run unaffected.

What is a Kernel? It is the core part of an operating system that acts as a bridge between software and the physical hardware. It is the first program loaded into memory (RAM) when a system boots up. How it works: - When an app needs hardware (like the CPU or Disk), it sends a System Call. - The kernel receives this request and checks if the app has permission. - It then manages the hardware to perform the task and sends the result back to the app. Problem it solves: It prevents apps from crashing the whole system. Without a kernel, software would fight for hardware control, leading to chaos and security leaks. It ensures resources are shared fairly and safely. Simple Scenario: An app wants to print a document. It doesn't talk to the printer directly. It asks the kernel, which then communicates with the printer hardware to finish the job.

What is an Operating System? An Operating System (OS) is a system software that manages computer hardware and provides a platform for applications to run. It acts as the middle layer between the hardware and the user. Working: - It handles CPU scheduling, deciding which task gets processed and for how long. - It manages RAM by allocating specific memory blocks to active programs so they don't interfere with each other. - It translates software commands into machine-level signals that hardware can understand. Problem solved: It solves "Hardware Complexity." Without an OS, every app developer would have to write complex code to communicate directly with specific electronic circuits and disk drivers. Simple Scenario: When you save a file, the OS finds available physical blocks on the storage drive, writes the data, and updates a system table so the file can be retrieved later.