Computer Science Subjects

• Course orientation: learning plan, assignment workflow, setting up a Linux environment, a code editor, and Git and GitHub for submissions.
• Number systems: binary, octal and hexadecimal; conversions; signed numbers and two’s complement; an overview of IEEE 754 floating-point representation.
• Basic CPU organization: ALU, control unit, registers and buses; the stored-program (von Neumann) model.
• The instruction cycle (fetch, decode, execute), instruction formats and common addressing modes.
• Instruction pipelining: stages, throughput vs latency, structural, data and control hazards, and how stalls, forwarding and branch prediction address them.
• The memory hierarchy (registers, cache, main memory, secondary storage) and locality of reference.
• Cache memory: direct-mapped, fully associative and set-associative mapping; hit ratio and effective access time; write-through vs write-back.
• I/O fundamentals: polling, interrupts and direct memory access (DMA).
• From source code to a running program: compiling, linking and loading.

Outcome: Explain how an instruction flows through a pipelined CPU and solve standard number-representation, cache-mapping and effective-access-time problems.

• The role of an operating system; kernel mode vs user mode; system calls; monolithic and microkernel designs.
• The process concept: process control block (PCB), process states and transitions, context switching.
• Process creation and termination on Linux with fork(), exec() and wait(); zombie and orphan processes.
• Threads: user-level vs kernel-level threads, multithreading models, threads vs processes, POSIX threads basics.
• Inter-process communication: pipes, shared memory, message passing and signals.
• Scheduling criteria: CPU utilization, throughput, turnaround time, waiting time and response time.
• Scheduling algorithms: FCFS, SJF, SRTF, Priority (with aging), Round Robin, multilevel queue and multilevel feedback queue.
• Gantt-chart problem solving, and how modern Linux schedulers (the Completely Fair Scheduler and its successor, EEVDF) approach fairness.

Outcome: Trace a process through its lifecycle, write small multi-process and multi-threaded programs in C, and compute scheduling metrics by hand for any standard algorithm.

• Race conditions, critical sections and the requirements of a correct solution: mutual exclusion, progress and bounded waiting.
• Peterson’s solution and hardware support: test-and-set, compare-and-swap and atomic operations.
• Mutex locks, spinlocks, counting and binary semaphores, monitors and condition variables.
• Classic problems: bounded-buffer producer–consumer, readers–writers and dining philosophers.
• Thread-safe code in practice with pthread mutexes and condition variables, and an overview of Java’s synchronized blocks and concurrency utilities.
• Deadlock: the four necessary (Coffman) conditions and resource-allocation graphs.
• Deadlock prevention, avoidance with safe states and the Banker’s algorithm, detection and recovery.
• Starvation, livelock and priority inversion.

Outcome: Identify and fix race conditions, solve classic synchronization problems with semaphores and mutexes, and use the Banker’s algorithm to decide whether a system state is safe.

• Address binding, logical vs physical addresses and the MMU; contiguous allocation, internal and external fragmentation.
• Paging: page tables, the translation lookaside buffer (TLB), effective memory access time, multilevel and inverted page tables.
• Segmentation, and segmentation combined with paging.
• Virtual memory: demand paging, page-fault handling and copy-on-write.
• Page replacement: FIFO, Optimal, LRU and LRU approximations (Clock / second chance); Belady’s anomaly; thrashing and the working-set model.
• File systems: file concepts, directory structures, allocation methods (contiguous, linked, indexed), inodes and free-space management.
• Disk structure and scheduling: FCFS, SSTF, SCAN, C-SCAN, LOOK and C-LOOK; an overview of RAID levels.
• Operating Systems interview revision: frequently asked conceptual questions and common traps.

Outcome: Solve paging, TLB and page-replacement numericals with confidence, and explain how a file read travels from a system call down to the disk.

• Why a DBMS: limitations of file-based storage, data independence, the three-schema architecture and DBMS architecture.
• Entity–Relationship modeling: entities, attributes (simple, composite, multivalued, derived), relationships, cardinality and participation.
• Weak entities, generalization, specialization and aggregation.
• Converting ER diagrams into relational schemas.
• The relational model: relations, tuples, domains and integrity constraints.
• Keys: super, candidate, primary, alternate, foreign and composite keys; referential integrity.
• Relational algebra: selection, projection, joins, set operations and division; an introduction to tuple relational calculus.
• Hands-on: installing PostgreSQL or MySQL and creating schemas with DDL and constraints.

Outcome: Model a real-world domain as an ER diagram, convert it into a relational schema with correct keys and constraints, and express queries in relational algebra.

• Functional dependencies, Armstrong’s axioms, attribute closure, finding candidate keys and computing a minimal cover.
• Insertion, update and deletion anomalies, and why normalization matters.
• Normal forms 1NF, 2NF, 3NF and BCNF; lossless-join and dependency-preserving decomposition; an introduction to multivalued dependencies and 4NF.
• SQL language categories (DDL, DML, DCL, TCL) and constraints.
• Querying with SELECT, WHERE, ORDER BY, GROUP BY, HAVING and aggregate functions.
• Inner, left, right, full outer, self and cross joins; correlated and non-correlated subqueries; EXISTS and IN.
• Views, common table expressions (CTEs) and window functions such as ROW_NUMBER, RANK, DENSE_RANK, LAG and LEAD.
• Stored procedures and triggers, and when to avoid them.
• Interview SQL patterns: Nth-highest value, finding duplicates, top-N per group and running totals.

Outcome: Normalize a schema to BCNF with clear justification, and write correct, readable SQL for typical interview and real-world questions.

• Transactions, the ACID properties and transaction states.
• Schedules: serial and serializable schedules, conflict and view serializability, precedence graphs.
• Recoverable, cascadeless and strict schedules.
• Concurrency control: lock-based protocols, two-phase locking (basic and strict 2PL), timestamp ordering and an overview of MVCC.
• Isolation levels and the anomalies they prevent: dirty reads, non-repeatable reads and phantom reads.
• Recovery: logging, write-ahead logging and checkpoints.
• Indexing: primary, clustered and secondary indexes; dense vs sparse indexes; B-trees and B+ trees; hash indexes.
• Query processing basics and reading EXPLAIN plans.
• NoSQL overview: key–value, document, wide-column and graph stores, and how to choose between SQL and NoSQL.

Outcome: Test schedules for serializability, select appropriate isolation levels, design indexes that measurably speed up real queries, and justify SQL vs NoSQL choices.

• Network fundamentals: LAN, MAN and WAN; topologies; circuit vs packet switching; transmission, propagation and queuing delay; throughput.
• The OSI reference model vs the TCP/IP model: layer responsibilities and encapsulation.
• Physical layer basics: transmission media, bandwidth and an overview of signal encoding.
• Data link layer: framing, error detection (parity, checksum, CRC) and flow control (stop-and-wait, Go-Back-N, Selective Repeat).
• Media access and LANs: Ethernet, CSMA/CD, switches, MAC addresses, ARP and an overview of VLANs.
• Network layer: IPv4 addressing, classful vs classless (CIDR) addressing, subnetting and supernetting, private addresses and NAT; an IPv6 overview.
• Routing: distance-vector and link-state algorithms; RIP, OSPF and BGP at a conceptual level; ICMP, ping and traceroute.
• Labs: subnetting drills, building a small routed network in Cisco Packet Tracer, and live packet captures in Wireshark.

Outcome: Subnet any network quickly and accurately, explain encapsulation across the layers, and read real packet captures in Wireshark.

• Transport layer: ports and multiplexing; UDP vs TCP and when to use each.
• TCP in depth: the three-way handshake, connection teardown, sequence and acknowledgment numbers, sliding-window flow control and retransmission.
• Congestion control: slow start, congestion avoidance, fast retransmit and fast recovery.
• DNS: the naming hierarchy, recursive vs iterative resolution, record types and caching.
• HTTP and HTTPS: methods, status codes, headers, cookies and persistent connections; how HTTP/1.1, HTTP/2 and HTTP/3 differ.
• TLS basics: symmetric vs asymmetric encryption, certificates and the TLS handshake at a high level.
• Other application protocols: DHCP, SMTP and FTP overview; the classic “what happens when you type a URL” walkthrough.
• Socket programming: building a TCP client–server application.

Outcome: Explain TCP reliability and congestion control, walk through a web request end to end from DNS lookup to rendered response, and build a working socket-based application.

• The four pillars of OOP: encapsulation, abstraction, inheritance and polymorphism; composition vs inheritance; interfaces vs abstract classes.
• SOLID principles, DRY, KISS and YAGNI.
• UML class diagrams and sequence diagrams.
• Design patterns: creational (Singleton, Factory, Builder), structural (Adapter, Decorator, Facade) and behavioral (Strategy, Observer, Command, State).
• Low-level design practice: parking lot, library management and elevator systems.
• SDLC models: Waterfall, iterative and Agile (Scrum and Kanban); requirements and documentation basics.
• Software testing: unit, integration, system and acceptance testing; black-box vs white-box testing; writing good test cases.
• Version control in teams: Git branching, pull requests, code review and resolving merge conflicts.

Outcome: Produce clean object-oriented designs with UML, choose the right design pattern for a problem, and work in a team-style Git and Agile workflow.

• A structured approach to design interviews: functional and non-functional requirements, back-of-the-envelope estimation, APIs, data model, high-level design and deep dives.
• Scalability: vertical vs horizontal scaling, stateless services, latency vs throughput.
• Load balancing: Layer 4 vs Layer 7, balancing algorithms, reverse proxies and content delivery networks (CDNs).
• Caching: cache-aside, write-through and write-back strategies; LRU and LFU eviction; TTLs and cache invalidation.
• Databases at scale: replication, read replicas, partitioning and sharding strategies, and consistent hashing.
• The CAP theorem, PACELC and consistency models (strong vs eventual).
• Asynchronous processing: message queues and publish/subscribe (Kafka and RabbitMQ concepts), idempotency and retries.
• API design: REST principles, pagination, versioning, rate limiting and authentication basics.
• Case studies: a URL shortener, a chat/messaging system and a news feed.
• Capstone kickoff: choose your system, then draft its requirements, capacity estimates and API contracts for review.

Outcome: Design a scalable architecture for a common interview problem, defend every trade-off with clear reasoning, and start your capstone with an approved scope.

• Capstone project completion, demonstration and viva (see Projects).
• Integrated revision across OS, DBMS, CN, COA, OOP and System Design, with emphasis on how the subjects connect.
• Subject-wise interview question banks with model answers and common follow-up questions.
• Mock technical interviews with individual feedback: a rapid-fire core CS round, a live SQL round and a design round.
• Presenting your projects: structuring answers with the STAR method and writing strong résumé points for CS fundamentals.
• GATE-style conceptual and numerical practice across OS, DBMS, CN and COA.
• Career guidance: choosing target roles and planning your preparation beyond the course.
• Final review of your Certificate of Completion requirements.

Outcome: Present a complete capstone, answer core CS interview questions with clarity and depth, and leave with a personal revision plan.