JNTUK R23 B.Tech CSE III Year I Semester (3-1) Syllabus & Subject-wise Topics

by Rishi | Jul 10, 2026 | JNTUK R23 Syllabus

Course Structure

Total: L 15 – T 1 – P 10 – C 23

Professional Core Subjects

Data Warehousing & Data Mining

— the course that turns raw transactional data into the classification, clustering, and association models behind recommendation engines and BI dashboards.

• Unit 1: Data warehouse fundamentals — OLAP, data cube modeling, warehouse design and implementation, cloud data warehousing, plus core data/pattern mining concepts, data objects, statistical description, and visualization.
• Unit 2: Data preprocessing — cleaning noisy records, integrating multiple sources, reducing dimensionality, and transforming/discretizing raw attributes before modeling.
• Unit 3: Classification — decision tree induction, attribute selection measures and pruning, Bayesian and rule-based classifiers, and model evaluation/selection.
• Unit 4: Association rule mining — frequent itemset generation, confidence-based rule pruning, the Apriori algorithm, and the more scalable FP-Growth approach.
• Unit 5: Cluster analysis — K-means and its variants (bisecting K-means), agglomerative hierarchical clustering, and density-based DBSCAN, including their respective strengths and weaknesses.

Computer Networks

— the layered-architecture course (OSI/TCP-IP) that explains how data actually gets from one machine to another, and the base for every networking interview question.

• Unit 1: Network types and topologies, a comparison of the OSI and TCP/IP reference models, and the physical layer — guided media (twisted pair, coaxial, fiber) versus unguided transmission.
• Unit 2: Data link layer — framing techniques, error detection/correction (CRC, checksums), elementary protocols for noisy and noiseless channels, sliding-window schemes (Go-Back-N, Selective Repeat), HDLC, and PPP.
• Unit 3: Media access control — random access (ALOHA, CSMA/CD, CSMA/CA), controlled access and channelization (FDMA/TDMA/CDMA), and Ethernet standards from classic to 10-Gigabit.
• Unit 4: Network layer — packet-switching design issues, routing algorithms (shortest path, flooding, distance vector, link state), congestion control, and internetworking including IPv4/IPv6 addressing, CIDR, and fragmentation.
• Unit 5: Transport and application layers — UDP and TCP mechanics (flow, error, and congestion control), plus HTTP, email, Telnet, and DNS as the services riding on top.

Formal Languages and Automata Theory

— the theoretical-CS course explaining why some problems are computable and others aren’t, and the mathematical backbone behind every compiler and regex engine.

• Unit 1: Finite automata — DFA/NFA design, epsilon-transitions, DFA-NFA equivalence and conversion, minimization, and Mealy/Moore machines.
• Unit 2: Regular expressions and regular sets — identity rules, the pumping lemma, closure properties, and the Chomsky grammar hierarchy linking regular grammars to finite automata.
• Unit 3: Context-free grammars — leftmost/rightmost derivations, parse trees, ambiguity, grammar simplification, and normal forms (Chomsky and Greibach).
• Unit 4: Pushdown automata — design, deterministic versus non-deterministic variants, and their equivalence to context-free grammars.
• Unit 5: Turing machines — models and design, decidability versus undecidability, the halting problem, Post’s Correspondence Problem, and the P/NP/NP-hard/NP-complete complexity classes.

Professional Elective-I (choose one)

Object Oriented Analysis and Design

— a UML-first modeling course for students who want to design real systems on a whiteboard before writing a line of code.

• Unit 1: The nature of complex software systems — why large systems get complicated, their key attributes, and structured approaches to managing that complexity.
• Unit 2: UML foundations — modeling principles, the UML conceptual architecture, and basic structural modeling using classes, relationships, and standard diagrams.
• Unit 3: Class and object diagrams in depth — advanced structural modeling covering interfaces, types, roles, and packages.
• Unit 4: Behavioral modeling — use cases, use-case diagrams, interaction diagrams, and activity diagrams for capturing system behavior.
• Unit 5: Advanced behavioral and architectural modeling — events, state machines, state-chart diagrams, and component/deployment diagrams for runtime architecture.

Artificial Intelligence

— the foundational AI course walking from search algorithms to knowledge representation to the reasoning logic behind expert systems, underpinning every later ML/AI elective.

• Unit 1: Intelligent agents — problem formulation, the concept of rationality, and how agents perceive and act across different environment types.
• Unit 2: Search strategies — uninformed search (BFS, DFS), heuristic search (Hill Climbing, A, AO), and adversarial game-playing search including minimax and alpha-beta pruning.
• Unit 3: Knowledge representation — predicate logic, semantic networks, frames, rule-based deduction, and reasoning under uncertainty via probability and Dempster-Shafer theory.
• Unit 4: Logic and learning — first-order logic inference, unification, forward/backward chaining, resolution, and learning approaches from decision trees to reinforcement learning.
• Unit 5: Expert systems — architecture, knowledge acquisition, and classic case studies such as MYCIN, DART, and XCON.

Microprocessors & Microcontrollers

— the hardware-facing elective that drops students to register level with 8086 assembly and 8051 interfacing, ahead of any embedded-systems work.

• Unit 1: 8086 architecture — internal structure, bus interface and execution units, interrupt handling, and minimum/maximum mode configurations.
• Unit 2: 8086 assembly programming — instruction set, addressing modes, assembler directives, and program development tools.
• Unit 3: 8086 interfacing — memory interfacing, the 8255 peripheral interface, switches/LEDs/seven-segment displays, USART, DMA, and A/D-D/A conversion.
• Unit 4: 8051 microcontroller architecture — special function registers, I/O ports, instruction set, and addressing modes.
• Unit 5: 8051 interfacing — timers, serial communication, interrupts, LCD/keyboard interfacing, ADC/DAC/sensor interfacing, and a comparison against PIC and ARM processors.

Quantum Computing

— an emerging elective introducing the qubit-based computing model, giving students their first formal exposure to Grover’s and Shor’s algorithms.

• Unit 1: Foundations — the history of quantum computing and the conceptual shift from classical bits to qubits and quantum logic operations.
• Unit 2: Background mathematics and physics — linear algebra, Hilbert spaces, superposition, entanglement, and a brief look at genomics/proteomics.
• Unit 3: Qubits and circuits — physical realizations of qubits, the Bloch sphere, single- and multi-qubit gates, and Bell states.
• Unit 4: Quantum algorithms — Deutsch’s and Deutsch-Jozsa algorithms, Shor’s factorization algorithm, and Grover’s search algorithm, compared against classical complexity.
• Unit 5: Error correction and applications — noise and fault-tolerant computation, quantum cryptography, and quantum teleportation.

Open Elective-I

Open Elective-I / Entrepreneurship Development & Venture Creation

— a floating slot where CSE students either take a cross-department open elective (offered outside the CSE syllabus) or, as an alternative, a course on startup fundamentals and venture creation. Because it’s administered outside the CSE-specific syllabus document, there is no CSE unit-wise breakdown to report here.

Labs

Data Mining Lab

— the hands-on counterpart to Data Warehousing & Data Mining, built almost entirely around WEKA and Python.

• Building data warehouses/marts and running OLAP operations (slice, dice, roll-up, drill-down) using tools such as Pentaho or Microsoft SSIS.
• Using WEKA for preprocessing, association rule mining (Apriori, FP-Growth), classification (ID3, J48, Naive Bayes, k-NN), and clustering (k-means, hierarchical, DBSCAN).
• Writing original Python/Java/R programs for chi-square computation, Naive Bayes classification, k-means clustering, dissimilarity matrices, and data visualization with Matplotlib.

Computer Networks Lab

— the protocol-simulation lab that pairs with Computer Networks theory, running from manual framing exercises to live packet capture.

• Implementing data link layer framing (bit/character stuffing), error detection (checksum, Hamming code, CRC), and sliding-window protocols (Go-Back-N, Selective Repeat, Stop-and-Wait).
• Coding routing algorithms — Dijkstra’s shortest path and Distance Vector routing — plus congestion control via the leaky bucket algorithm.
• Hands-on network analysis using Wireshark for packet capture, Nmap for OS detection/scanning, and NS2 simulations for packet loss, TCP/UDP behavior, and throughput comparison.

Full Stack Development-2

— the MERN-stack sequel lab, moving from Express JS backends into React JS front ends and MongoDB persistence.

• Building Express JS applications with routing, middleware, templating, sessions, cookie-based authentication, and RESTful APIs.
• Building React JS interfaces — JSX, function/class components, props/state, conditional rendering, forms, React Router, and hooks.
• Wiring up MongoDB with Mongoose for CRUD operations, collections, indexing, and aggregation, culminating in a to-do list or quiz-app project.

User Interface Design using Flutter

— a mobile UI elective introducing Flutter/Dart for students who want to build cross-platform apps without leaving the CSE syllabus.

• Installing the Flutter/Dart SDK and exploring core widgets (Text, Image, Container) and layout structures (Row, Column, Stack).
• Building responsive, multi-screen UIs with navigation/routing, state management (setState, Provider), and custom themed widgets.
• Implementing animations, form validation, REST API data fetching, and basic unit testing/debugging of Flutter apps.

Community Service Internship

Evaluation of Community Service Internship

— not a taught course but a credit-bearing evaluation of a community service internship completed by the student, carrying 2 credits with no lecture, tutorial, or practical hours and no unit-wise syllabus in the CSE course document.

JNTUK R23 B.Tech CSE II Year I Semester (2-1) Syllabus & Subject-wise Topics

by Rishi | Jul 10, 2026 | JNTUK R23 Syllabus

Students admitted from 2023 onward follow the R23 regulation. Second year kicks off with a mix of core CS theory, math, and the first skill-enhancement electives. Here’s the full course structure for 2-1, followed by unit-wise topic breakdowns for each subject.

Course Structure — II Year I Semester

Subjects

Discrete Mathematics & Graph Theory

— builds the logical/mathematical foundation CSE students lean on for algorithms and theory courses later.

• Unit 1: Propositional & predicate logic, truth tables, inference rules
• Unit 2: Set theory, relations, functions, lattices
• Unit 3: Combinatorics — permutations, combinations, recurrence relations & generating functions
• Unit 4: Graph fundamentals — representations, isomorphism, paths, Eulerian/Hamiltonian graphs
• Unit 5: Multigraphs, planar graphs, coloring, spanning trees (Prim’s/Kruskal’s), BFS/DFS trees

Universal Human Values

— a mandatory values-and-ethics course common across all JNTUK branches, built around self-exploration rather than exams in the usual sense.

• Unit 1: Introduction to value education — natural acceptance, happiness and prosperity as human aspirations
• Unit 2: Harmony within the self — understanding the self as distinct from (and connected to) the body
• Unit 3: Harmony in the family and society — trust and respect as foundational relationship values
• Unit 4: Harmony in nature and existence — interconnectedness across the orders of nature
• Unit 5: Implications for professional ethics — applying the holistic understanding to a working career

Digital Logic & Computer Organization

— how a computer actually works underneath the code.

• Unit 1: Number systems, binary codes, logic gates, K-map simplification
• Unit 2: Computer architecture basics, Von Neumann model, bus structures
• Unit 3: Computer arithmetic (fast adders, multiplication, division), processor organization
• Unit 4: Memory hierarchy — RAM, ROM, cache, virtual memory
• Unit 5: I/O organization — interrupts, DMA, standard interfaces

Advanced Data Structures & Algorithm Analysis

— the algorithms course most placement interviews draw from directly.

• Unit 1: Complexity analysis, AVL trees, B-trees
• Unit 2: Heaps, graph traversal, divide-and-conquer (quicksort, mergesort, Strassen’s)
• Unit 3: Greedy & dynamic programming — MST, shortest paths, knapsack, TSP
• Unit 4: Backtracking & branch-and-bound — 8-queens, subset sum, graph coloring
• Unit 5: NP-hard/NP-complete theory, Cook’s theorem

Object Oriented Programming through Java

• Unit 1: Java fundamentals, control statements
• Unit 2: Classes, objects, constructors, methods
• Unit 3: Arrays, inheritance, interfaces
• Unit 4–5: Exception handling, string handling, multithreading, JDBC, JavaFX GUI

Advanced Data Structures & Algorithm Analysis Lab

— the hands-on counterpart to ADSA, where AVL trees, greedy strategies, and backtracking move from the whiteboard into working, debuggable code.

• Building and operating on AVL trees, B-trees, and min/max heaps, plus BFS/DFS traversals and biconnected-component detection on graphs
• Benchmarking sorting algorithms (quick sort, merge sort) and implementing minimum-cost spanning trees and single-source shortest-path methods
• Backtracking and branch-and-bound solutions for the 0/1 knapsack problem, N-Queens, job sequencing, and the travelling salesperson problem

Object Oriented Programming Through Java Lab

— turns the Java theory course into muscle memory, with every OOP concept implemented, run, and broken on purpose so students learn to fix it.

• Classes, constructors, inheritance, and runtime polymorphism through a sequence of increasingly layered programs
• Exception handling (built-in and user-defined), multithreading with the Producer-Consumer problem, and custom packages
• File and stream I/O, JavaFX GUI components, and JDBC connectivity for inserting and deleting database records

Python Programming

— the skill-enhancement course that gets most CSE students writing real Python for the first time, ending with a first taste of data-science tooling.

• Unit 1: Python basics — identifiers, data types, operators, indentation, and control flow (if/else, loops, exception handling)
• Unit 2: Functions (arguments, args/*kwargs), string operations, and list creation/indexing/slicing
• Unit 3: Dictionaries, tuples, and sets — creation, built-in methods, and how the three interrelate
• Unit 4: File handling (text, binary, CSV, pickle) and object-oriented Python — classes, constructors, encapsulation, inheritance, polymorphism
• Unit 5: Intro to data science — functional programming, JSON/XML handling, NumPy arrays, and Pandas dataframes

Environmental Science

— a mandatory, ungraded audit course (no credits, but attendance-linked) covering the environmental literacy every engineer is expected to carry into practice.

• Unit 1: Natural resources and overexploitation — forests, water, minerals, food, and energy resources
• Unit 2: Ecosystem structure and function, food chains/webs, and biodiversity conservation
• Unit 3: Pollution — causes, effects, and control across air, water, soil, marine, noise, thermal, and nuclear sources; solid waste and disaster management
• Unit 4: Sustainable development, environmental ethics, climate change, and India’s environmental legislation
• Unit 5: Population growth, human health, welfare programmes, and field-based environmental study

JNTUK R23 B.Tech CSE IV Year II Semester (4-2) Syllabus & Subject-wise Topics

by Rishi | Jul 10, 2026 | JNTUK R23 Syllabus

The final semester of the JNTUK R23 CSE curriculum drops the usual mix of theory subjects and electives entirely. Instead of a multi-subject timetable, the whole semester is handed over to a single, high-credit component: a full-time internship and major project. It’s the university’s way of closing out four years of coursework with one sustained, real-world (or research-grade) deliverable rather than another set of exams.

IV Year II Semester Course Structure

Semester Total: 12 Credits

Mandatory MOOC/NPTEL note (R23 Regulations, 11th criteria):

Every CSE student must clear at least one MOOC/NPTEL course worth 3 credits at some point across the program (counted within the overall 160-credit degree total) — this is separate from the internship/project credits above. Students are allowed to register for this MOOC/NPTEL requirement as early as one semester in advance, so many complete it during IV-I rather than waiting until the final semester.

Full Semester Internship & Project Work

Full Semester Internship & Project Work

— the capstone of the CSE degree, replacing every regular subject with one continuous, credit-heavy internship or major project that runs for the entire semester.

With 0 lecture hours and 0 tutorial hours against 24 practical hours a week, this is structured as full-time, hands-on work rather than a subject taught alongside other classes — effectively treating the student’s work week like an industry placement. Students typically either intern with a company (or research lab) on live problems, or execute a self-directed major project under a faculty guide, drawing on the programming, systems, and specialization knowledge built up across the previous seven semesters. Because it’s assessed as applied work rather than through unit-wise exams, JNTUK evaluates it against dedicated project/internship rubrics — covering things like periodic progress reviews, the final report, and a viva-voce defense — administered by the college rather than delivered as a classroom syllabus.

No other theory subjects, professional electives, or open electives appear in this semester’s structure — IV Year II Semester is exclusively the internship/project component described above.

JNTUK R23 B.Tech CSE II Year II Semester (2-2) Syllabus & Subject-wise Topics

by Rishi | Jul 10, 2026 | JNTUK R23 Syllabus

II Year II Semester — course structure

A mandatory 8-week Community Service Project internship also runs during the summer vacation between II-II and III-I.

II Year II Semester — subjects

Managerial Economics and Financial Analysis

— the business-and-money course every engineer needs before making cost-benefit calls on real projects.

• Unit 1: Managerial economics fundamentals — demand concepts, elasticity, and demand forecasting methods
• Unit 2: Production and cost analysis — production functions, returns to scale, and break-even analysis
• Unit 3: Business organization forms and market structures, from perfect competition to oligopoly, plus pricing strategy
• Unit 4: Capital budgeting — working capital estimation and investment evaluation via payback period, ARR, NPV, and IRR
• Unit 5: Financial accounting — double-entry bookkeeping, final accounts, and ratio-based financial analysis

Probability & Statistics

— the statistical foundation that resurfaces later in ML model evaluation, A/B testing, and research methodology.

• Unit 1: Descriptive statistics for data science — data types, visualization, central tendency, variability, skewness, and kurtosis
• Unit 2: Correlation (including rank correlation) and linear/curvilinear regression
• Unit 3: Probability theory — conditional probability, Bayes’ theorem, random variables, and standard distributions (binomial, Poisson, uniform, normal)
• Unit 4: Sampling theory — point/interval estimation, the central limit theorem, and t- and F-distributions
• Unit 5: Hypothesis testing — Type I/II errors, significance levels, and tests for large and small samples

Operating Systems

— the systems course that explains what’s actually happening under a running program, from process scheduling to file storage.

• Unit 1: OS overview and system structures — services, system calls, and OS design/implementation
• Unit 2: Process concepts, inter-process communication, multithreading models, and CPU scheduling algorithms
• Unit 3: Synchronization tools (critical sections, mutex locks, semaphores, monitors) and deadlock prevention/avoidance/detection
• Unit 4: Memory management — contiguous allocation, paging, virtual memory, demand paging, and storage management
• Unit 5: File systems — access methods, directory structures, allocation methods, and protection mechanisms

Database Management Systems

— arguably the most job-relevant theory course of the semester, covering everything from ER modeling to transaction internals.

• Unit 1: Database fundamentals, schema architecture, and Entity-Relationship modeling
• Unit 2: The relational model and basic SQL — schema definition and core DML operations
• Unit 3: Advanced SQL — nested queries, joins, aggregation, grouping, and views
• Unit 4: Normalization — functional dependencies and normal forms from 1NF through 5NF (including BCNF)
• Unit 5: Transaction management, concurrency control, recovery, and indexing (B+ trees, hash-based indexing)

Software Engineering

— reframes coding as a managed process, covering planning, design, testing, and maintenance at scale rather than just writing code.

• Unit 1: Software life cycle models — waterfall, RAD, spiral, and agile
• Unit 2: Project management — size/effort estimation, COCOMO, risk management, and requirements specification (SRS)
• Unit 3: Software design — modularity, cohesion/coupling, agile practices (XP), and user interface design
• Unit 4: Coding and testing — black-box/white-box testing, debugging, and quality standards (ISO 9000, CMM)
• Unit 5: CASE tools, software maintenance strategies, and software reuse

Operating Systems Lab

— puts OS theory into a terminal, turning scheduling and memory-management algorithms into runnable simulations.

• UNIX commands and system calls (fork, exec, wait) alongside shell-command simulations
• CPU scheduling algorithm simulations (FCFS, SJF, priority, round robin) and semaphore/monitor-based process synchronization
• Page replacement and file allocation strategy simulations, plus the Banker’s algorithm for deadlock avoidance

Database Management Systems Lab

— where SQL and PL/SQL move from lecture slides to a working, queryable schema.

• DDL/DML operations, constraint enforcement, and nested/aggregate SQL queries with views
• PL/SQL programming — control structures, procedures, functions, cursors, and triggers
• JDBC-based database connectivity for inserting, updating, and deleting records from Java

Full Stack Development – I

— the first half of the stack: static, styled, and scripted web pages before any backend framework enters the picture.

• HTML structuring — lists, links, images, tables, forms, and frames
• CSS styling — selector types, the box model, and layout with colors, backgrounds, and fonts
• JavaScript fundamentals — conditionals, loops, functions, events, and a first look at Node.js

Design Thinking & Innovation

— a BS&H elective that treats invention as a teachable process rather than a flash of inspiration.

• Unit 1: Design fundamentals — elements, principles, and the history of design thinking
• Unit 2: The design thinking process — empathize, analyze, ideate, and prototype, applied to social innovation
• Unit 3: Innovation — distinguishing creativity from innovation and building innovation-focused teams
• Unit 4: Product design — problem formulation, product strategy, and specification writing
• Unit 5: Design thinking in business — applying the framework to startups and corporate strategic innovation

JNTUK R23 B.Tech CSE III Year II Semester (3-2) Syllabus & Subject-wise Topics

by Rishi | Jul 10, 2026 | JNTUK R23 Syllabus

Course Structure

Total: 20-1-08, 23 credits.

Students also complete a mandatory 8-week industry internship or mini-project during the summer vacation between III and IV year — it doesn’t carry a semester credit here but is a non-negotiable graduation requirement.

Note on electives: Professional Elective II and III are each a single 3-credit slot where a student picks one subject from the listed options (or an approved 12-week NPTEL/SWAYAM MOOC). Below, every option is covered individually since different colleges offer different choices. Open Elective II is drawn from a rotating cross-department pool defined outside the CSE syllabus book, so its actual content depends on which department’s elective a student selects that semester.

Professional Core Subjects

Compiler Design

— the course that explains what actually happens between writing code and a running program, and a frequent source of systems-interview questions.

• Unit 1: Lexical analysis fundamentals — how source code is tokenized, the finite-automata and regular-expression theory behind scanner generators like LEX, plus an introduction to context-free grammars and parse trees.
• Unit 2: Parsing techniques — top-down methods including recursive-descent and LL(1) parsing, and bottom-up methods covering shift-reduce, SLR, CLR, and LALR parsing-table construction.
• Unit 3: Syntax-directed translation — attaching semantic rules to grammar productions and generating intermediate representations such as three-address code, syntax trees, and backpatched jumps.
• Unit 4: Code optimization — basic-block analysis, flow graphs, data-flow analysis, and loop and peephole optimizations that make generated code more efficient.
• Unit 5: Runtime environments and code generation — activation records, procedure-call mechanics, and the design choices behind object-code generation and register allocation.

Cloud Computing

— a core paper for students aiming at infrastructure, platform, or DevOps-adjacent roles, covering how modern applications get deployed and scaled without owning physical servers.

• Unit 1: Cloud fundamentals — service models (IaaS/PaaS/SaaS), deployment models, and an overview of major providers such as AWS, Azure, and Google App Engine.
• Unit 2: Enabling technologies — parallel and distributed computing foundations, remote procedure calls, service-oriented architecture, and the virtualization concepts that make cloud computing work.
• Unit 3: Virtualization and containers — hypervisor-based virtualization versus containerization, Docker fundamentals, and orchestration with Kubernetes and Docker Swarm.
• Unit 4: Cloud challenges — interoperability, scalability, fault tolerance, energy efficiency, and the shared-responsibility security model across deployment types.
• Unit 5: Advanced cloud paradigms — serverless/Function-as-a-Service computing, cloud-centric IoT, edge and fog computing, and how DevOps and infrastructure-as-code fit into the cloud stack.

Cryptography & Network Security

(Common to CSE, CS & IT) — the paper that explains how the internet keeps secrets, from block ciphers to the protocols securing an ordinary browser session.

• Unit 1: Security foundations — attack classifications, security services, and the modular-arithmetic and matrix math that cryptographic algorithms depend on.
• Unit 2: Symmetric-key cryptography — algebraic structures behind block ciphers, and the design and security analysis of DES and AES.
• Unit 3: Asymmetric-key cryptography — primality testing and factorization, and public-key systems including RSA, Rabin, ElGamal, and elliptic-curve cryptography.
• Unit 4: Data integrity and key management — hash functions, message authentication, digital signature schemes, and symmetric key distribution via Kerberos.
• Unit 5: Network security protocols — PGP and S/MIME at the application layer, SSL/TLS at the transport layer, IPSec at the network layer, and an introduction to firewalls, intrusion detection, and malware.

Professional Elective II (choose one)

Software Testing Methodologies

(Common to CSE, CS, IT, CSD, CSE-AI, CSE-AI&ML, CSE-AI&DS) — the theory backbone behind QA engineering and test-automation careers.

• Unit 1: Testing fundamentals — why bugs occur, testing models, and path testing built around flow graphs and path predicates.
• Unit 2: Transaction-flow and data-flow testing — techniques centered on how data and control move through a program, along with domain testing.
• Unit 3: Path expressions and logic-based testing — regular expressions for flow-anomaly detection, decision tables, and KV charts.
• Unit 4: State-based testing — modeling software as state graphs and designing test cases around state transitions.
• Unit 5: Graph matrices — matrix representations of program graphs used to drive systematic test design, with hands-on exposure to a tool such as JMeter, Selenium, SoapUI, or Katalon.

Cyber Security

— a practical, law-and-forensics-facing companion to the cryptography paper, aimed at students headed toward security operations or digital forensics.

• Unit 1: Cybercrime landscape — definitions, attacker categories, mobile and wireless attack surfaces, and botnets.
• Unit 2: Attack tools and techniques — phishing, keyloggers, malware, sniffing and spoofing, session hijacking, DoS/DDoS, SQL injection, and social engineering.
• Unit 3: Cybercrime investigation — evidence collection and preservation, email tracing, and password-recovery case studies.
• Unit 4: Computer forensics — evaluating forensic tools, OS-specific forensics on Windows and Linux, and biometric/multimedia forensic analysis.
• Unit 5: Legal perspectives — the Indian IT Act, comparative global cyber law, and digital-signature regulation.

DevOps

(Common to CSE, CS, IT, AI&ML, CSE-AI, CSE-AI&ML) — the toolchain course behind modern CI/CD pipelines and release engineering.

• Unit 1: DevOps foundations — SDLC and Agile background, the DevOps lifecycle, and release practices like Scrum and Kanban.
• Unit 2: Source control and code quality — Git workflows and branching, plus unit testing and code-coverage analysis with SonarQube.
• Unit 3: Continuous integration — Jenkins architecture, pipelines, and master-slave build automation.
• Unit 4: Continuous delivery and containerization — CD workflow concepts, Docker fundamentals, and browser-test automation with Selenium.
• Unit 5: Configuration management and orchestration — Ansible playbooks and roles, plus container orchestration with Kubernetes and OpenShift.

Machine Learning

— the theory course underneath most ML-adjacent CSE career paths, building the statistical intuition that libraries like scikit-learn abstract away.

• Unit 1: ML foundations — learning paradigms, data representation, feature engineering, and the general model-building pipeline.
• Unit 2: Nearest-neighbor models — distance and similarity measures, KNN classification and regression, and classifier performance evaluation.
• Unit 3: Decision trees and Bayesian methods — impurity measures, random forests, and the Naive Bayes classifier.
• Unit 4: Linear discriminants — perceptrons, support vector machines, kernel methods, logistic and linear regression, and multi-layer perceptrons with backpropagation.
• Unit 5: Clustering — partitional and hierarchical clustering, K-means, fuzzy C-means, and spectral clustering.

(A 12-week NPTEL/SWAYAM MOOC recommended by the Board of Studies may substitute for a classroom subject in this slot.)

Professional Elective III (choose one)

Software Project Management

— for students who want the delivery-management side of software engineering, not just the code.

• Unit 1: Conventional versus modern management — the waterfall model, software economics, and the shift toward iterative development.
• Unit 2: Project life cycle — inception, elaboration, construction, and transition phases, and the artifacts produced at each stage.
• Unit 3: Process planning — architecture-centric planning perspectives, workflow checkpoints, work-breakdown structures, and cost/schedule estimation.
• Unit 4: Organization and automation — team structures, role responsibilities, and tooling that automates project tracking and metrics.
• Unit 5: Agile and DevOps adoption — Scrum practices, DevOps delivery pipelines, and organizational rollout of DevOps tooling.

Mobile Adhoc Networks

(Common to CSE, CS, IT, CSE-AI, CSE-AI&ML, CSD) — pairs wireless-network theory with sensor-network design.

• Unit 1: Ad hoc network basics — MANET characteristics, applications, design challenges, and MAC-layer protocol design.
• Unit 2: Routing and transport — routing-protocol classification and TCP adaptations for ad hoc wireless environments.
• Unit 3: Security protocols — MANET-specific attacks, key management, secure routing, and intrusion detection.
• Unit 4: Wireless sensor fundamentals — sensor hardware constraints, energy consumption, clustering, and the WSN protocol stack.
• Unit 5: WSN security and tooling — key management and secure data aggregation in sensor networks, sensor operating systems like TinyOS, and simulators such as NS-2 and TOSSIM.

Natural Language Processing

— the linguistics-meets-algorithms course behind search, chatbots, and text analytics.

• Unit 1: NLP foundations — language modeling, regular expressions, finite-state automata, tokenization, and spelling correction.
• Unit 2: Word-level analysis — N-gram models, smoothing techniques, part-of-speech tagging, and hidden Markov/maximum-entropy models.
• Unit 3: Syntactic analysis — context-free grammars, treebanks, dependency grammar, and probabilistic parsing.
• Unit 4: Semantics and pragmatics — first-order logic representations, word-sense disambiguation, and thematic roles.
• Unit 5: Discourse analysis — coreference and anaphora resolution, plus standard lexical resources like WordNet and the Penn Treebank.

Big Data Analytics

— explains why scaling up a single server stops working, and what Hadoop/Spark-era tooling does instead.

• Unit 1: Big data landscape — industry use cases, the Hadoop ecosystem, and open-source, cloud-scale analytics technologies.
• Unit 2: NoSQL data models — key-value, document, and graph databases, sharding, replication, and consistency trade-offs, with a look at Cassandra.
• Unit 3: Hadoop internals — HDFS architecture, MapReduce data flow, and HiveQL for data definition and querying.
• Unit 4: Apache Spark — RDDs, DataFrames, the Catalyst optimizer, and cluster deployment on YARN or standalone mode.
• Unit 5: Stream processing — event-time processing, windowing, watermarking, and structured-streaming fundamentals.

Distributed Operating System

— a systems-level elective for students who want to understand what runs underneath distributed applications.

• Unit 1: Distributed system fundamentals — system models, distributed-OS design issues, and message-passing mechanisms.
• Unit 2: Remote procedure calls — RPC transparency, stub generation, argument marshaling, and client-server binding.
• Unit 3: Distributed shared memory — consistency models, synchronization, clock ordering, and deadlock/election algorithms.
• Unit 4: Resource and process management — global scheduling, load balancing and sharing, and process migration.
• Unit 5: Distributed file systems — file-sharing semantics, caching schemes, replication, and fault tolerance.

(A 12-week NPTEL/SWAYAM MOOC recommended by the Board of Studies may substitute for a classroom subject in this slot.)

Open Elective

Open Elective – II

— a cross-department elective. CSE students pick this from the pool of subjects offered by other engineering branches that semester (the specific subject and its syllabus therefore aren’t fixed within the CSE curriculum document and vary by college/department offering).

Labs

Cloud Computing Lab

— the hands-on companion to the Cloud Computing theory paper.

• Covers setting up virtual machines with VirtualBox/VMware, launching and configuring Amazon EC2 or OpenStack instances, deploying apps on Google App Engine, and running a containerized web server with Docker.
• Also includes serverless function experiments using OpenFaaS, a single-node Hadoop cluster setup with a word-count job, and cloud simulation/scheduling exercises using CloudSim.

Cryptography & Network Security Lab

— the applied counterpart to the cryptography theory paper.

• Covers implementing classical ciphers (Caesar, substitution, Hill) and modern block ciphers (DES, Blowfish, AES/Rijndael) in C/Java.
• Also includes RSA key generation and encryption, a Diffie-Hellman key-exchange simulation in JavaScript, and computing message digests with SHA-1.

Soft Skills

(Skill Enhancement Course) — an employability-focused lab-cum-classroom subject rather than a technical one.

• Covers listening and verbal/non-verbal communication, self-management (time, stress, and anger management), and workplace/social etiquette.
• Also includes grammar and business-writing practice, plus job-oriented sessions on group discussions, resume building, and mock interviews.

Technical Paper Writing & IPR

(Audit Course — no credit weight) — rounds out the semester with academic-writing and IP literacy.

• Covers structuring and drafting technical reports, proofreading, and presentation skills.
• Also covers word-processor tooling for citations, tracked changes, and document management, plus the basics of intellectual property — patents, designs, trademarks, copyright, and the patenting process.

Mandatory Industry Internship / Mini Project

Running alongside (technically, between) III-II and IV-I coursework, students must complete an 8-week industry internship or mini-project during the intervening summer vacation. It’s a graduation requirement rather than a semester-credit subject, and some colleges let students substitute it with an approved SWAYAM Plus program (e.g., a hands-on data-analytics or applied-AI masterclass).

JNTUK R23 B.Tech CSE IV Year I Semester (4-1) Syllabus & Subject-wise Topics

by Rishi | Jul 10, 2026 | JNTUK R23 Syllabus

IV-I is the lightest theory load of the whole CSE program on paper, but it’s where the curriculum hands over most of the steering wheel to the student — two Professional Electives with five or six subject choices each, two Open Elective slots pulled from outside the department, a hands-on Prompt Engineering skill course, and the start of the industry internship/mini-project track that runs into IV-II. Below is the official R23 course structure table followed by a subject-by-subject breakdown, including every elective option JNTUK lists for this semester.

Course Structure

Note: the same table also carries three optional add-on tracks students can pick up alongside the core 21 credits — a Minor Course (3-0-0-3, drawn from the same specialization-minor pool) and two Honors Course slots (3-0-0-3 each, drawn from the same honors pool). These aren’t part of the mandatory 21-credit total; they’re for students separately pursuing a Minor or Honors distinction in CSE.

On Open Elective III & IV: the R23 CSE document doesn’t lock these two slots to specific CSE subjects — they’re filled from whatever open elective pool the university offers that semester, typically courses run by other engineering departments. For reference, the same document separately lists what CSE itself teaches to other branches as open electives: Principles of Operating Systems/Computer Organization & Architecture, Principles of Database Management Systems, Object Oriented Programming through Java, and Principles of Software Engineering/Computer Networks — but that’s CSE’s outbound offering, not the inbound pool CSE students draw IV-I’s OE-III/OE-IV from.

Subject-Wise Syllabus

Deep Learning

— the theory backbone behind almost every neural-network question in a placement interview, tracing the field from classical ML up through CNNs, RNNs, and generative models.

• Unit 1: The roots of machine learning before deep learning took over — probabilistic modeling, early neural nets, kernel methods, decision trees, random forests, and gradient boosting — plus the overfitting/underfitting tradeoff that motivates going deeper.
• Unit 2: Biological vision and language versus their machine counterparts, the anatomy of artificial neural networks, and the mechanics of training and improving deep networks.
• Unit 3: Building and training networks with Keras, TensorFlow, Theano, and CNTK, worked through two classic examples — binary sentiment classification on movie reviews and multiclass classification on newswire topics.
• Unit 4: Convolutional neural networks (representation learning, convolutional layers, multichannel convolutions) and recurrent neural networks, implemented hands-on in PyTorch.
• Unit 5: Applied deep learning across machine vision, NLP, and generative adversarial networks, plus deep reinforcement learning and a look at generative research — autoencoders, Boltzmann machines, and deep belief networks.

Human Resources & Project Management

— the one paper in the semester that has nothing to do with writing code, covering how organizations hire and develop people, and how projects actually get delivered.

• Unit 1: HRM fundamentals — scope, functions, and emerging trends like e-HRM and HR audits — alongside workforce planning, job design, recruitment, and selection procedures.
• Unit 2: HR development and training methods, performance appraisal techniques, career counseling, and team/group dynamics.
• Unit 3: Core project management concepts — resource management, project types, project networks, life cycle stages, and how projects get appraised and selected.
• Unit 4: Matching management strategy to project type, plus the practical side of implementation — organizational forms, planning, control, and the human factors in delivery.
• Unit 5: Closing out a project — implementation prerequisites, performance review, and abandonment analysis for deciding when a project should be pulled.

Professional Elective-IV (choose one)

Five named subjects plus a BoS-recommended 12-week MOOC option — students pick one for 3 credits.

Software Architecture & Design Patterns

— moves students from writing classes to justifying why the classes are shaped that way, built around the classic Gang-of-Four pattern catalog and UML modeling.

• Unit 1: What a design pattern is, how the standard pattern catalog is organized, and the core ideas behind object-oriented analysis and design.
• Unit 2: Systems analysis in practice — gathering functional requirements, defining conceptual classes and relationships, and translating domain knowledge into a design.
• Unit 3: Structural design patterns — Adapter, Bridge, Composite, Decorator, Facade, Flyweight, and Proxy.
• Unit 4: The Model-View-Controller pattern applied end-to-end through a drawing-program case study, including undo handling and adding new features without breaking the design.
• Unit 5: Distributed object systems — client-server architecture, Java RMI, SOAP/REST web services, and the Enterprise Service Bus.

Blockchain Technology

— for students who want to understand what’s actually inside a block before they write a smart contract, covering consensus mechanisms, chain types, and security.

• Unit 1: Blockchain fundamentals and components, consensus protocols, blockchain types, and cryptocurrency basics (Bitcoin, altcoins, tokens).
• Unit 2: Public blockchain systems — Bitcoin and Ethereum — plus smart contracts and the oracle systems that feed them external data.
• Unit 3: Private and consortium blockchains, permissioned-chain algorithms, Hyperledger/Ripple/Corda, and how Initial Coin Offerings work.
• Unit 4: Blockchain security and privacy challenges, identity management, regulatory compliance, and applications across banking, healthcare, energy, and supply chain.
• Unit 5: Case studies in retail, banking, healthcare, and energy, plus hands-on blockchain development using Python and Hyperledger Fabric.

Augmented Reality & Virtual Reality

— a systems-level tour of AR/VR that moves from tracking hardware and display optics into the human perception science that makes immersion convincing.

• Unit 1: AR foundations — definitions, history, and displays — plus the tracking, calibration, and registration pipeline that anchors virtual content to the real world.
• Unit 2: Computer vision techniques for AR tracking (marker-based and natural-feature), interaction methods, and the software architectures behind AR applications.
• Unit 3: VR foundations — history, human physiology, the geometry of virtual worlds, and the optics of light, lenses, and displays.
• Unit 4: Human visual physiology from the eye to the visual cortex, depth/motion/color perception, and rendering techniques including ray tracing and distortion correction.
• Unit 5: Motion and the vestibular system, locomotion and social interaction in virtual worlds, and how spatial audio is modeled and rendered.

Internet of Things

— ties sensors, connectivity protocols, and edge processing together into one end-to-end IoT stack.

• Unit 1: IoT’s predecessors (wireless sensor networks, machine-to-machine communication), how modern IoT emerged, and its networking and addressing components.
• Unit 2: Sensing and actuation fundamentals, sensor/actuator characteristics, and IoT data-processing topologies and offloading strategies.
• Unit 3: Connectivity protocols spanning short and long range — Zigbee, Thread, RFID, NFC, LoRa, Wi-Fi, Bluetooth, Sigfox — and the communication/discovery/data protocol stack.
• Unit 4: IoT interoperability standards and frameworks, plus fog computing architecture and its applications.
• Unit 5: Emerging IoT paradigms and open challenges, illustrated with agricultural and vehicular IoT case studies.

Agentic AI

— the newest option on the list, covering how AI systems move from answering single prompts to autonomously planning and executing multi-step goals.

• Unit 1: What makes AI “agentic” versus reactive or purely generative — agent architectures, rationality, and the motivation for autonomous systems.
• Unit 2: Decision-making and planning under uncertainty, reinforcement learning fundamentals (MDPs, policy, reward shaping), and deep RL methods like PPO, DQN, and A3C.
• Unit 3: How large language models power agent reasoning — transformer basics, prompting strategies (zero-shot, chain-of-thought, ReAct), retrieval-augmented generation, and tool invocation.
• Unit 4: Practical agent frameworks — LangChain, LangGraph, AutoGen, CrewAI — plus vector databases, multi-agent coordination, and deployment/monitoring concerns.
• Unit 5: Responsible AI design for autonomous agents — bias, fairness, transparency, and safety/alignment — with case studies in healthcare, cybersecurity, and business automation.

Professional Elective-V (choose one)

Four named subjects plus a BoS-recommended 12-week MOOC option — students pick one for 3 credits.

Agile Methodologies

— less about a specific tool and more about the mindset shift from plan-driven delivery to iterative, feedback-driven software development.

• Unit 1: The Agile Manifesto and the values behind it, and why “agile” resists being reduced to one fixed process.
• Unit 2: The 12 Agile principles applied to real project delivery, team communication, and continuous improvement.
• Unit 3: Scrum — roles, ceremonies, sprint planning and retrospectives, and the self-organizing team model.
• Unit 4: Extreme Programming (XP) — its core practices and values, and how it embraces changing requirements through simple, incremental design.
• Unit 5: Lean thinking and Kanban — eliminating waste, managing flow, and the role of an Agile coach in driving organizational change.

Generative AI

— a survey of the models behind the current AI boom, from language models to image and music generation, including the frameworks used to build with them.

• Unit 1: Generative AI’s history and how it differs from discriminative modeling — GANs, VAEs, autoregressive models, and diffusion models — plus ethics and responsible-AI considerations.
• Unit 2: Language models and transformer architecture, text generation with models like BERT and GPT, prompt engineering, RLHF, and retrieval-augmented generation.
• Unit 3: Image generation — GANs, variational autoencoders, stable diffusion, and transformer-based image models like DALL-E and GPT-4V.
• Unit 4: Generative models for painting, music, and gameplay — style transfer, CycleGAN, music-generating RNNs, and RL-based agents.
• Unit 5: Fine-tuning and deploying open-source generative models — LangChain, Llama, Hugging Face, and transfer-learning workflows.

Computer Vision

— the math-heavy elective on this list, covering cameras, optics, and the geometry that turns 2D pixels into 3D understanding.

• Unit 1: Camera models, radiometry, shading, and recovering surface color from image color.
• Unit 2: Linear filters and convolution, Fourier analysis, edge detection, and texture representation/synthesis.
• Unit 3: Multi-view geometry, stereopsis, and image segmentation by clustering.
• Unit 4: Model-fitting techniques — the Hough transform, robust fitting, EM-based segmentation, and object tracking with Kalman filters.
• Unit 5: Geometric camera calibration and model-based vision, with case studies in mobile robot localization and medical image registration.

Cyber Physical Systems

— for students headed toward embedded or industrial systems, covering how software controllers stay correct, secure, and synchronized when tied to physical processes.

• Unit 1: Symbolic synthesis techniques for building verified controllers for cyber-physical systems.
• Unit 2: Security threats and countermeasures specific to cyber-physical systems, including system-theoretic defense approaches.
• Unit 3: Synchronization challenges in distributed CPS — consensus algorithms, time-triggered architectures, and lockstep execution.
• Unit 4: Real-time scheduling under fixed timing constraints, memory effects, and multicore scheduling under variability.
• Unit 5: Model integration across CPS design languages — causality, timing semantics, and formal language integration.

Skill Enhancement Course: Prompt Engineering

— a hands-on course built around getting reliable, structured output from LLMs, with a lab session paired to nearly every unit of theory.

• Unit 1: Prompt anatomy and the iterative prompting lifecycle, practiced through baseline-vs-enhanced prompt comparisons and diagnosing common failure modes.
• Unit 2: Advanced prompting patterns — few-shot examples, role-based personas, negative prompting, and constraint enforcement — tested through zero-shot vs. few-shot lab comparisons.
• Unit 3: Structured outputs and reasoning — generating valid JSON/YAML, chain-of-thought prompting, and task decomposition — validated with parser-checked exercises.
• Unit 4: Retrieval-augmented generation — RAG architecture, LangChain/LCEL basics, embeddings and vector stores — built hands-on into a working retrieval pipeline.
• Unit 5: LLM agents, multimodal prompting, and evaluation — tool-calling agents, text-to-image workflows, LLM-as-judge scoring, and prompt-injection safety testing.

Lab work runs alongside every unit rather than as a separate block: students install and configure LLM APIs, iterate on prompts across multiple rounds, build a JSON/YAML-validated output pipeline, assemble a working LCEL-based RAG chain, and finish by wiring up a tool-calling agent and running a prompt-injection safety test.

Audit Course: Constitution of India

— a mandatory, non-credit civics course every JNTUK student takes before graduating, covering how the Indian Constitution was built and how it functions today.

• Unit 1: How the Constitution was drafted, and its foundational philosophy — the Preamble and its salient features.
• Unit 2: Fundamental rights and duties — equality, freedom, protection from exploitation, religious freedom, constitutional remedies — alongside the Directive Principles of State Policy.
• Unit 3: The three organs of government — Parliament, the Executive (President, Governor, Council of Ministers), and the Judiciary — their composition and powers.
• Unit 4: Local self-government — district administration, municipalities, and the Panchayati Raj system across zila, block, and village levels.
• Unit 5: The Election Commission’s role and functioning, and the constitutional bodies safeguarding SC/ST/OBC and women’s welfare.

Internship Evaluation of Industry Internship / Mini Project

— not a taught subject but a 2-credit evaluation slot that grades the industry internship or mini-project every student is expected to complete this year, assessed against a rubric rather than classroom units.

Open Elective III & IV

Both are 3-0-0-3 slots pulled from the broader university open elective pool rather than a fixed CSE syllabus, so the exact subject a student sits for depends on what’s on offer that semester from other departments. Students should confirm the live options with their department before registration.