B.Sc. (Computer Science) Computer Science Practical 3 Syllabus - Mumbai University

This is the SY BSc Computer Science syllabus under NEP 2020, in force from the academic year 2025-26. The University still sets the earlier Choice Based papers alongside it — her Summer 2026 third-year timetables name that scheme — so check which scheme your exam form names before you revise.

Loading syllabus...

Syllabus for Computer Science Practical 3

Major · Semester 3 · SY BSc Computer Science · 2 credits · 50 marks

Module I

Practical based on Principles of Operating Systems
Process Communication using Shared Memory
Understand shared memory concepts in inter-process communication.
Implement producer-consumer synchronization using shared memory and semaphores.
Explore issues of race conditions and how to avoid them.
Process Communication using Message Passing
Use message queues/pipes to solve the producer-consumer problem.
Compare and contrast shared memory vs. message-passing approaches.
Analyze blocking vs. non-blocking communication.
Threading and Single Thread Control Flow
Practice thread creation and basic thread lifecycle using standard libraries (e.g., pthreads or Java threads).
Observe execution order, thread joining, and delays.
Measure execution time for sequential vs threaded execution.
Multi-threading and Fibonacci Generation
Implement multi-threading to generate and print Fibonacci sequences.
Explore thread safety, synchronization when accessing shared variables.
Introduce concepts of thread pooling and task delegation.
Process Synchronization and Bounded Buffer Problem
Simulate producer-consumer bounded buffer using mutex and semaphores.
Implement buffer control with synchronized access.
Introduce circular queue techniques for managing shared buffers.
Readers-Writers Problem – Synchronization in Shared Access
Implement reader and writer prioritization.
Use semaphores to allow multiple readers or exclusive writer access.
Extend to fairness in access and deadlock prevention.
CPU Scheduling Algorithms (Part 1) – FCFS and Non-preemptive Scheduling
Simulate First-Come First-Serve scheduling.
Extend implementation to general non-preemptive scheduling.
Analyze waiting time, turnaround time, and Gantt chart generation.
CPU Scheduling Algorithms (Part 2) – Round Robin
Implement Round Robin scheduling with configurable time quantum.
Compare with FCFS: fairness, turnaround, response time.
Track context switches and improve queue management.
Memory Management Techniques
Simulate FIFO and LRU page replacement using page reference strings.
Measure hit/miss ratios under different reference patterns.
Extend to include frames and memory constraints.
Disk Scheduling and Simple File System Design
Simulate FCFS, SSTF, C-SCAN, C-LOOK, RSS for disk head movement.
Design a basic file system structure with block allocation, directory management, and file operations (create, read, delete).

Module II

Practical based on Data Structures
Exploring Abstract Data Types (ADT) & Custom Structures
Create and manipulate structures to model ADTs like Student, Book, or Employee.
Implement basic operations (create, update, delete) using structures.
Reflect on differences between primitive and abstract data types.
Building and Using Singly Linked Lists
Construct a dynamic singly linked list with basic operations.
Apply linked lists to simulate scenarios such as managing a playlist or to-do list.
Compare static (array) vs dynamic (linked) approaches.
Polynomial Operations Using Linked Lists
Represent polynomials using linked lists.
Perform polynomial addition and subtraction by merging lists.
Use structured representation to reinforce node manipulation.
Working with Doubly Linked Lists
Create a doubly linked list with forward and backward traversal.
Implement insertion/deletion at head, tail, and specific positions.
Use in scenarios like browser history or undo-redo features.
Implementing and Using Stack ADT
Implement push, pop, peek using arrays or linked lists.
Solve problems like delimiter matching or undo mechanism.
Convert expressions from prefix to postfix and evaluate them.
Understanding Queues and Circular Queues
Develop linear and circular queues to simulate task scheduling.
Perform enqueue and dequeue with wrap-around logic.
Discuss memory utilization in linear vs circular queues.
Tree Traversals and Binary Search Trees
Create a binary search tree (BST) from a dataset.
Perform and visualize in-order, pre-order, and post-order traversals.
Use traversal results to derive sorted sequences.
Balanced Trees & Priority Queues
Insert values and observe AVL tree rebalancing.
Construct min-heaps or max-heaps and simulate priority queues.
Use priority queues to manage task priorities (e.g., patient triage, job scheduling).
Graph Representations and Traversals
Represent graphs using adjacency matrices and lists.
Implement BFS and DFS to explore graph components.
Use graphs for mapping routes or exploring social networks.
Hashing Concepts and Collision Handling
Implement a hash table with chaining or linear probing.
Simulate insertion, deletion, and search with collisions.
Discuss practical hashing applications (e.g., dictionary lookup, indexing).

Text Books

1 Silberschatz, A., Galvin, P. B., & Gagne, G. (2022). Operating system concepts (10th ed.). Wiley.
2 Aho, A. V., Ullman, J. D., & Lam, M. S. (2021). Data Structures and Algorithms in Python (Adapted by R. Rao). Pearson India.
1 Goodrich, M. T., Tamassia, R., & Goldwasser, M. H. (2014). Data Structures and Algorithms in Java (6th ed.). Wiley India.
2 Kanetkar, Y. (2020). Data Structures Through Python (1st ed.). BPB Publications.

Reproduced from the University of Mumbai syllabus for B.Sc. (Computer Science) under NEP 2020, in force from the academic year 2025-26. Wording is as printed in that syllabus. Module numbering is as printed there too.

Report or request