UGC NET Computer Science and Applications December 2026: Complete Syllabus, Exam Pattern, Important Topics & Preparation Strategy

Complete and easy-to-understand guide for UGC NET Computer Science and Applications preparation, covering the syllabus, exam pattern, all 10 units and a practical preparation strategy.

UGC NET Computer Science and Applications – Quick Overview

Particular	Details
Subject	Computer Science and Applications
Subject Code	087
Paper	Paper 2
Total Units	10 Units
Questions	100
Total Marks	200
Question Type	Objective Type Multiple Choice Questions
Mode	Computer Based Test (CBT)
Negative Marking	No negative marking

Important: Computer Science and Applications is Subject Code 087. The official syllabus contains 10 units, beginning with Discrete Structures and Optimization and ending with Artificial Intelligence.

What is UGC NET Computer Science and Applications?
Exam Pattern
Complete Syllabus
Unit 1 – Discrete Structures and Optimization
Unit 2 – Computer System Architecture
Unit 3 – Programming Languages and Computer Graphics
Unit 4 – Database Management Systems
Unit 5 – System Software and Operating System
Unit 6 – Software Engineering
Unit 7 – Data Structures and Algorithms
Unit 8 – Theory of Computation and Compilers
Unit 9 – Data Communication and Computer Networks
Unit 10 – Artificial Intelligence
How to Prepare
Study Strategy

What is UGC NET Computer Science and Applications?

UGC NET Computer Science and Applications is the subject-specific Paper 2 for candidates who choose Computer Science and Applications in UGC NET.

The syllabus covers 10 major areas of computer science, including discrete mathematics, computer architecture, programming languages, databases, operating systems, software engineering, data structures and algorithms, theory of computation, computer networks and artificial intelligence.

For December 2026 preparation, candidates should study the prescribed syllabus carefully and follow the latest official NTA information for examination-related updates.

UGC NET Computer Science and Applications Exam Pattern

UGC NET is conducted in Computer Based Test mode. Paper 2 is the subject-specific paper and contains 100 objective-type questions carrying 200 marks.

Feature	Paper 2
Subject	Computer Science and Applications
Subject Code	087
Questions	100
Marks per Question	2 Marks
Total Marks	200 Marks
Question Type	Objective MCQ
Mode	Computer Based Test
Negative Marking	No

UGC NET qualification is based on the combined performance in Paper 1 and Paper 2, subject to the applicable eligibility and qualification rules.

UGC NET Computer Science and Applications Syllabus

The official syllabus contains the following ten units:

Discrete Structures and Optimization
Computer System Architecture
Programming Languages and Computer Graphics
Database Management Systems
System Software and Operating System
Software Engineering
Data Structures and Algorithms
Theory of Computation and Compilers
Data Communication and Computer Networks
Artificial Intelligence

Unit 1 – Discrete Structures and Optimization

Mathematical Logic

Propositional and Predicate Logic
Propositional Equivalences
Normal Forms
Predicates and Quantifiers
Nested Quantifiers
Rules of Inference

Sets and Relations

Set Operations
Representation and Properties of Relations
Equivalence Relations
Partially Ordering

Counting, Mathematical Induction and Discrete Probability

Basics of Counting
Pigeonhole Principle
Permutations and Combinations
Inclusion-Exclusion Principle
Mathematical Induction
Probability
Bayes' Theorem

Group Theory

Groups and Subgroups
Semi Groups
Product and Quotients of Algebraic Structures
Isomorphism
Homomorphism
Automorphism
Rings
Integral Domains
Fields
Applications of Group Theory

Graph Theory

Simple Graph
Multigraph
Weighted Graph
Paths and Circuits
Shortest Paths in Weighted Graphs
Eulerian Paths and Circuits
Hamiltonian Paths and Circuits
Planar Graph
Graph Coloring
Bipartite Graphs
Trees and Rooted Trees
Prefix Codes
Tree Traversals
Spanning Trees and Cut-Sets

Boolean Algebra and Optimization

Boolean Functions and their Representation
Simplification of Boolean Functions
Linear Programming
Graphical Solution
Simplex and Dual Simplex Method
Sensitivity Analysis
Integer Programming
Transportation and Assignment Models
PERT-CPM
Critical Path Calculations
Resource Levelling
Cost Consideration in Project Scheduling

Unit 2 – Computer System Architecture

Digital Logic Circuits and Components

Digital Computers
Logic Gates
Boolean Algebra
Map Simplifications
Combinational Circuits
Flip-Flops
Sequential Circuits
Integrated Circuits
Decoders
Multiplexers
Registers and Counters
Memory Unit

Data Representation

Data Types
Number Systems and Conversion
Complements
Fixed Point Representation
Floating Point Representation
Error Detection Codes
Computer Arithmetic
Addition, Subtraction, Multiplication and Division Algorithms

Register Transfer and Microoperations

Register Transfer Language
Bus and Memory Transfers
Arithmetic Microoperations
Logic Microoperations
Shift Microoperations

Basic Computer Organization and Design

Stored Program Organization
Instruction Codes
Computer Registers
Computer Instructions
Timing and Control
Instruction Cycle
Memory-Reference Instructions
Input-Output
Interrupt

Programming the Basic Computer

Machine Language
Assembly Language
Assembler
Program Loops
Subroutines
Input-Output Programming

Microprogrammed Control, CPU and Processing

Control Memory
Address Sequencing
Design of Control Unit
General Register Organization
Stack Organization
Instruction Formats
Addressing Modes
RISC and CISC Computers
Parallel Processing
Pipelining
Arithmetic Pipeline
Instruction Pipeline
Vector Processing
Array Processors

Input-Output, Memory and Multiprocessors

Peripheral Devices
Input-Output Interface
Asynchronous Data Transfer
Modes of Transfer
Priority Interrupt
DMA
Serial Communication
Memory Hierarchy
Main Memory
Auxiliary Memory
Associative Memory
Cache Memory
Virtual Memory
Memory Management Hardware
Multiprocessors
Interconnection Structures
Interprocessor Arbitration
Interprocessor Communication and Synchronization
Cache Coherence
Multicore Processors

Unit 3 – Programming Languages and Computer Graphics

Language Design and Translation Issues

Programming Language Concepts
Programming Language Paradigms and Models
Programming Environments
Virtual Computers and Binding Times
Programming Language Syntax
Stages in Translation
Formal Transition Models

Elementary Data Types and C Programming

Properties of Types and Objects
Scalar and Composite Data Types
C Tokens and Identifiers
Data Types
Sequence Control
Subprogram Control
Arrays
Structures and Union
Strings
Pointers
Functions
File Handling
Command Line Arguments
Preprocessors

Object Oriented Programming and C++

Class and Object
Instantiation
Inheritance
Encapsulation
Abstract Class
Polymorphism
C++ Tokens
Variables and Constants
Data Types and Operators
Control Statements
Functions and Parameter Passing
Virtual Functions
Constructors and Destructors
Overloading
Templates
Exception and Event Handling
Streams and Files
Multifile Programs

Web Programming

HTML
DHTML
XML
Scripting
Java
Servlets
Applets

Computer Graphics

Video-Display Devices
Raster-Scan and Random-Scan Systems
Graphics Monitors
Input Devices
Points and Lines
Line Drawing Algorithms
Mid-Point Circle and Ellipse Algorithms
Scan Line Polygon Fill Algorithm
Boundary-Fill and Flood-Fill
2-D Geometrical Transformations
Translation, Scaling, Rotation, Reflection and Shear
Matrix Representations and Homogeneous Coordinates
Composite Transformations
Viewing Pipeline
Window to View-Port Transformation
Line and Polygon Clipping Algorithms
3-D Object Representation
Polygon and Quadric Surfaces
Spline Representation
Bezier and B-Spline Curves and Surfaces
Illumination Models
Polygon Rendering Methods
Projection Transforms

Unit 4 – Database Management Systems

Database System Concepts and Architecture

Data Models, Schemas and Instances
Three-Schema Architecture
Data Independence
Database Languages and Interfaces
Centralized and Client/Server Architectures

Data Modeling and Relational Database

Entity-Relationship Diagram
Relational Model
Constraints
Relational Database Schemas
Update Operations
Relational Algebra
Relational Calculus
Codd Rules

SQL and Database Processing

Data Definition and Data Types
SQL Constraints and Queries
Insert, Delete and Update Statements
Views
Stored Procedures and Functions
Database Triggers
SQL Injection
Functional Dependencies
Normalization
Query Processing and Optimization
Transaction Processing
Concurrency Control
Database Recovery
Database Security and Authorization

Advanced Database Topics

Object and Object-Relational Databases
Temporal Databases
Multimedia Databases
Deductive Databases
XML and Internet Databases
Mobile Databases
Geographic Information Systems
Genome Data Management
Distributed Databases
Data Warehousing and Data Mining
OLAP and OLTP
Association Rules
Classification
Clustering
Regression
Support Vector Machine
K-Nearest Neighbour
Hidden Markov Model
Big Data Systems
Map-Reduce and Hadoop
Distributed File System and HDFS
NOSQL and Query Optimization
NOSQL Products
NOSQL in Cloud

Unit 5 – System Software and Operating System

System Software

Machine, Assembly and High-Level Languages
Compilers and Interpreters
Loading, Linking and Relocation
Macros
Debuggers

Operating System Basics

Operating System Structure
Operations and Services
System Calls
Operating System Design and Implementation
System Boot

Process, Threads and CPU Scheduling

Process Scheduling and Operations
Interprocess Communication
Client-Server Communication
Process Synchronization
Critical-Section Problem
Peterson's Solution
Semaphores
Multicore Programming
Multithreading Models
Thread Libraries
Implicit Threading
Threading Issues
CPU Scheduling Algorithms
Multiple-Processor Scheduling
Real-Time CPU Scheduling

Deadlocks and Memory Management

Deadlock Characterization
Deadlock Prevention
Deadlock Avoidance
Deadlock Detection
Recovery from Deadlock
Contiguous Memory Allocation
Swapping
Paging
Segmentation
Demand Paging
Page Replacement
Allocation of Frames
Thrashing
Memory-Mapped Files

Storage, File Systems and Security

Mass-Storage Structure
Disk Structure
Disk Scheduling and Management
RAID Structure
File Access Methods
Directory and Disk Structure
File-System Mounting and Sharing
File-System Structure and Implementation
Directory Implementation
File Allocation Methods
Free-Space Management
I/O Hardware
Kernel I/O Subsystem
Protection and Access Control
Program and Network Threats
Cryptography
User Authentication

Virtual Machines and Operating Systems

Types of Virtual Machines
Virtualization
Linux Operating Systems
Linux Kernel and Process Management
Linux Memory Management
Linux File Systems
Linux Input and Output
Linux Interprocess Communication
Windows Operating Systems
Windows System Components
Windows File System and Networking
Distributed Systems

Unit 6 – Software Engineering

Software Process Models

Software Process
Generic Process Model
Framework Activities
Task Set and Process Patterns
Process Lifecycle
Prescriptive Process Models
Project Management
Component-Based Development
Aspect-Oriented Software Development
Formal Methods
Agile Process Models
Extreme Programming
Adaptive Software Development
Scrum
Dynamic System Development Model
Feature Driven Development
Crystal
Web Engineering

Software Requirements and Design

Functional and Non-Functional Requirements
Requirements Elicitation
Use Cases
Requirement Analysis and Modelling
Requirements Review
Software Requirement Specification (SRS)
Abstraction
Software Architecture
Design Patterns
Separation of Concerns
Modularity
Information Hiding
Functional Independence
Cohesion and Coupling
Object-Oriented Design
Data Design
Architectural Design
User Interface Design
Component Level Design

Software Quality and Estimation

McCall's Quality Factors
ISO 9126 Quality Factors
Quality Control
Quality Assurance
Risk Management
Risk Mitigation
RMMM
Software Reliability
Software Sizing
LOC and Function Point Estimation
Cost and Effort Estimation
COCOMO
Project Scheduling and Staffing
Time-line Charts

Software Testing and Configuration Management

Verification and Validation
Error, Fault, Bug and Failure
Unit and Integration Testing
White-box and Black-box Testing
Basis Path Testing
Control Structure Testing
Test Case Design
Alpha and Beta Testing
Regression Testing
Performance Testing
Stress Testing
Change Control
Version Control
Software Reuse
Software Re-engineering
Reverse Engineering

Unit 7 – Data Structures and Algorithms

Data Structures

Arrays and Applications
Sparse Matrix
Stacks
Queues
Priority Queues
Linked Lists
Trees and Forests
Binary Trees
Threaded Binary Trees
Binary Search Trees
AVL Trees
B Trees
B+ Trees
B* Trees
Data Structures for Sets
Graphs
Sorting and Searching Algorithms
Hashing

Algorithm Analysis and Design

Time and Space Complexity
Asymptotic Notation
Recurrence Relations
Divide and Conquer
Dynamic Programming
Greedy Algorithms
Backtracking
Branch and Bound
Lower Bound Theory
Comparison Trees
Lower Bounds through Reductions

Graph Algorithms and Complexity Theory

Breadth-First Search
Depth-First Search
Shortest Paths
Maximum Flow
Minimum Spanning Trees
P and NP Class Problems
NP-Completeness
Reducibility
Number Theoretic Algorithms
Polynomial Arithmetic
Fast Fourier Transform
String Matching Algorithms
Parallel Algorithms
Approximation Algorithms
Randomized Algorithms

Unit 8 – Theory of Computation and Compilers

Theory of Computation

Formal Language
Non-Computational Problems
Diagonal Argument
Russell's Paradox

Regular Languages

Deterministic Finite Automaton (DFA)
Non-Deterministic Finite Automaton (NDFA)
Equivalence of DFA and NDFA
Regular Languages
Regular Grammars
Regular Expressions
Properties of Regular Languages
Pumping Lemma
Non-Regular Languages
Lexical Analysis

Context Free Languages and Turing Machines

Pushdown Automaton (PDA)
Non-Deterministic Pushdown Automaton (NPDA)
Context Free Grammar
Chomsky Normal Form
Greibach Normal Form
Ambiguity
Parse Tree Representation
Equivalence of PDA and Context Free Grammars
Properties of Context Free Language
Turing Machines
Universal Turing Machines
Models of Computation
Church-Turing Thesis
Recursive and Recursively Enumerable Languages
Context-Sensitive Languages
Unrestricted Grammars
Chomsky Hierarchy of Languages

Unsolvable Problems and Compiler Design

Halting Problem
Post Correspondence Problem
Computational Complexity
Associativity and Precedence
Grammar Transformations
Top Down Parsing
Recursive Descent Predictive Parsing
LL(1) Parsing
Bottom Up Parsing
LR Parser
LALR(1) Parser
Attribute Grammar
Syntax Directed Definitions
Inherited and Synthesized Attributes
Dependency Graph
Type Checking
Runtime System
Activation Tree and Activation Record
Parameter Passing Mechanisms
Symbol Table
Intermediate Code Generation
Code Generation
Code Optimization
Data-Flow Analysis
Loop Optimization
Peep-Hole Optimization
Instruction Scheduling

Unit 9 – Data Communication and Computer Networks

Data Communication

Components of a Data Communication System
Simplex, Half-Duplex and Duplex Modes
Analog and Digital Signals
Noiseless and Noisy Channels
Bandwidth, Throughput and Latency
Digital and Analog Transmission
Data Encoding and Modulation Techniques
Broadband and Baseband Transmission
Multiplexing
Transmission Media
Transmission Errors
Error Handling Mechanisms

Internet, Security and Mobile Technology

WWW
URL
DNS
Email Architecture
SMTP, POP and IMAP
TELNET and FTP
Malware
Cryptography
Steganography
Secret-Key Algorithms
Public-Key Algorithms
Digital Signature
Virtual Private Networks
Firewalls
GSM and CDMA
Mobile Computing
Mobile IP
Communication Satellites
Wireless Networks and Topologies
Mobile Adhoc Networks
GPRS and SMS

Cloud Computing and IoT

SaaS
PaaS
IaaS
Public and Private Cloud
Virtualization
Virtual Server
Cloud Storage
Database Storage
Resource Management
Service Level Agreement
Basics of IoT

Unit 10 – Artificial Intelligence

Approaches to AI

Turing Test
Rational Agent Approach
State Space Representation of Problems
Heuristic Search Techniques
Game Playing
Min-Max Search
Alpha-Beta Cutoff Procedures

Knowledge Representation

Logic
Semantic Networks
Frames
Rules
Scripts
Conceptual Dependency
Ontologies
Expert Systems
Handling Uncertainty in Knowledge

Planning and Natural Language Processing

Components of a Planning System
Linear and Non-Linear Planning
Goal Stack Planning
Hierarchical Planning
STRIPS
Partial Order Planning
Natural Language Processing
Grammar and Language
Parsing Techniques
Semantic Analysis
Pragmatics

Multi-Agent Systems and Fuzzy Sets

Agents and Objects
Agents and Expert Systems
Generic Structure of Multi-Agent Systems
Semantic Web
Agent Communication
Knowledge Sharing using Ontologies
Agent Development Tools
Notion of Fuzziness
Membership Functions
Fuzzification and Defuzzification
Operations on Fuzzy Sets
Fuzzy Functions and Linguistic Variables
Fuzzy Relations
Fuzzy Rules and Fuzzy Inference
Fuzzy Control System

Genetic Algorithms and Artificial Neural Networks

Encoding Strategies
Genetic Operators
Fitness Functions
Genetic Algorithm Cycle
Problem Solving using Genetic Algorithms
Supervised Learning
Unsupervised Learning
Reinforcement Learning
Single Perceptron
Multi Layer Perceptron
Self Organizing Maps
Hopfield Network

How to Prepare for UGC NET Computer Science and Applications

Computer Science and Applications has a broad syllabus, so a structured preparation approach is important. Divide the syllabus into manageable units and combine concept study with regular question practice.

1. Start With the Complete Syllabus

Read all ten units and identify the topics you already understand and the topics that need more attention.

2. Build Strong Fundamentals

Give special attention to core areas such as Discrete Mathematics, Computer Architecture, DBMS, Operating Systems, Data Structures, Algorithms, Theory of Computation and Computer Networks.

3. Practice Along With Theory

Do not postpone question practice until the end. After completing each concept, solve relevant MCQs and numerical problems.

4. Make Short Revision Notes

Maintain concise notes for formulas, algorithms, definitions, properties, complexity results, protocols, database concepts and important comparisons.

5. Solve Previous Questions

Previous UGC NET questions can help you understand the examination style and identify areas where your conceptual understanding needs improvement.

6. Take Unit-Wise Tests

After completing each unit, take a test and analyse every incorrect answer. Revise the concept behind the mistake.

7. Take Full-Length Mock Tests

Once most of the syllabus is completed, start taking full-length mock tests and work on accuracy, time management and question selection.

UGC NET Computer Science Study Strategy

Phase	Focus
Phase 1	Discrete Structures and Optimization + Computer System Architecture
Phase 2	Programming Languages and Computer Graphics + Database Management Systems
Phase 3	System Software and Operating System + Software Engineering
Phase 4	Data Structures and Algorithms + Theory of Computation and Compilers
Phase 5	Data Communication and Computer Networks + Artificial Intelligence
Phase 6	Complete Revision + Previous Questions + Mock Tests

Smart preparation: Complete each unit with concept study, question practice and revision. Keep an error notebook for repeated mistakes and revise it regularly.

Prepare With Yash Prajapati

For more UGC NET, Computer Science, education and career-related content, follow and subscribe for new updates.

◎ Instagram ▶ YouTube

Yash Prajapati