Learn how to build a Finite State Machine (FSM) in Java that checks whether a decimal number is divisible by 3. Includes the theory behind the digit-sum rule, a 3-state FSM implementation, state-trace output, sample output, and a detailed explanation.
Learn how to build a Finite State Machine (FSM) in Java that checks whether a string ends with the suffix 'abb'. Includes a transition table, state-trace output, sample output, and a detailed step-by-step explanation.
Learn how to build a Finite State Machine (FSM) in Java that checks whether a string contains the substring 'abb'. Includes a transition table approach, commented code, sample output, and a step-by-step explanation.
Learn how to simulate a Turing Machine in Java to check whether a parenthesis string is well-formed. Includes a clean implementation, step-by-step code walkthrough, sample output, and a detailed explanation.
Learn how to implement a Pushdown Automaton (PDA) in Java to recognize strings with equal numbers of 'a' and 'b' characters. Includes a stack-based approach, commented code, sample output, and a detailed explanation.
Learn how to compute epsilon-closure in Java for an NFA. This post explains the concept, walks through the recursive algorithm with descriptive variable names, provides sample output, and includes a detailed explanation of the results.
Learn how a Finite State Machine (FSM) can implement a binary adder in Java. This post walks through the state transition logic, carry handling, commented code, sample output, and a detailed output explanation.
In this post, we implement a basic Multithreading example in Java. Multithreading allows multiple threads to execute concurrently within a single program, enabling tasks to run in parallel rather than one after another. Java has built-in support for multithreading through the Thread class and the Runnable interface. What is Multithreading? A thread is the smallest unit of execution within a process. When a program creates multiple threads, the operating system’s thread scheduler interleaves their execution — giving each thread a slice of CPU time in turn. This makes it appear as though they are running simultaneously (and on multi-core systems, they actually can be). In this example, we create two threads by extending the Thread class and overriding its run() method. Each thread prints a label 4 times, pausing 500 ms between prints. Both threads run concurrently, so their output interleaves. start() — Tells the JVM to create a new OS-level thread and invoke run() on it. Calling run() directly would execute it on the current thread, not a new one. Thread.sleep(ms) — Pauses the current thread for the given number of milliseconds, allowing other threads to execute. InterruptedException — Must be caught when calling sleep(). It fires if another thread interrupts this one while it is sleeping.
In this post, we implement the FIFO (First In, First Out) Page Replacement Algorithm in C++. When the OS needs to load a new page into memory but all frames are occupied, FIFO evicts the page that has been in memory the longest — the one that arrived first. It is one of the simplest page replacement strategies and serves as a baseline for comparing more sophisticated algorithms. What is FIFO Page Replacement? Physical memory is divided into frames. When a process references a page not currently in a frame (a page fault), it must be loaded. If all frames are full, an existing page must be evicted. FIFO chooses the oldest resident page for eviction, regardless of how frequently it has been used. Page Hit — Referenced page is already in a frame. No disk I/O needed. Page Fault (Miss) — Referenced page is not in any frame. Must load from disk. FIFO Queue — Tracks the order in which pages were loaded. Front = oldest; back = newest. A notable weakness of FIFO is Bélady’s Anomaly — adding more frames can sometimes cause more page faults, counter-intuitively.
In this post, we implement the Banker’s Algorithm in C++ — a classic deadlock avoidance mechanism in operating systems proposed by Edsger Dijkstra. The algorithm is named after the analogy of a bank that never lends money in a way that could prevent it from satisfying all customers’ future needs. What is the Banker’s Algorithm? Before granting any resource request, the OS runs the Banker’s Algorithm to check whether doing so keeps the system in a safe state. A safe state is one where a safe sequence exists — an ordering of all processes such that each can eventually complete using currently available resources plus the resources released by earlier processes in the sequence. If no safe sequence exists, the state is unsafe, meaning deadlock is possible. The OS denies the request in that case. Three data structures are needed: Available[] — Current free units of each resource type. Allocated[][] — Resources currently held by each process. Maximum[][] — The maximum resources each process may ever request. Need[][] — Remaining resources a process may still request: Need[i][j] = Maximum[i][j] - Allocated[i][j]