Note: All lecture materials are moved to LMS of Dankook University.
https://nlms.dankook.ac.kr
Computer Architecture and Mobile Processor + Advanced Mobile Project 1 (3rd yr/Spring)
Overview.
Computer Organization and Mobile Processors is a hardware-oriented course that explains how modern computers — especially mobile and embedded systems — are organized and how they execute programs. We study processors, memory, storage, and I/O devices from a system designer’s point of view, with a focus on performance and correctness. The goal is to build a clear mental model of what really happens between a high‑level program and the underlying hardware.
Main topics.
The course uses a MIPS-like processor as a running example. We begin with instruction set architecture (instruction encoding, data formats, addressing modes, procedure calls, control flow) and then design the processor datapath and control. Students learn how a single‑cycle CPU works, how a classic 5‑stage pipeline is built, and how to handle pipeline hazards, stalls, forwarding, branches, and precise exceptions. We also cover memory hierarchy and cache design (locality, write policies, associativity, multi‑level caches), basic computer arithmetic (integer and floating point), and an introduction to multicore, SIMD, and multiprocessor systems.
Projects and preparation.
A key feature of the course is hands‑on implementation in C on a Linux environment. Students incrementally develop (1) a simple calculator with their own ISA, (2) a single‑cycle CPU, (3) a pipelined CPU, and (4) a small microprocessor with cache support, and are evaluated mainly on these implementations. The course assumes basic C/assembly skills and prior exposure to data structures and system programming, and is tightly coupled with Advanced Mobile Project 1, where students apply architectural concepts to more open‑ended mobile system projects.
Operating Systems + Advanced Mobile Project2 (3rd yr/Fall)
Overview
Operating Systems introduces the core concepts that make modern computers usable, from smartphones to large-scale cloud servers. The course looks behind the application programming interface (API) to explain how the OS manages processes, memory, storage, and I/O devices while providing performance, protection, and isolation. The emphasis is on general principles that apply across Linux, mobile operating systems, and distributed systems.
Key Topics
We begin with the structure and history of operating systems and basic system call interfaces. Then we study processes and inter-process communication (IPC) (System V IPC and sockets), threads and concurrency, and core synchronization primitives such as locks, semaphores, monitors, and spinlocks. Next, we cover CPU scheduling (time-sharing, round-robin, multi-level queues, multiprocessor and virtual CPU scheduling), virtual memory (paging, segmentation, kernel allocators, demand paging, copy-on-write), and storage & file systems (disk structure, I/O scheduling, inode-based file systems). In the later part of the course, we connect OS concepts to key-value stores and LSM-tree–based storage and introduce distributed systems and cloud computing topics such as two-phase commit, fault tolerance, and recovery.
Labs, Co-requisite, and Outcomes
This is an English-taught, programming-intensive course that assumes solid C/assembly skills and prior background in data structures and computer architecture. Students implement several programming assignments and three main projects (e.g., a CPU scheduling simulator, a virtual memory simulator, and a simple file system simulator) on Linux, using git for all submissions. The course is tightly coupled with Advanced Mobile Project 2, which provides additional lab work and co-evaluation of OS-related projects. By the end of the course, students gain a practical understanding of how the OS behaves “behind the curtain” and develop the ability to reason about the performance, correctness, and robustness of real-world system software.
Systems Programming (2nd yr/Fall)
Overview
System Programming is an introductory course that sits between application-level programming and computer architecture. Starting from basic C programming, the course gently breaks common abstractions and shows how programs actually run on real machines. We study how a computer system is organized, how binaries are generated and executed, and what it really means for software to “run” on a CPU, memory, and storage devices.
Key Topics
We begin with the organization of computing systems: application software vs. system software, binary representation, addresses, and numeric formats (hex/binary/decimal). Then we move down to hardware-level concepts such as CPU, registers, memory, the program counter, and stack frames, and see how high-level code maps to low-level execution. Students learn how text is translated to binary through compilation and linking, what happens on the stack and heap, and how to write simple programs in MIPS assembly (arithmetic operations, function calls, stack traces, pointers, and structures). In the second half, the course broadens into computational thinking: treating the computer as a state machine or Turing machine, designing procedures and recursive solutions for small computational problems (e.g., Tower of Hanoi, coin counting, rational arithmetic, sets and ordered sets), and experiencing another paradigm via Racket programming.
Labs, Prerequisites, and Outcomes
The class combines lectures with hands-on labs, following the spirit of Computer Systems: A Programmer’s Perspective. Students are expected to already know basic C programming. During the semester, they practice low-level reasoning with MIPS assembly (mid-term focus) and higher-level problem solving with Racket (final exam focus), plus a small term project and in-class exercises. By the end of the course, students gain a concrete understanding of how code relates to the underlying machine, what system software does at the hardware–software boundary, and what kinds of problems computers can or cannot solve—forming a foundation for the follow-up course Computer Architecture and Mobile Processor and later systems courses.
Mobile Systems Programming (4th yr/Spring)
Overview
Mobile Systems Programming focuses on how software on mobile devices is built, deployed, and connected all the way down to the operating system and hardware. Rather than treating Android as a black box, the course looks inside the mobile stack: from bootloader and Linux kernel to the Android framework and user applications. We discuss the unique challenges of mobile environments—limited CPU, memory, and battery, constant network connectivity, and highly interactive user interfaces—and how these constraints shape system design and programming practices.
Key Topics
The course starts with an introduction to Android and recent trends from sources such as Google I/O, covering Android’s overall anatomy and application framework. We then review operating system concepts in the context of real mobile systems and move into the low-level platform: bootloader, kernel, and file system. Students learn how to configure, compile, and run a custom Linux/Android kernel, explore kernel modules and device drivers, and understand the hardware abstraction layer (HAL) that bridges devices and higher-level software. In the upper layers, we study how Java and native code are integrated through the Java Native Interface (JNI), and how data and control flow across the entire stack—from hardware and drivers, through the Android runtime, up to applications.
Projects, Prerequisites, and Outcomes
This is a project‑driven, English‑taught course that assumes prior knowledge of Operating Systems and either mobile programming or Java programming. A central component is a semester‑long Android project in which students set their own goals, work with real Android source code, and build applications or services that interact with customized kernels and user-interaction hardware. Evaluation is based on a written midterm, project work and documentation, attendance, and in‑class participation or presentations. By the end of the course, students gain practical experience in end‑to‑end mobile stack development and a solid understanding of how hardware, kernel, Android framework, and apps are connected in modern mobile systems.