Difficulty: Intermediate | Prerequisites: Hardware and Low-Level Foundations study notes (Part 1), basic programming in C or Python
This is the second half of the CSE overview. Where Part 1 covered the hardware from gates to processor architecture, this document covers the software and systems layers built on top of that hardware: operating systems, computer networks, software engineering principles, real-time and cyber-physical systems, and the capstone/career landscape. If you have not reviewed the hardware foundations, start there, as several concepts here (interrupts, memory hierarchy, pipelining) are assumed knowledge.
The software side of CSE covers how operating systems manage hardware, how data moves across networks, and how large software systems are designed and built. It also includes real-time and cyber-physical systems, where software must interact with the physical world under strict timing constraints. Graduates with this combination of hardware understanding and software skill are in high demand across embedded, automotive, aerospace, and semiconductor industries.
Operating system (OS)
The layer of software that sits between applications and hardware, managing resources such as CPU time, memory, and I/O devices. Think of it as the traffic controller that decides which programme gets to use which part of the computer, and when.
Process scheduling
The OS mechanism that decides which process runs on the CPU at any given time. Common algorithms include round-robin, priority-based, and multi-level feedback queue.
Virtual memory
A memory management scheme that gives each process the illusion of having its own large, contiguous address space, even though physical RAM is shared and limited. The OS maps virtual addresses to physical addresses using page tables.
Concurrency
The ability of a system to handle multiple tasks that overlap in time. In simple terms, concurrency is about structuring a programme so that several things can make progress, whether or not they run at the exact same instant.
Synchronisation primitive
A low-level mechanism (mutex, semaphore, condition variable) used to coordinate access to shared resources between concurrent threads or processes, preventing race conditions.
TCP/IP
The suite of communication protocols that underpins the internet. TCP (Transmission Control Protocol) provides reliable, ordered delivery of data; IP (Internet Protocol) handles addressing and routing packets between hosts.
Routing
The process of selecting a path for data to travel across a network from source to destination. Routers use routing tables and algorithms (e.g. OSPF, BGP) to determine the best path.
Object-oriented programming (OOP)
A programming paradigm that organises code around objects, which bundle data (attributes) and behaviour (methods). In simple terms, you model things as self-contained units that know what they are and what they can do.
Computational complexity
A measure of how the resources (time, space) required by an algorithm grow as the input size increases. Big-O notation (e.g. O(n), O(n log n), O(n squared)) is the standard way to express this.
Cyber-physical system (CPS)
A system that integrates computation, networking, and physical processes. Self-driving cars and smart manufacturing plants are examples: the software and the physical world are tightly coupled.
ADAS (Advanced Driver Assistance Systems)
A collection of electronic technologies in vehicles that assist drivers with safety and driving functions, including lane-keeping, adaptive cruise control, and automatic emergency braking.
The operating system is the software layer that interfaces directly with computer hardware. It manages resources and provides the environment in which applications run.
Process scheduling
The OS decides which process gets CPU time using scheduling algorithms
First-Come First-Served (FCFS), Shortest Job First (SJF), Round-Robin (RR), and Multi-Level Feedback Queue (MLFQ) are the main algorithms to know
Preemptive scheduling allows the OS to interrupt a running process; non-preemptive scheduling lets it finish or yield voluntarily
Context switching: the OS saves the state of the current process and loads the state of the next one, which takes time
Memory management
Virtual memory maps each process's virtual address space to physical RAM using page tables
Paging divides memory into fixed-size blocks (pages); segmentation divides it by logical sections (code, stack, heap)
Page faults occur when a process accesses a page not currently in RAM; the OS loads it from disk
Replacement policies (LRU, FIFO, Clock) decide which page to evict when RAM is full
Filesystems
A filesystem organises data on storage devices into files and directories
Key concepts: inodes (metadata structures), journaling (crash recovery), file allocation methods (contiguous, linked, indexed)
POSIX file I/O: open, read, write, close, seek
Concurrency and synchronisation
Threads share a process's address space; processes have separate address spaces
Race conditions occur when multiple threads access shared data without proper synchronisation
Mutexes (mutual exclusion locks), semaphores, and condition variables are the standard synchronisation primitives
Deadlock: a set of threads each waiting for a resource held by another, so none can proceed. The four conditions: mutual exclusion, hold and wait, no preemption, circular wait
Systems programming projects
Writing a shell: teaches process creation (fork/exec), I/O redirection, piping, and signal handling
Building a memory allocator: teaches heap management, free lists, fragmentation, and malloc/free internals
Implementing a threads library: teaches context switching, scheduling, and synchronisation at the lowest level
Writing device drivers: teaches how the OS communicates with hardware peripherals through interrupt handlers and I/O ports
Languages and interfaces
Systems programming is done primarily in C and assembly
POSIX APIs provide a standard interface for processes, threads, file I/O, and inter-process communication (IPC)
Understanding pointers, manual memory management, and the C runtime is essential
Networking courses teach how data is transmitted between computers, whether across a room or across the globe.
TCP/IP architecture
The internet protocol stack is typically presented as four or five layers: application, transport, network, data link, (physical)
IP (Internet Protocol) handles addressing and routing packets; each device gets an IP address
TCP provides reliable, connection-oriented communication with error checking, retransmission, and flow control
UDP provides connectionless, best-effort delivery with lower overhead, used where speed matters more than reliability (video streaming, gaming)
Routing and switching
Switches operate at the data link layer (Layer 2), forwarding frames based on MAC addresses within a local network
Routers operate at the network layer (Layer 3), forwarding packets between different networks based on IP addresses
Routing protocols (OSPF, BGP) allow routers to discover and share information about network topology
Subnetting divides a large network into smaller, manageable segments
Network protocols
HTTP/HTTPS for web traffic, DNS for name resolution, DHCP for automatic IP address assignment, ARP for mapping IP to MAC addresses
The three-way handshake (SYN, SYN-ACK, ACK) establishes a TCP connection
TLS/SSL encrypts data in transit for secure communication
Wireless data transmission
Wi-Fi (IEEE 802.11 family) is the dominant wireless LAN standard
Wireless signals face challenges that wired connections do not: interference, attenuation, multipath fading, and shared medium access
Cellular networks (4G LTE, 5G) provide wide-area wireless connectivity
Network security fundamentals
Firewalls filter traffic based on rules (source/destination IP, port, protocol)
Encryption (symmetric and asymmetric) protects data confidentiality
Common threats: denial-of-service (DoS), man-in-the-middle (MITM), phishing, packet sniffing
Defence in depth: layered security controls, because no single measure is sufficient
Software is a large component of the CSE degree, even though the name emphasises engineering. Students take courses in algorithms, data structures, OOP, and design patterns alongside their hardware coursework.
Algorithms and data structures
Fundamental data structures: arrays, linked lists, stacks, queues, hash tables, trees (binary search trees, heaps), graphs
Sorting algorithms (merge sort, quicksort, heapsort) and searching algorithms (binary search, BFS, DFS) are core knowledge
Computational complexity: Big-O notation expresses how an algorithm's runtime or space usage scales with input size
Common complexity classes: O(1) constant, O(log n) logarithmic, O(n) linear, O(n log n) linearithmic, O(n squared) quadratic
Object-oriented programming (OOP)
Four pillars: encapsulation, abstraction, inheritance, polymorphism
Design patterns (e.g. Singleton, Observer, Factory, Strategy) provide reusable solutions to common software design problems
OOP is the dominant paradigm in large-scale systems; understanding it is essential for team-based development
Version control
Git is the standard tool; students should be comfortable with branching, merging, pull requests, and resolving conflicts
Version control enables team collaboration, tracks change history, and supports rollback
Testing and debugging
Unit tests verify individual functions or methods; integration tests verify that components work together
Test-driven development (TDD) writes tests before code
Debugging tools: breakpoints, step-through execution, memory analysers (e.g. Valgrind for C/C++)
Requirements analysis
Functional requirements define what the system should do; non-functional requirements define constraints (performance, security, scalability)
Gathering and documenting requirements before writing code reduces costly rework
Agile methodologies
Iterative development in short cycles (sprints), with regular feedback from stakeholders
Scrum and Kanban are the most common frameworks
Stand-ups, retrospectives, and sprint reviews are standard Agile ceremonies
Large-scale software design
Modular architecture: breaking systems into independent, loosely coupled components
API design, dependency management, and continuous integration/continuous deployment (CI/CD) pipelines
Understanding how to build large-scale software prepares graduates for team engineering environments
Real-time computing systems must guarantee response times for critical applications. Cyber-physical systems (CPS) merge computation with the physical world.
Real-time scheduling algorithms
Rate Monotonic Scheduling (RMS): assigns higher priority to tasks with shorter periods; optimal among fixed-priority algorithms for independent, periodic tasks
Earliest Deadline First (EDF): assigns priority based on which task's deadline is nearest; optimal among dynamic-priority algorithms
Schedulability analysis determines whether a set of tasks can meet all deadlines under a given algorithm
Hard vs. soft real-time
Hard real-time: every deadline must be met, or the system has failed (flight control, airbag deployment, pacemakers)
Soft real-time: occasional deadline misses degrade performance but are tolerable (video conferencing, media playback)
Firm real-time: a missed deadline makes the result worthless, but does not cause catastrophic failure
Safety-critical embedded systems
Systems where failure can cause injury or loss of life must meet rigorous certification standards
Redundancy, fault tolerance, and formal verification are common design strategies
Industries: automotive, aerospace, medical devices, nuclear
Automotive and computer vision hardware
ADAS features (lane-keeping, adaptive cruise control, emergency braking) rely on real-time processing of camera and sensor data
Autonomous vehicles push real-time requirements further, needing to process LiDAR, radar, and camera feeds simultaneously with sub-millisecond latency
Aerospace controls
Flight control systems are classic hard real-time applications
Fly-by-wire replaces mechanical linkages with electronic controls, placing strict demands on reliability and timing
Cyber-physical system projects
Self-driving cars, smart manufacturing systems, industrial IoT, autonomous drones
These projects integrate sensing, computation, networking, and actuation into a single system
Capstone design is the culmination of the CSE programme: students work in teams to design and build a complete system from the ground up.
Capstone project examples
Self-navigation robots
IoT monitoring devices
Heart-rate monitoring and embedded health systems
Smart home controller systems
Programmable LED dancers
Many students find job opportunities directly from their capstone projects
High-demand career fields (2025-2026)
Embedded software engineering
Robotics
Automotive computing (electric vehicles, ADAS, autonomous vehicles)
Aerospace and drone engineering
Defence and aerospace systems
Semiconductor and device engineering
Internet of Things (IoT)
Cybersecurity hardware integration
Why CSE graduates are sought after
CSE graduates can think across the full stack, from circuits to software
Companies such as Intel, Qualcomm, Google, and Tesla hire CSE majors because they understand both the hardware constraints and the software that runs on it
The ability to design reliable, efficient, and secure computing systems from the ground up is increasingly valuable as computing moves into cars, medical devices, satellites, and factory floors
Operating systems knowledge is essential for anyone writing performance-critical software or code that interacts directly with hardware: kernel developers, firmware engineers, and systems programmers all rely on it daily. Networking skills open doors to software engineering, systems administration, cloud infrastructure, and security roles. Software engineering and algorithm design are universal: every team-based engineering environment uses version control, testing, and modular design. Real-time and cyber-physical systems are the bridge to careers in automotive computing (Tesla's Autopilot, for instance), aerospace controls, and industrial automation, where the software you write has direct physical consequences.
Students often think virtual memory gives a process more RAM. It does not. Virtual memory provides the illusion of a large address space and allows the OS to use disk as overflow, but accessing pages on disk is orders of magnitude slower than accessing RAM. Virtual memory is about isolation and flexibility, not extra capacity.
Students sometimes assume that adding more threads always makes a programme faster. Beyond a point, adding threads increases contention for shared resources (locks, cache lines, memory bus), and the overhead of context switching and synchronisation can outweigh any parallelism gains.
Students frequently confuse routing and switching. Switches forward frames within a single network based on MAC addresses (Layer 2). Routers forward packets between networks based on IP addresses (Layer 3). They operate at different layers of the protocol stack.
Students sometimes think Agile means "no planning." Agile methodologies involve continuous planning in short cycles; the planning is iterative, not absent.
⚠️ Process scheduling algorithms (FCFS, SJF, RR, MLFQ) are a staple exam topic. Be able to calculate average waiting time and turnaround time for a given set of processes.
⚠️ Deadlock conditions and prevention strategies are commonly tested. Know the four necessary conditions (mutual exclusion, hold and wait, no preemption, circular wait) and how breaking any one prevents deadlock.
⚠️ Page replacement algorithms (LRU, FIFO, Optimal) and page fault calculations appear on most OS exams.
⚠️ The TCP three-way handshake (SYN, SYN-ACK, ACK) is a standard networking exam question. Know it step by step.
⚠️ Big-O complexity analysis is tested across multiple courses. Be able to determine the time complexity of nested loops, recursive functions, and common sorting algorithms.
⚠️ Rate Monotonic vs. Earliest Deadline First scheduling: know when each is optimal and how to run a basic schedulability test.
True or false: A mutex allows multiple threads to access a shared resource simultaneously.
Answer: False. A mutex provides mutual exclusion; only one thread can hold the lock at a time.
Fill in the blank: TCP uses a ______-way handshake to establish a connection.
Answer: three.
True or false: Routers operate at Layer 2 (data link layer) of the protocol stack.
Answer: False. Routers operate at Layer 3 (network layer). Switches operate at Layer 2.
Fill in the blank: In Big-O notation, the time complexity of binary search is O(______).
Answer: log n.
True or false: In a soft real-time system, missing a deadline means the system has failed.
Answer: False. Soft real-time systems tolerate occasional deadline misses with degraded quality, not system failure.
Q: Explain the four necessary conditions for deadlock and describe one strategy for preventing it.
A: The four conditions are mutual exclusion (a resource can only be held by one thread), hold and wait (a thread holds one resource while waiting for another), no preemption (resources cannot be forcibly taken from a thread), and circular wait (a cycle of threads each waiting for a resource held by the next). Breaking circular wait, for example by imposing a global ordering on resource acquisition, prevents deadlock.
Q: Compare TCP and UDP. When would you choose one over the other?
A: TCP is connection-oriented and provides reliable, ordered delivery with error checking and retransmission. UDP is connectionless and provides best-effort delivery with lower overhead. Choose TCP when data integrity and order matter (file transfer, web browsing). Choose UDP when low latency matters more than perfect delivery (live video, online gaming, DNS lookups).
Q: What is the difference between virtual memory and physical memory?
A: Physical memory is the actual RAM installed in the machine. Virtual memory is an abstraction that gives each process its own address space, mapped to physical RAM (and potentially disk) by the OS via page tables. This provides isolation between processes and allows the system to run programmes whose combined memory needs exceed physical RAM.
Q: Describe Rate Monotonic Scheduling and state when it is optimal.
A: RMS assigns fixed priorities based on period: the shorter the period, the higher the priority. It is optimal among fixed-priority scheduling algorithms for a set of independent, periodic tasks with deadlines equal to their periods. The utilisation bound for RMS with n tasks is n(2 to the power of 1/n minus 1), which approaches about 69% as n grows.
Q: Name three high-demand career fields for CSE graduates and explain why CSE training is relevant to each.
A: Embedded software engineering (CSE graduates understand both the hardware and the software that runs on constrained devices), automotive computing (self-driving cars and ADAS require real-time, safety-critical software integrated with sensors and actuators), and semiconductor/device engineering (CSE graduates understand processor architecture, HDLs, and the physical electronics underlying chip design).
Operating systems connect directly to the hardware foundations in Part 1: process scheduling depends on how the CPU pipeline and interrupts work, and memory management relies on the memory hierarchy (caches, DRAM, virtual memory hardware). Networking ties into both OS knowledge (socket programming, kernel-level packet handling) and security (encryption, authentication). Software engineering practices apply across every domain in CSE, from writing embedded firmware to building web-facing applications. Real-time and cyber-physical systems bring together embedded systems, control theory, and networking into a single design challenge.
operating system, OS, process scheduling, FCFS, SJF, round-robin, MLFQ, context switch, virtual memory, paging, page table, page fault, page replacement, LRU, FIFO, filesystem, inode, journaling, POSIX, concurrency, thread, mutex, semaphore, condition variable, deadlock, race condition, synchronisation, shell, memory allocator, malloc, free, device driver, C programming, assembly, systems programming, TCP, UDP, IP, TCP/IP, three-way handshake, routing, switching, MAC address, IP address, OSPF, BGP, subnetting, DNS, DHCP, HTTP, HTTPS, TLS, SSL, Wi-Fi, 802.11, firewall, DoS, MITM, encryption, algorithms, data structures, Big-O, sorting, binary search, BFS, DFS, OOP, object-oriented programming, encapsulation, inheritance, polymorphism, design patterns, version control, Git, testing, TDD, Agile, Scrum, Kanban, CI/CD, real-time systems, RMS, rate monotonic scheduling, EDF, earliest deadline first, hard real-time, soft real-time, safety-critical, ADAS, autonomous vehicles, cyber-physical systems, CPS, IoT, Internet of Things, capstone project, embedded software engineering, robotics, aerospace, semiconductor, device engineering, cybersecurity, ASU, Arizona State University, computer systems engineering, CSE