BCA Syllabus 2024-2026 – Gurugram University (GU) | NEP 2020 | All 6 Semesters

Fundamentals of Computers & Programming in C (CC-ID1 | 240/BCA/CC101) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Computer Fundamentals — Concept of data and information, components of a computer system, input and output devices, CPU components, memory and storage devices, classification of computers, advantages and limitations of computers, applications of computers. Social concerns of computer technology including positive and negative impacts, computer crimes, viruses and their remedial solutions. Computer software concepts including system software and application software, overview of operating systems, programming languages (Machine, Assembly, High-Level, 4GL), language translators, linker and loader. Unit II: Problem Solving and C Fundamentals — Problem identification and analysis, algorithms, flowcharts, pseudocode, decision tables, program coding, testing and execution. C Programming fundamentals: keywords, variables, constants, and structure of a C program. Unit III: Operators, Expressions and Decision Making — Arithmetic, unary, logical, bitwise, assignment, and conditional operators and expressions. Decision-making using if, if-else, else-if ladder, switch statements, break, continue, and goto. Unit IV: Loops and Functions — Looping using while, do-while, for, and nested loops. Functions: user-defined functions, library functions, function prototypes, passing arguments, passing arrays, recursion, macro vs functions, pointers in C. Lab Experiments: Quadratic equation roots, integer reversal, palindrome check, simple calculator (switch), linear search, bubble sort, sparse matrix, string manipulation functions, right rotate function, recursive factorial & binomial coefficient, student records using structures, array statistics using pointers.

PC Software (CC-ID2 | 240/BCA/CC102) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Windows — Basics of Windows OS, history, components, icons, taskbar, desktop, title bar, running applications, Windows Explorer, managing files and folders, configuring system devices, Control Panel, Windows accessories. Unit II: MS Word — Creating and editing documents, formatting, Auto-text, Autocorrect, spelling and grammar tools, page formatting, bookmarks, advanced features including Mail Merge, Macros, Tables, printing, styles, linking and embedding objects. Unit III: MS Excel — Introduction to spreadsheets, creating and editing worksheets, formatting, formulas and functions, charts, database management including sorting, querying, filtering, tables, validation, goal seek, and scenarios. Unit IV: MS PowerPoint — Creating and manipulating presentations, enhancing slides, organizational charts, Excel charts, WordArt, layering art objects, animations and sounds, inserting animated pictures and recorded sound effects. Lab Experiments: MS Word — text formatting, styles, page layout, mail merge, tables; MS Excel — data entry, conditional formatting, sorting, filtering, formulae, charts; MS PowerPoint — slide creation, transitions, animations, graphics.

Logical Organization of Computers (CC-ID3 | 240/BCA/CC103) — 4 Credits | 100 Marks (30 Internal + 70 External) | Duration: 3 hrs. Theory-only course; no practicals. Unit I: Information Representation and Binary Logic — Number systems (Binary, Octal, Decimal, Hexadecimal), binary arithmetic, fixed-point and floating-point representation, BCD codes, error-detecting and correcting codes, ASCII, EBCDIC, Unicode. Boolean algebra, Boolean theorems, truth tables, canonical and standard forms, simplification using Venn Diagrams and Karnaugh Maps. Unit II: Digital Logic and Combinational Circuits — Basic gates (AND, OR, NOT), universal gates (NAND, NOR), XOR, XNOR. Combinational circuits including Half-Adder, Full-Adder, Half-Subtractor, Full-Subtractor, encoders, decoders, multiplexers, demultiplexers, comparators, and code converters. Unit III: Sequential Logic — Characteristics of sequential logic, flip-flops (Clocked RS, D-type, JK, T-type, Master-Slave), state tables, state diagrams, flip-flop excitation tables. Registers — SISO, SIPO, PISO, PIPO and shift registers. Counters — asynchronous and synchronous binary counters, Modulo-N counters, Up-Down counters. Unit IV: Memory, I/O Devices and Instruction Design — Memory parameters, semiconductor RAM and ROM, magnetic and optical storage, flash memory, I/O devices and controllers. Machine instruction, instruction set selection, instruction cycle, instruction formats, addressing modes. I/O interface, interrupt structure, programmed control, interrupt-controlled and DMA transfer, I/O processors.

Data Structures (CC-ID4 | 240/BCA/CC201) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Fundamentals and Strings — Data structure definition, data type vs data structure, categories, operations, applications. Algorithm complexity, time-space trade-off, Big-O notation. Strings: introduction, string operations, pattern matching algorithms. Unit II: Arrays and Sorting/Searching — Linear arrays, memory representation, traversal, insertion and deletion. Multidimensional arrays, sparse matrices, 2D array operations. Sorting techniques: Bubble Sort, Merge Sort, Selection Sort, Heap Sort, Insertion Sort. Searching techniques: sequential search, binary search, search trees. Unit III: Stacks, Queues and Linked Lists — Stacks: representation and operations, applications (infix to postfix, expression evaluation). Queues: operations, circular queues, dequeue, priority queues and applications. Linked Lists: singly, doubly, circular; operations (insertion, deletion, traversal, sorting); dynamic memory management. Unit IV: Trees and Graphs — Trees: basic terminology, binary trees, linked list representation, tree operations, binary tree traversal (in-order, pre-order, post-order) with and without recursion, applications. Graphs: definitions, adjacency matrix/list representation, graph traversals (BFS/DFS), shortest path problem, applications. Lab Experiments: Linear search in 2D array, binary search (iterative and recursive), matrix operations (add/subtract/multiply/transpose), quick sort, string operations, call-by-value vs call-by-reference, BST implementation, linked list operations, file operations (insert/delete/update).

Mathematical Foundations of Computer Science (CC-ID5 | 240/BCA/CC202) — 4 Credits | 100 Marks (30 Internal + 70 External) | Duration: 3 hrs. Theory-only course; no practicals. Unit I: Basic Statistics — Measures of central tendency (Mean, Mode, Median), frequency distribution tables, measures of dispersion (Range, Variance, Standard Deviation), correlation and regression analysis. Unit II: Algorithms and Graph Theory — Algorithm concepts, merits and demerits, fast exponentiation, linear and binary search, Big-O notation, complexity analysis, advantages of logarithmic algorithms. Graph theory: types of graphs, degree of vertex, subgraphs, isomorphic and homeomorphic graphs, adjacency and incidence matrices, Eulerian and Hamiltonian paths and circuits. Unit III: Trees, Recursion and Sorting — Trees, minimum distance trees, minimum weight and minimum distance spanning trees. Recursively defined functions. Merge Sort, Insertion Sort, Bubble Sort, Decimal to Binary conversion. Unit IV: Recurrence Relations and Number Theory — Linear Homogeneous Recurrence Relations (LHRR), LHRR with Constant Coefficients, Divide and Conquer Recurrence Relations (DCRR), recursive procedures. Number theory: mathematical induction, GCD, Euclidean algorithm, Fibonacci numbers, congruences and equivalence relations, public key encryption schemes.

Database Management System (CC-ID6 | 240/BCA/CC203) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Database System Concepts and Architecture — Traditional file processing vs DBMS, characteristics and advantages of DBMS, three-schema architecture, data independence, data models, schemas and instances, database languages and interfaces, classification of DBMS. Data modeling: ER diagrams, relational model constraints, relational algebra and calculus, Codd's Rules. Unit II: Normalization and SQL — Functional dependencies and normalization (1NF to BCNF). SQL as 4GL: DDL, DML, DQL, DCL, TCL components. Data definition, data types, constraints, queries, insert/delete/update statements, views, stored procedures and functions, database triggers, SQL injection. Unit III: Query Processing and Transaction Management — Translating SQL queries into relational algebra, basic algorithms for query operations, heuristic and cost-based query optimization, semantic query optimization. Transaction processing: ACID properties, schedules and recoverability, serializability, transaction support in SQL. Database security and authorization basics. Unit IV: Concurrency Control and Recovery — Locking techniques, timestamp ordering, multiversion concurrency control (MVCC), validation-based concurrency control, granularity of data items, multiple granularity locking, concurrency control in indexes. Recovery techniques: deferred update, immediate update, shadow paging, ARIES recovery algorithm, database backup and catastrophic failure recovery. Lab Experiments: Database creation and SQL queries, insertion/deletion/modification/viewing of records, views, synonyms, sequences, indexes, save points, employee database with constraints, mini projects (Inventory Control, Hospital Management, Railway Reservation, Hotel Management, etc.).

Operating Systems (CC-ID7 | 240/BCA/CC301) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Introduction to Operating Systems — OS functions and characteristics, historical evolution, OS structure and operations. Types: real-time, multiprogramming, multiprocessing, batch processing. OS services, interface, implementation methodologies, system calls, and system programs. Unit II: Process Management and CPU Scheduling — Process concepts, operations on processes, process states and PCB, inter-process communication. Multithreaded programming: multithreading models, threading issues. CPU scheduling: criteria, levels, scheduling algorithms (FCFS, SJF, Round Robin, Priority, Multilevel), multiple processor scheduling, algorithm evaluation. Unit III: Synchronization and Deadlocks — Critical section problem, Peterson's solution, synchronization hardware, semaphores, classical synchronization problems (Producer-Consumer, Readers-Writers, Dining Philosophers), monitors, atomic transactions. Deadlocks: characterization, prevention, avoidance (Banker's Algorithm), detection and recovery. Unit IV: Memory Management and Distributed OS — Single-user and multiuser memory management, partitioning, swapping, contiguous memory allocation, paging, segmentation. Virtual memory: demand paging, page replacement algorithms (FIFO, Optimal, LRU), thrashing, memory-mapped files. Distributed OS: types, network structure, design issues. Lab Experiments: FCFS, SJF, Round Robin, Priority CPU scheduling; Producer-Consumer using semaphores; Dining Philosophers; FIFO and LRU page replacement; sequential and indexed file allocation.

Object Oriented Programming Using C++ (CC-ID8 | 240/BCA/CC302) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Elements of Programming and Functions — Basic elements of programming, console I/O operations. Functions: function prototyping, call and return by reference, inline functions, default and const arguments, function overloading, arrays, manipulators, enumeration. Unit II: Classes, Objects and OOP Concepts — Basic characteristics and advantages of OOP, procedural vs OOP. Classes and objects: specifying a class, creating objects, private and public data members and member functions, defining inline member functions, static data members and functions. Arrays within class, arrays of objects, objects as function arguments, returning objects. Unit III: Constructors, Destructors, Operator Overloading and Inheritance — Constructors and destructors: parameterized, multiple, default arguments, dynamic initialization, copy constructors, dynamic constructors, const objects. Operator overloading: unary and binary, rules for overloading. Inheritance: defining derived classes, types of inheritance, constructors and destructors in derived classes. Unit IV: Pointers, Virtual Functions, Friend Functions and File Handling — Pointer to objects, this pointer, new and delete operators, virtual functions, friend functions. File handling: opening and closing files, file modes, file pointers, sequential I/O, updating files, random access, error handling during file operations, command line arguments. Lab Experiments: First 10 prime numbers, constructor overloading, constructor/destructor invocation order in inheritance, area calculation (Triangle, Circle, Rectangle), static variables and functions, single/multiple inheritance, function overloading, operator overloading, constructor/destructor with scope resolution.

Web Designing (CC-ID9 | 240/BCA/CC303) — 3 Credits | 75 Marks (15 Internal + 35 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Introduction to Internet and WWW — Evolution and history of the World Wide Web, web pages and contents, web clients and servers, web browsers, Hypertext Transfer Protocol (HTTP), URLs, searching and webcasting techniques, search engines and scripting languages. Unit II: Web Publishing — Hosting a website, Internet Service Providers, planning and designing a website, web content authoring, web graphics design, web programming, steps for developing a website, choosing contents, home page, domain names, and introduction to markup languages (HTML and DHTML). Unit III: Web Development with HTML — HTML document features, fundamental HTML elements, creating links, headers, text styles, text structuring, text color and background, formatting, page layouts, images, ordered and unordered lists, inserting graphics, table creation and layouts, frame creation and layouts, working with forms, menus, radio buttons, checkboxes, and text boxes. Unit IV: CSS (Cascading Style Sheets) — CSS features, core syntax, types of CSS, style sheets and HTML, style rule cascading and inheritance, text properties, CSS Box Model, normal flow box layout, positioning and other useful style properties, features of CSS3. Lab Experiments: Webpages about art forms using headings and lists, sections with background colors and internal hyperlinks, image properties, profile pages with tables and hyperlinks, frames for Indian flag with chakra, frame-based navigation structure, HTML image map for India map.

Computer Networks (CC-ID10 | 240/BCA/CC401) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Introduction and Network Models — Data communication components, data representation, simplex/half-duplex/full-duplex transmission, modulation, multiplexing, computer networks, distributed processing, internet, topologies, packet and circuit switching, connection-oriented and connectionless services. OSI and TCP/IP reference models, Physical Layer, LAN (Ethernet). Unit II: Data Link Layer, MAC and Network Layer — MAC addressing, framing, Stop-and-Wait, Go-Back-N ARQ, Selective Repeat ARQ, sliding window protocol. Medium Access Control: random access, controlled access, and channelization protocols. Network Layer: logical addressing, classful and classless addressing, subnetting, IPv4, ICMPv4, ARP, RARP, BOOTP, IPv6. Unit III: Network Devices, Routing and Transport Layer — Repeater, hub, switch, router, gateway. Routing algorithms: shortest path, flooding, hierarchical routing, link state, distance vector routing. Transport Layer: process-to-process communication, UDP, TCP, TCP connection management. Unit IV: Application Layer and Network Security — Congestion control, quality of service (QoS). Application Layer: DNS, email, FTP, HTTP, SNMP. Network Security: firewalls, security goals, types of attacks, symmetric and asymmetric key ciphers. Lab Experiments: Network topology on Packet Tracer, VLAN configuration, RJ45 cable construction, static routing and security, complex topologies, Wireshark traffic monitoring, ARP, RIP, OSPF, BGP, DHCP and DNS configuration.

Software Engineering (CC-ID11 | 240/BCA/CC402) — 4 Credits | 100 Marks (30 Internal + 70 External) | Duration: 3 hrs. Theory-only course; no practicals. Unit I: Introduction, SLC Models and Requirements — Software and its characteristics, evolving role of software, software products, processes, and crisis. Software engineering evolution and principles, programming-in-the-small vs large, software components and processes. SLC Models: Waterfall, Prototype, Spiral, Evolutionary, Iterative Enhancement, Object-Oriented and other modern models. Software requirements: functional and non-functional, user and system requirements, requirements documentation, feasibility studies, elicitation, validation, and management. Unit II: Software Design and Testing — Basic concepts of software design, architectural design, low-level design, modularization, design structure charts, flowcharts, coupling and cohesion measures. Design strategies: function-oriented, object-oriented, top-down and bottom-up design, user interface design, coding standards. Software testing: verification vs validation, software reliability, levels of testing, structural testing (White Box), functional testing (Black Box). Unit III: Software Quality, Project Management and Metrics — Software quality attributes, SQA plans and activities, software documentation. Project management: estimation, planning, and scheduling. Risk management: reactive vs proactive strategies, risk identification, projection, refinement, mitigation, monitoring. Software metrics: process and project metrics, LOC, Halstead's Software Science, Function Point, Cyclomatic Complexity, estimation models (COCOMO I & II, Putnam). Unit IV: Maintenance, Configuration Management and CASE — Need for maintenance, categories (preventive, corrective, perfective), cost of maintenance, software re-engineering, reverse engineering, documentation. Software Configuration Management (SCM): activities, change control, version control, software reuse, evolution. CASE: Computer Aided Software Engineering tools and concepts.

Java Programming (CC-ID12 | 240/BCA/CC403) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Introduction to Java — Evolution of Java, OOP structure, overview and characteristics of Java, Java program compilation and execution, JVM organization, client-side programming, platform independence and portability, security, JVM/JRE/JDK relationship, JAR format, naming conventions, data types, type casting, operators, security promises of JVM. Unit II: OOP Implementation — Classes, objects, attributes, methods, data encapsulation, reference variables, constructors, anonymous blocks, method overloading, static data members, argument passing (primitives and objects), wrapper classes. this keyword: referencing instance members, intra-class constructor chaining. Inheritance: extending classes, super keyword, method overriding. Unit III: Packages, Interfaces and Exception Handling — Packages: defining packages, CLASSPATH, naming conventions, accessibility, using package members. Interfaces: implementing interfaces, interface vs abstract classes, extends and implements together. Exception handling: try-catch blocks, multiple exceptions, finally clause, types of exceptions, throwing exceptions, user-defined exceptions. Unit IV: Multithreading, I/O and Strings — Multithreading: main thread, Java thread model, thread priorities, synchronization, inter-thread communication. I/O: streams and stream classes, predefined streams, reading/writing from console and files, transient and volatile modifiers, native methods. Strings: String class, string operations, data conversion using valueOf(), StringBuffer class and methods. Lab Experiments: Fibonacci series (recursive and non-recursive), matrix multiplication, method and constructor overloading, static blocks and variables, employee details using Scanner, sorting names, single and multi-level inheritance, hierarchical inheritance, method overriding, abstract Shape class (Rectangle, Triangle, Circle), interfaces, multiple/hybrid inheritance, inner classes, packages, super/final keywords, exception handling programs, multithreading programs.

Computer Graphics (CC-ID13 | 240/BCA/CC501) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Graphics Primitives — Introduction to computer graphics, basics of graphics systems, application areas, overview of graphics systems, video-display devices, raster-scan and random-scan systems, graphics monitors, workstations and input devices. Output primitives: points and lines, line drawing algorithms (DDA, Bresenham's), midpoint circle and ellipse algorithms. Filled-area primitives: scan-line polygon fill algorithm, boundary fill and flood-fill algorithms. Unit II: 2D Geometric Transforms and Viewing — 2D transformations: translation, scaling, rotation, reflection and shear, matrix representations and homogeneous coordinates, composite transforms, transformation between coordinate systems. 2D viewing: viewing pipeline, viewing coordinate reference frame, window-to-viewport coordinate transformation, viewing functions, Cohen-Sutherland and Cyrus-Beck line clipping algorithms, Sutherland-Hodgman polygon clipping algorithm. Unit III: 3D Object Representation — Polygon surfaces, quadric surfaces, spline representation, Hermite curves, Bezier curves, B-Spline curves, Bezier and B-Spline surfaces. Basic illumination models, polygon-rendering methods. Unit IV: 3D Geometric Transformations and Viewing — 3D transformations: translation, rotation, scaling, reflection and shear, composite transformations. 3D viewing: viewing pipeline, viewing coordinates, view volume, general projection transforms and clipping. Lab Experiments: DDA and Bresenham's line drawing, midpoint circle and ellipse algorithms, scan-line polygon fill, boundary fill and flood fill, 2D transformations (translate/scale/rotate/reflect/shear), composite transformations, Cohen-Sutherland line clipping, Sutherland-Hodgman polygon clipping, Bezier and B-Spline curves, 3D transformations, perspective and orthographic projections.

Python Programming (CC-ID14 | 240/BCA/CC502) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Python Fundamentals — Data types, variables, assignments, immutable variables, numerical types, arithmetic operators and expressions, comments, conditions, boolean logic, logical operators, ranges, control statements (if-else, for, while loops), short-circuit evaluation. Strings and text files, manipulating files and directories (os and sys modules), reading/writing text and numbers, creating and reading formatted files (CSV, tab-separated), string subscript operator, indexing, slicing. Unit II: Data Structures and Functions — Lists, tuples, dictionaries: basic operators, replacing/inserting/removing elements, searching and sorting lists, dictionary literals, adding/removing keys, accessing/replacing values, traversing dictionaries. Function design: hiding redundancy and complexity, arguments and return values, formal vs actual arguments, named arguments. Unit III: Object Oriented Programming and Exception Handling — Classes and OOP: classes, objects, attributes and methods, defining classes, design with classes, data modeling, persistent storage of objects. Encapsulation, information hiding, method signature, classes and instances, abstraction, inheritance, polymorphism, operator overloading (__eq__, __str__, etc.), abstract classes, exception handling with try blocks. Unit IV: GUI Programming with tkinter — Event-driven programming paradigm, tkinter module, creating simple GUI applications, buttons, labels, entry fields, dialogs, widget attributes (sizes, fonts, colors), layouts, nested frames. Lab Experiments: Basic Python programs (variables, conditionals, loops, functions, libraries, errors), data structures (lists, tuples, dictionaries), OOP (classes, inheritance, polymorphism, abstract classes), PyQt for GUIs, NumPy (matrices, vectors, linear algebra), SciPy for numerical computations, Matplotlib for plotting, IPython.

Analysis and Design of Algorithms (CC-ID15 | 240/BCA/CC503) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Basic Concepts of Algorithms — Notion of algorithm, fundamentals of algorithmic problem solving, important problem types, analysis framework, asymptotic notations (Big-O, Omega, Theta) and basic efficiency classes. Mathematical analysis of non-recursive and recursive algorithms, recurrence relations, solving recurrence relations using the substitution method. Unit II: Sorting Algorithms — Brute Force approach: Selection Sort, Bubble Sort, sequential search (Linear Search), brute-force string matching. Divide and Conquer strategy: Merge Sort, Quick Sort, Binary Search, Strassen's matrix multiplication. Unit III: Greedy and Dynamic Programming — Greedy approach: Fractional Knapsack problem, Minimum Cost Spanning Tree (Prim's and Kruskal's algorithms), single-source shortest path problem. Dynamic Programming: principle of optimality, multi-stage graph problem, all-pair shortest path, 0/1 Knapsack problem, Travelling Salesperson Problem. Unit IV: Backtracking, Branch and Bound, and Complexity Classes — Backtracking: general method, N-Queen problem, 0/1 Knapsack problem. Branch and Bound: general method, 0/1 Knapsack, Travelling Salesperson problem. Lower bound theory, decision trees, complexity classes P, NP, and NP-Complete problems. Lab Experiments: Sorting techniques (Bubble, Insertion, Selection, Quick, Merge Sort), minimum cost spanning trees, Travelling Salesperson Problem, Longest Path in a DAG, Shortest Path with exactly k edges, maximum edge-disjoint paths, 0/1 Knapsack using Dynamic Programming, tree traversal algorithms, N-Queens Problem.

Management Information System (CC-ID16 | 240/BCA/CC601) — 4 Credits | 100 Marks (30 Internal + 70 External) | Duration: 3 hrs. Theory-only course; no practicals. Unit I: Introduction to Systems and Information — Basic system concepts, types of systems, the systems approach. Information systems: definition and characteristics, types of information, role of information in decision making. Sub-systems of an information system: EDP and MIS management levels, EDP/MIS/DSS. Unit II: Overview of MIS — Definition and characteristics of MIS, components of MIS, framework for understanding MIS — information requirements and levels of management, Simon's Model of Decision-Making, structured vs unstructured decisions, formal vs informal systems. Unit III: Developing Information Systems — Analysis and design of information systems, implementation and evaluation, pitfalls in MIS development. Unit IV: Functional MIS and E-Business — Study of Personnel MIS, Financial MIS, and Production MIS. Introduction to e-business systems, e-commerce technologies and applications, decision support systems for planning, control and decision-making.

Compiler Design (CC-ID17 | 240/BCA/CC602) — 3 Credits | 75 Marks (25 Internal + 50 External) | Duration: 3 hrs. Theory-only course; no practicals. Unit I: Introduction to Compilers and Lexical Analysis — Definition of compiler and interpreter, differences, phases of a compiler, role of lexical analyzer, regular expressions, finite automata, converting regular expressions to finite automata, passes and phases of translation, bootstrapping, LEX (lexical analyzer generator). Unit II: Parsing — Bottom-up parsing: handles, handle pruning, stack implementation of shift-reduce parsing, conflicts during shift-reduce parsing, LR grammars, LR parsers (Simple LR, Canonical LR/CLR, LALR), error recovery in parsing, YACC (automatic parser generator). Top-down parsing: role of parser, context-free grammar, derivations, parse trees, ambiguity, elimination of left recursion, left factoring, eliminating ambiguity from dangling-else grammar, backtracking, recursive descent parsing, predictive parsers, LL(1) grammars. Unit III: Syntax-Directed Translation and Intermediate Code Generation — Syntax directed definitions, construction of syntax trees, S-attributed and L-attributed definitions, translation schemes, emitting a translation. Intermediate forms of source programs: abstract syntax trees, Polish notation and three-address code, types of three-address statements, translation of simple statements, Boolean expressions and flow-of-control statements. Unit IV: Code Optimization and Code Generation — Organization of code optimizer, basic blocks and flow graphs, optimization of basic blocks, principal sources of optimization, DAG representation of basic blocks, global data flow analysis. Code generation: machine-dependent code generation, object code forms, target machine, a simple code generator, register allocation and assignment, peephole optimization.

Artificial Intelligence (CC-ID18 | 240/BCA/CC603) — 4 Credits | 100 Marks (25 Internal + 50 External + 5 Practical Internal + 20 Practical External) | Duration: 3 hrs. Unit I: Introduction to Artificial Intelligence — Intelligence, AI concepts, various definitions of AI, knowledge pyramid, people vs computers (what each does better), characteristics of AI problems, problem representation in AI, components of AI, AI evolution, application areas of AI, history of AI, Turing Test and Revised Turing Test. Unit II: Expert Systems — Components of Expert Systems: knowledge base, inference engine, user interface. Features, Expert System life cycle, categories, rule-based vs model-based expert systems, advantages and limitations. Developing an expert system: identification, conceptualization, formalization, implementation, testing, using an expert system, application areas. Unit III: AI and Search Processes — Brute force search: Depth First Search (DFS), Breadth First Search (BFS). Heuristic search: Hill Climbing, Constraint Satisfaction, Means-End Analysis, Best First Search, A* Algorithm, AO* Algorithm, Beam Search. Unit IV: Natural Language Processing and Robotics — NLP: introduction, need, goal, fundamental problems in natural language understanding, how people overcome NLP problems. Speech Recognition: introduction, advantages and approaches. Introduction to Robotics: parts of a robot, controlling a robot, intelligent robots, mobile robots. Lab Experiments: DFS implementation, BFS implementation, Travelling Salesman Problem, Simulated Annealing Algorithm, Wumpus World problem, 8-puzzle problem, Towers of Hanoi, A* Algorithm, Hill Climbing Algorithm, information bot about college.