BSc CSIT Digital Logic (CSC116) Complete Guide: TU Syllabus, Boolean Algebra, K-Maps, Sequential Circuits & Exam Preparation

 

BSc CSIT Digital Logic (CSC116) Complete Guide: TU Syllabus, Boolean Algebra, K-Maps, Sequential Circuits & Exam Preparation

<!-- Featured image placeholder: images/featured-image-csc116.png -->

Introduction

Open up any computer science textbook and you'll eventually run into a sentence like "everything in a computer is just 1s and 0s." It's true, but it's also the kind of statement that explains nothing on its own. Digital Logic (CSC116) is the course where that sentence finally gets a real answer — where you learn how a handful of electrical switches, arranged the right way, can add numbers, store memory, and eventually run an entire operating system.

If you're a BSc CSIT student wondering why you need a hardware-flavored course this early in the program, here's the honest answer: almost nothing else in computer science makes sense without it. Microprocessor design, computer architecture, embedded systems, FPGA programming, and VLSI design all sit directly on top of what you learn here. Even fields that feel far removed from hardware, like AI and robotics, eventually touch this layer — a neural network accelerator chip or a robotics controller board is, underneath all the software, a digital logic circuit doing exactly what this course teaches you to design.

The course itself moves through a fairly natural arc: you start with how computers represent numbers, move into the algebra that governs logical decisions, learn to simplify those decisions efficiently, build basic circuits out of gates, scale those circuits up using off-the-shelf components, and finally add memory and timing into the picture so circuits can "remember" things over time. By the end, you can look at a digital clock, a calculator, or a basic counter and actually understand what's happening inside it.

This guide walks through the official CSC116 syllabus the way it's actually taught, with worked conversions, a solved K-map, and the comparisons that tend to show up as exam questions. Full unit-wise breakdowns with extra practice problems are linked at the bottom.

Official Course Information

Particular	Details
Course Title	Digital Logic
Course Code	CSC116
Semester	First Semester
Nature of Course	Theory + Lab
Full Marks	60 + 20 + 20
Pass Marks	24 + 8 + 8
Credit Hours	3

Course Description

CSC116 covers digital logic and switching networks: Boolean algebra and how it's applied to circuit analysis, multilevel gate networks, flip-flops and counters, logic devices, and both synchronous and asynchronous sequential logic, finishing with an introduction to digital integrated circuits.

Course Objective

The course is meant to give students the basic tools for designing digital circuits, along with the methods and procedures used across a range of real digital design problems — not just theory, but a practical design skill.

Official Unit-Wise Syllabus Overview

Unit 1: Binary Systems (6 Hrs)

This is where the course starts, and it's heavier than it looks at first glance. You'll cover binary numbers and base conversion, octal and hexadecimal systems, complements, signed binary representation, several decimal coding schemes (BCD, 2421, 8421, Excess-3, and Gray code), and a first look at how binary values get stored in registers.

The conversions are worth practicing by hand rather than memorizing as steps. Take 725 in decimal: dividing repeatedly by 2 and reading the remainders from bottom to top gives 1011010101 in binary — you can check it yourself by adding up the place values (512+128+64+16+4+1 = 725).

Complements matter because computers don't have a natural way to represent a minus sign — instead, negative numbers are represented using 1's or 2's complement. For an 8-bit number, 25 is 00011001; flipping every bit gives the 1's complement, 11100110; adding 1 to that gives the 2's complement, 11100111, which is how -25 would actually be stored.

The coding schemes are easy to mix up under exam pressure, so it helps to remember what each one is for. BCD just encodes each decimal digit separately in 4 bits (47 becomes 0100 0111). Excess-3 is BCD shifted by adding 3 to each digit before encoding — it's "self-complementing," meaning the 9's complement of a digit can be found just by inverting the bits, which made certain arithmetic circuits simpler to build in the days before this was all handled in software. Gray code is built so that only one bit changes between any two consecutive values — converting binary 1011 to Gray code gives 1110, using the rule that each Gray bit is the XOR of the current and previous binary bit. That single-bit-change property is exactly why Gray code shows up in rotary encoders and position sensors, where a multi-bit-change at the wrong moment could register a completely wrong position.

Unit 2: Boolean Algebra and Logic Gates (5 Hrs)

Boolean algebra is the math underneath every digital circuit, and this unit introduces it properly — the axiomatic definitions, the basic theorems and properties, and how Boolean functions and logic gates connect to each other.

A lot of students try to memorize the list of Boolean laws (commutative, associative, distributive, absorption, and so on) without connecting them to anything concrete, which is exactly why they're forgotten by exam day. DeMorgan's theorem is the one worth actually understanding rather than memorizing: (A+B)' equals A'B', and (AB)' equals A'+B'. You can convince yourself this is true just by building a truth table and checking that both sides match for every combination of A and B — that's effectively how the theorem gets "proven" at this level, and it's also exactly the technique used later to convert AND/OR circuits into all-NAND or all-NOR implementations.

The gates themselves — AND, OR, NOT, NAND, NOR, XOR, XNOR — each have a truth table and a standard circuit symbol, and two of them deserve special attention: NAND and NOR are both "universal gates," meaning either one alone can be used to build any other gate, and by extension any Boolean function whatsoever. That's not just a theoretical curiosity; it's why real chips are often built almost entirely out of one gate type, since manufacturing a single uniform component is cheaper than mixing several gate designs.

Unit 3: Simplification of Boolean Functions (5 Hrs)

Raw Boolean expressions derived from a truth table are often far longer than necessary, and this unit is about shrinking them down — mainly through Karnaugh maps (K-maps), covering two, three, and four-variable cases, along with product-of-sums simplification, NAND/NOR implementation, and handling "don't care" conditions.

K-maps feel abstract until you actually work through one. Take F(A,B,C) = Σm(0,2,4,5,6) — minterms 0, 2, 4, 5, and 6 are 1, the rest are 0. Laid out on a 3-variable map, the entire C=0 column turns out to be all 1s, which collapses to the single term C'. The remaining 1 at minterm 5 pairs up with its neighbor at minterm 4 to form the term AB'. Put together, F = C' + AB' — two terms instead of the five-minterm expression you started with. That's the entire point of the exercise: turning something that looks complicated into something a circuit can implement with far fewer gates.

Don't-care conditions are the other piece worth understanding conceptually: sometimes a particular input combination simply can't occur in practice (think of a circuit that only ever receives valid BCD digits, 0 through 9 — combinations 10 through 15 are "don't cares"), and you're free to treat those cells as either 0 or 1, whichever makes the grouping bigger and the final expression simpler.

Unit 4: Combinational Logic (5 Hrs)

This unit is where individual gates start turning into actual useful circuits — adders, subtractors, code converters — along with the general design procedure (going from a word problem to a truth table to a simplified circuit) and its reverse, the analysis procedure (going from an existing circuit back to its Boolean expression).

The half adder and full adder are the natural starting point. A half adder takes two bits and produces a sum (A XOR B) and a carry (AB) — but it can't handle a carry coming in from a previous addition, which is exactly the problem the full adder solves by accepting a carry-in bit and producing Sum = A⊕B⊕Cin and Carry-out = AB + BCin + ACin. Chain enough full adders together and you have a circuit that can add numbers far larger than a single bit, which is essentially the design pattern your CPU's arithmetic unit is built on.

This unit also covers multilevel NAND and NOR circuits — taking a standard AND/OR design and rebuilding it entirely out of one universal gate type — and Exclusive-OR circuits, which show up constantly in parity checking and simple comparators.

Unit 5: Combinational Logic with MSI and LSI (8 Hrs)

With 8 teaching hours, this is the heaviest unit in the course, and it's where you move from building gates one at a time to using pre-packaged, higher-level building blocks: binary parallel adders and subtractors, decimal (BCD) adders, magnitude comparators, decoders, encoders, multiplexers, and an introduction to ROM, PLA, and PAL.

A binary parallel adder is just full adders chained together to add multi-bit numbers in one shot — the kind of "ripple carry" adder that's conceptually simple but has a real timing cost, since each stage has to wait for the carry from the one before it. A decoder takes n input lines and activates exactly one of 2ⁿ output lines, while an encoder does the reverse — it's the same relationship as a light switch panel (decoder: pick one light) versus a priority button system (encoder: figure out which single button was pressed). A multiplexer selects one of several input signals to pass through based on a set of select lines, the digital equivalent of a multi-way switch.

ROM, PLA, and PAL are worth keeping straight because they're easy to confuse. A ROM implements any function using a fixed AND array (essentially a decoder) feeding into a programmable OR array — you can choose which outputs each minterm feeds into, but not the minterms themselves. A PLA goes further by making both the AND and OR arrays programmable, which is more flexible but more expensive to manufacture. A PAL sits in between: a programmable AND array but a fixed OR array, which made it cheaper and faster to program than a full PLA, at the cost of some flexibility.

Unit 6: Synchronous and Asynchronous Sequential Logic (10 Hrs)

At 10 hours, this is the single largest unit in the course, and for good reason — it's where circuits stop being purely combinational (output depends only on current input) and start having memory, meaning output depends on both current input and past state. This is the unit on flip-flops, how they're triggered, how to analyze a clocked sequential circuit, state reduction, and an introduction to asynchronous circuits built from latches.

The four flip-flop types — SR, JK, D, and T — get confused constantly, so it's worth being precise about each one. An SR flip-flop sets or resets based on its two inputs but has an undefined state when both inputs are 1 simultaneously, which is exactly the flaw the JK flip-flop was designed to fix: when both J and K are 1, instead of an undefined state, the output simply toggles. A D flip-flop is the simplest conceptually — whatever is on the D input gets copied to the output at the next clock edge, making it ideal for basic storage. A T flip-flop toggles its output whenever T is 1, which is exactly the behavior you want for building counters.

Triggering matters too: a latch is level-triggered, meaning it responds for as long as its enable signal is active, while a true flip-flop is edge-triggered, responding only at the precise moment the clock transitions from 0 to 1 (or 1 to 0). That distinction is why latches are the building block for asynchronous circuits, while flip-flops are what you use when you want a circuit to update in clean, predictable, clock-synchronized steps.

Unit 7: Registers and Counters (6 Hrs)

The final unit puts flip-flops to work in two of their most common practical forms: registers (including shift registers) and counters, along with timing sequences and a closing look at how memory fits into the picture.

A register is just a row of flip-flops storing multiple bits together, and a shift register adds the ability to move those bits left or right on each clock pulse — useful for tasks like serial-to-parallel data conversion. Counters split into two families that are worth telling apart clearly: ripple counters are asynchronous, with each flip-flop triggered by the output of the previous one, which is simple to build but accumulates a small timing delay at each stage; synchronous counters trigger every flip-flop from the same clock signal simultaneously, which is more complex to design but avoids that accumulated delay entirely, making it the better choice when timing accuracy matters.

Quick Comparison Tables

These are the comparisons most likely to show up as "differentiate between" questions on the actual exam.

NAND vs. NOR

Aspect	NAND	NOR
Output	0 only when all inputs are 1	1 only when all inputs are 0
Universal Gate	Yes	Yes
Common Use	Building blocks for most TTL/CMOS chips	Used similarly, especially in some latch designs

Combinational vs. Sequential Circuits

Aspect	Combinational	Sequential
Output depends on	Current inputs only	Current inputs and past state
Memory element	None	Flip-flops/latches
Example	Adder, decoder, multiplexer	Counter, register, flip-flop

Multiplexer vs. Demultiplexer

Aspect	Multiplexer (MUX)	Demultiplexer (DEMUX)
Function	Many inputs → one output	One input → many outputs
Selection	Select lines choose which input passes through	Select lines choose which output receives the input

Encoder vs. Decoder

Aspect	Encoder	Decoder
Function	2ⁿ inputs → n output lines	n inputs → 2ⁿ output lines
Typical Use	Identifying which single input line is active	Activating exactly one output line based on a binary code

SR vs. JK Flip-Flop

Aspect	SR Flip-Flop	JK Flip-Flop
Inputs	Set (S), Reset (R)	J, K
Both inputs = 1	Undefined/invalid state	Output toggles (no invalid state)

ROM vs. PLA vs. PAL

Aspect	ROM	PLA	PAL
AND array	Fixed	Programmable	Programmable
OR array	Programmable	Programmable	Fixed
Flexibility	Lowest	Highest	Moderate

RAM vs. ROM (general memory reference)

Aspect	RAM	ROM
Volatility	Volatile	Non-volatile
Read/Write	Both	Mostly read-only
Common Use	Temporary working storage	Permanent stored instructions/data

Formula and Reference Sheet

Topic	Reference
1's complement	Invert every bit
2's complement	Invert every bit, then add 1
Half adder	Sum = A ⊕ B, Carry = AB
Full adder	Sum = A ⊕ B ⊕ Cin, Carry-out = AB + BCin + ACin
DeMorgan's Theorem	(A+B)' = A'B', (AB)' = A' + B'
Decoder size	n inputs activate exactly one of 2ⁿ outputs
Gray code from binary	MSB unchanged; each next bit = XOR of current and previous binary bit
BCD	Each decimal digit encoded separately in 4 bits
Excess-3	BCD value + 3 (binary), self-complementing

How CSC116 Is Typically Tested

With marks split as 60 (theory) + 20 (lab) + 20 (internal), expect a mix of short conversion/definition questions, K-map and Boolean simplification problems, circuit design questions (build a circuit that does X), and longer descriptive questions on sequential logic. Since Unit 6 (Sequential Logic) carries the most teaching hours, followed by Unit 5 (MSI/LSI), these two units tend to be weighted the heaviest — which lines up with the lab requirement, where you're expected to actually build and test flip-flops, counters, and combinational circuits, not just describe them on paper.

Study Plan

30-Day Plan

• Days 1–6: Unit 1 (Binary Systems) — drill conversions and complements daily
• Days 7–11: Unit 2 (Boolean Algebra and Logic Gates)
• Days 12–16: Unit 3 (K-Maps) — work through at least one solved problem per day
• Days 17–21: Unit 4 (Combinational Logic)
• Days 22–27: Unit 5 (MSI/LSI) — the heaviest content unit
• Days 28–30: Units 6–7 overview, to be deepened in the next phase

15-Day Plan

• Days 1–2: Unit 1
• Days 3–4: Unit 2
• Days 5–6: Unit 3
• Days 7–8: Unit 4
• Days 9–11: Unit 5
• Days 12–14: Unit 6 (the largest unit — give it real time, not a squeeze)
• Day 15: Unit 7 plus comparison-table review

7-Day Plan

• Day 1: Unit 1
• Day 2: Units 2–3
• Day 3: Unit 4
• Day 4–5: Unit 5 and Unit 6 (don't compress these two — they're worth the most marks)
• Day 6: Unit 7
• Day 7: Formula sheet, comparison tables, and one full K-map + flip-flop practice round

Night-Before Exam Strategy

• Redo one number conversion, one K-map, and one full-adder derivation by hand — don't just reread them.
• Run through the comparison tables once, since "differentiate between" questions are quick marks if you keep the pairs straight.
• Skim flip-flop behavior one more time; SR vs JK is the single most common mix-up under time pressure.
• Skip anything genuinely new at this point — focus only on what you've already practiced.

Common Mistakes Students Make

Gray code conversion trips up more students than it should, mostly because they try to memorize the pattern instead of the XOR rule that generates it. NAND and NOR get mixed up constantly, especially when a question asks you to redesign a circuit using only one of them. K-map grouping mistakes are common too — students group cells that aren't actually adjacent, or stop at a smaller group when a larger one was available. SR and JK flip-flops get confused, particularly the case where both inputs are 1. And a surprising number of marks get lost simply by forgetting to carry the Cin term in a full-adder design, defaulting back to half-adder logic out of habit.

Tips to Score High Marks

Treat the K-map and number conversion sections as skills, not facts — the only way to get fast and accurate is repetition, the same way you'd practice scales on an instrument. Build a single formula and comparison-table sheet early in the semester and add to it as you go, rather than assembling it the week before the exam. When a question asks you to design a circuit, sketch the truth table first even if it feels slow — it's far easier to catch a mistake on paper than after you've already drawn half a circuit. And don't skip the lab work in favor of pure theory revision; questions about flip-flop triggering and counter behavior are noticeably easier to answer once you've actually built and watched one operate.

Frequently Asked Questions (FAQs)

Is Digital Logic a hard course for BSc CSIT first-semester students? The individual topics aren't conceptually difficult, but there's a lot of ground to cover, and several topics (K-maps, flip-flops, number conversions) genuinely require hands-on practice rather than passive reading, so students who skip the practice tend to find it harder than it needs to be.

Which is the most important chapter in Digital Logic? Unit 6 (Synchronous and Asynchronous Sequential Logic) and Unit 5 (Combinational Logic with MSI and LSI) carry the most teaching hours and tend to be weighted accordingly, but Unit 3 (K-Maps) is disproportionately important because it's a skill, not just content — and it shows up indirectly in almost every later unit.

How should I study Karnaugh maps effectively? Work through several different minterm lists by hand rather than just reading worked examples — the grouping intuition only develops through repetition, the same way mental math gets faster with practice rather than explanation.

Which derivations are most likely to appear on the exam? DeMorgan's theorem, full-adder Sum/Carry equations, and Gray code conversion rules are common, along with deriving a simplified Boolean expression from a given truth table using a K-map.

Can I pass Digital Logic without doing the lab work? You can pass the theory paper, but the lab marks are a meaningful part of your total grade, and skipping hands-on practice with real flip-flops and counters tends to make the sequential logic unit harder to understand on paper too.

What's the easiest way to remember the difference between NAND and NOR? NAND is "not AND" — it's 0 only in the one case where every input is 1. NOR is "not OR" — it's 1 only in the one case where every input is 0. Working from the original gate's truth table and just inverting it is more reliable than memorizing the inverted table directly.

Why do JK flip-flops exist if SR flip-flops already work? Because SR flip-flops have an undefined output when both inputs are 1 simultaneously, which is a real design problem — the JK flip-flop fixes exactly that case by making the output toggle instead, with no invalid state.

Is Gray code actually used anywhere, or is it just an exam topic? It's genuinely used in rotary encoders and position-sensing hardware, specifically because only one bit changes between consecutive values, which avoids the kind of multi-bit-change glitch that could happen with ordinary binary counting.

Do ROM, PLA, and PAL still matter if modern chips use different technology? The underlying idea — using programmable logic arrays to implement custom functions — is still the conceptual ancestor of modern programmable hardware like FPGAs, so understanding ROM/PLA/PAL gives you the foundation for that later technology, even if the specific components have evolved.

How is Digital Logic connected to courses I'll take later? Almost directly: Computer Organization and Architecture builds on the adder, register, and counter designs from this course, and Microprocessors/Embedded Systems assumes you already understand flip-flops, memory, and sequential logic at the level this course teaches.

Conclusion

Digital Logic can feel like a strange mix of math and electronics at first, but it's really just the layer where Boolean algebra becomes physical hardware. Get comfortable with number conversions, practice enough K-maps that the grouping becomes intuitive, and keep the flip-flop types straight, and the rest of the course — adders, registers, counters — tends to fall into place because it's all built from the same handful of ideas repeated at increasing scale.

For full chapter-wise notes, extra solved K-maps, and additional practice problems, see the detailed unit-wise guides:

• Unit 1: Binary Systems (coming soon)
• Unit 2: Boolean Algebra and Logic Gates (coming soon)
• Unit 3: Simplification of Boolean Functions (coming soon)
• Unit 4: Combinational Logic (coming soon)
• Unit 5: Combinational Logic with MSI and LSI (coming soon)
• Unit 6: Synchronous and Asynchronous Sequential Logic (coming soon)
• Unit 7: Registers and Counters (coming soon)

You may also find these related guides useful: BSc CSIT Mathematics-I (MTH117) Complete Guide, Introduction to Information Technology (CSC114) Complete Guide, and Physics (PHY118) Complete Guide.