First Year Engineering • Session 2025–2026
FY AI & DS Semester 2 Study Library
Official Repository for Question Banks, Module Syllabus Notes, and End-Term Exam Papers
1. Fundamentals of Python Languages (FPP): Memory Models & Paradigm Architecture
Python functions as a multi-paradigm, dynamically typed programming language built upon a reference-counted memory management architecture combined with a cyclical garbage collector. In Semester 2 engineering modules, students progress beyond elementary syntax into the operational mechanics of the Python virtual machine (PVM). Understanding how Python manages namespaces, stack frames, and object references is critical for constructing high-performance data processing pipelines.
At the core of Python's execution model is the concept of mutability. Immutable primitives—such as integers, tuples, and strings—are bound to memory addresses that cannot be modified in place. When a modification is applied, a new object allocation occurs. Conversely, mutable data structures such as lists, dictionaries, and sets allow in-place modification, introducing considerations for shallow versus deep copying when passing references across functional boundaries. Object-Oriented Programming (OOP) in Python introduces encapsulation, dunder methods (`__init__`, `__str__`, `__repr__`), inheritance hierarchies, and polymorphic dispatch, providing students with modular code abstractions required for enterprise software engineering.
class DataPipeline:
def __init__(self, name: str):
self._name = name
self.__records = []
def ingest(self, record: dict) -> None:
if isinstance(record, dict):
self.__records.append(record)
def __len__(self) -> int:
return len(self.__records)
2. Applied Engineering Physics & Wave Mechanics: Quantum & Electromagnetic Fundamentals
Applied Physics in the AI & DS curriculum establishes the physical principles governing semiconductor hardware, optical communication, and sensor instrumentation. The wave-particle duality of light, formulated through de Broglie hypothesis and wave packet dynamics, underpins modern solid-state physics. The Schrödinger wave equation provides the mathematical framework for modeling electron behavior in quantum wells and semiconductor energy bands.
In wave optics, the phenomena of interference and diffraction are quantified through Huygens-Fresnel principles. Coherent light generation in LASER systems (Light Amplification by Stimulated Emission of Radiation) relies on population inversion within active optical cavities. These optical principles are vital for fiber-optic network infrastructure, where total internal reflection enables high-speed data transmission over long distances with minimal signal attenuation.
3. Vector Calculus & Linear Matrix Spaces: Geometric Transformations & Multivariable Fields
Advanced engineering mathematics provides the rigorous foundation for multidimensional optimization, machine learning loss evaluation, and spatial data analytics. Vector differential calculus introduces scalar field gradients ($\nabla f$), vector field divergence ($\nabla \cdot \mathbf{F}$), and curl ($\nabla \times \mathbf{F}$), characterizing conservative vector fields and fluid/electromagnetic flow dynamics.
Integral vector calculus connects surface integrals to volume integrals through fundamental theorems: Green's Theorem in a plane, Stokes' Theorem for closed curves, and Gauss' Divergence Theorem for closed boundaries. Concurrently, linear matrix theory equips students with linear operator tools to calculate matrix ranks, solve non-homogeneous systems of linear equations, and compute characteristic polynomial roots to extract eigenvalues and eigenvectors for multidimensional transformations.
4. Introduction to Artificial Intelligence: State-Space Formalisms & Knowledge Engineering
Artificial Intelligence treats problem-solving as a formal search through an explicit state space defined by a set of initial states, action transition models, goal tests, and path costs. Uninformed search algorithms—such as Breadth-First Search (BFS), Depth-First Search (DFS), and Uniform Cost Search (UCS)—explore state spaces systematically without domain-specific evaluation metrics.
Informed or heuristic search algorithms incorporate domain knowledge via heuristic evaluation functions. $A^*$ search utilizes $f(n) = g(n) + h(n)$, combining exact path cost $g(n)$ with estimated remaining cost $h(n)$ to yield optimal trajectories when $h(n)$ is admissible. Knowledge representation formalisms transition from propositional logic to First-Order Predicate Logic (FOL), utilizing unification, modus ponens, and resolution refutation to execute automated reasoning in complex problem domains.
import heapq
def a_star_search(graph, start, goal, h_func):
open_set = []
heapq.heappush(open_set, (0 + h_func(start), 0, start, [start]))
visited = set()
while open_set:
f_cost, g_cost, current, path = heapq.heappop(open_set)
if current == goal:
return path
visited.add(current)
for neighbor, weight in graph[current].items():
if neighbor not in visited:
new_g = g_cost + weight
heapq.heappush(open_set, (new_g + h_func(neighbor), new_g, neighbor, path + [neighbor]))
return None
5. Foundations of Computer Security & Networks: Layered Architectures & Cryptographic Defense
Computer networking structures digital communications through layered abstraction models, primarily the ISO/OSI seven-layer reference model and the practical TCP/IP protocol suite. The Data Link Layer handles framing, error detection via Cyclic Redundancy Checks (CRC), and Media Access Control (MAC) address resolution. The Network Layer implements logical routing algorithms (Distance Vector and Link State) to forward packets across autonomous systems via IPv4 and IPv6 protocols.
The Transport Layer establishes end-to-end communication guarantees through the Transmission Control Protocol (TCP)—incorporating three-way handshakes, sliding window flow control, and exponential backoff congestion management—or unacknowledged User Datagram Protocol (UDP) sockets. Computer security integrates modern cryptographic defense mechanisms, employing symmetric ciphers (AES) for high-speed payload encryption and asymmetric RSA/ECC key pairs for digital signatures, authentication, and secure TLS handshake exchanges.