联系我们： 手动添加方式: 微信>添加朋友>企业微信联系人>13262280223 或者 QQ: 1483266981

Project Guidelines: CS171 Project – 2025/2026
Module: CS171 – Computer Systems
Project: Individual Coding and Research Project
Archived Content Due: Friday 16th January 14:00
Project Demo: Before or on Week 19. Thursday 15th January. 14:00 – 17:00
Objectives:
This project is designed to teach key Computer Systems concepts through hands-on
application, emphasising the interplay between software, hardware, and operating
systems. By researching, designing, and implementing a Processing-based program,
you’ll develop skills in independent problem-solving, debugging, and critical
reflection—essential for understanding system-level interactions like memory
management, input/output handling, and resource allocation. To enhance delivery, the
project incorporates guided milestones during lab sessions, where tutors provide
feedback on your progress and conceptual ties to lectures (e.g., how your code
abstracts hardware primitives). For assessment, we’ve added elements to ensure
genuine learning and discourage reliance on generative AI, such as personalised
components, process artifacts, and conceptual explanations.
Introduction:
Applying programming skills to a self-designed project mirrors real-world system
development. In Computer Systems, this means not just coding but understanding how
your program interfaces with underlying hardware. Projects like this prepare you for
tasks that come later in the degree and post-graduate tasks. Choose a topic that sparks
your interest, work individually, but discuss ideas in labs or forums.
Description:
Research a Computer Systems idea, implement it in Processing, and test it thoroughly.
Examples include games, simulations, or tools (see suggestions below). Demonstrate
original code while linking to Computer Systems themes, such as efficiency in loops
(relating to CPU cycles) or graphics rendering (frame buffers). Use libraries where
needed, but (e.g. how OpenCV interfaces with camera hardware).
Personalisation: Incorporate your student ID into the code (e.g. as a seed for
random elements or a unique identifier in outputs). Reference your hardware
setup (e.g. OS version, Graphics cards, screen resolution) in behaviour or
comments.
Process Evidence: Document your development journey to show iterative,
human-driven work.
Variability: Introduce edge cases or randomised tests based on your system
time/date.
Constraints:
Must be individual work; plagiarism checks will include AI-detection tools.
Use Processing; include at least 50% original code (e.g., custom functions).
Acknowledge all external code/libraries with in-code comments and citations
(e.g., // Adapted from [Source], modified for [Your Change]).
No direct AI-generated code; submissions must include evidence of manual
creation (e.g. hand-drawn pseudocode).
Run on your personal hardware; note any system-specific adaptations.
Submission:
Upload a single ZIP file via Moodle containing:
1. Processing Project: Full sketch folder (code, data files).
2. Report Document: Word/PDF, 4-8 pages, structured as below. Include your
student ID on every page.
3. Artifacts Folder: Screenshots, videos, diagrams (detailed below).
Report Structure
Title: [Your Project Title, e.g., “Personalised Battleships Game with Hardware Tied Randomisation”]
Name, Date, Student Number:
Introduction: Outline aims, theoretical foundations (e.g., linking to binary
representations or event loops from lectures), libraries used, and why it interests
you. Explain how it demonstrates Computer Systems concepts (e.g., “This game
simulates network I/O, relating to OS socket handling”). (1/2-1 page)
Specification: Describe functionality, expected behaviour, hardware
requirements (include your specs), and special features (e.g., “Adapts to screen
resolution [Your Resolution] for pixel-perfect rendering”). Include a hand-drawn
UML diagram or flowchart of system architecture. (1 page)
Overview of the Code: High-level description (not line-by-line). Explain key
components, interactions, and original contributions. Include code snippets
with comments. Discuss system ties (e.g., “Loop efficiency optimises CPU
usage, avoiding bottlenecks”). (1 page)
Development Process: Detail iterations with timestamps (e.g., “Week 3: Initial
sketch failed due to [Error]; fixed by [Your Solution]”). Include 3-5 screenshots of
evolving IDE sessions (with console logs showing errors/fixes) and a short video
(1-2 minutes) of you coding/debugging in real-time, narrating decisions. (1 page)
Testing: Screenshots/figures of runs on your hardware, including edge cases
(e.g., low memory simulation). Provide test plans with inputs/outputs,
incorporating randomness seeded by your student ID + current timestamp. Label
all (e.g. Figure 1: Output at Frame 100 on [Your OS]). (1-2 pages)
Reflection and Conclusion: Reiterate achievements, challenges overcome
(e.g., “Debugging graphics lag taught me about GPU synchronization”), future
extensions, and lessons on Computer Systems (e.g., “This highlights how
Processing abstracts low-level memory access”). 500-750 words; reference
lectures. (1 page)
Start early—use labs for milestone checks (e.g., Week 8: Share initial idea; Week 11:
Demo prototype).
Some Project Suggestions: [simplified requirements, extended discussion/testing
options]
These are starting points; add a personal touch and link to Computer Systems.
Research libraries (e.g. via processing.org; contributed ones like OpenCV for vision,
BlobDetection for image analysis, QRCode generators from forums, Jasmine for fast
algorithm evaluation, Video for media handling). Explain installation and system
integration in your report.
1. Battleships: 8×8 grid game; personalize ship positions with your student ID
modulo 64. Test network latency on your machine. Link to systems: Discuss grid
as memory array.
2. Network Battleships: Multiplayer over network; require local testing with
loopback. Reflect on socket programming vs. OS networking stacks.
3. Quadratic Solver: Plot roots; use your birthdate for example equations. Hand draw root derivations. Tie to floating-point hardware.
4. Image Tracer: Draw over loaded images; add filter based on your webcam input
if using OpenCV.
5. Particle Simulation: Measure “pressure”; adjust for your CPU cores. Explain
multithreading potential.
6. Crossword Helper: Use word list; search patterns including your name. Discuss
string processing efficiency.
7. Piano Keyboard: Play/save tunes; integrate sound library. Test on your audio
hardware.
8. Base Converter: Decimal to Hex/Binary; visualise bit representations.
9. Classic Game Recreation: E.g., Snake; add pause on low FPS, logging system
performance.
10. Loan Calculator: Interactive; plot repayments. Link to numerical stability in
computations.
11.Central Limit Theorem Demo: Simulate dice; vary based on your random seed.
Explain randomness in hardware.
12. Fractal Generator: E.g., Mandelbrot; zoom tied to mouse DPI.
13.Space-Filling Curve: E.g., Hilbert; animate drawing.
14.Conway’s Game of Life: Cellular automaton; optimise for your RAM.
15. Travelling Salesman Problem Solver: Visualize paths; discuss algorithmic
complexity vs. CPU time.
16.Random Number Algorithms: Implement/test generators; compare to hardware
RNG.
17.NIM Game: With strategy; AI opponent using minimax.
18. Towers of Hanoi: Simulate/solve; recursive depth limited by your stack size.
19.Road Plotter: From OpenStreetMap CSV; plot in Processing.
20.Card Deck Simulator: Draw cards; shuffle analysis.
21.Magic Square Noughts and Crosses: Predict moves.
22.Pendulum Simulation: Physics model; tie to timing interrupts.
23.Supermarket Queue Simulator: Random arrivals; optimise for your simulations
speed.
24.Genome Compressor: Encode/decode; discuss bit-packing.
25.Steganography Tool: Hide messages; use image pixels.
26.Sudoku Solver: Backtracking; efficiency reflection.
27. Text Comparator: Substring differences; for code versioning.
28.Book Cover Generator: Procedural art; personalise with your inputs.
29.Distribution Visualiser: Stats plots; user parameters.
30.Pascal’s Triangle: Draw for n; combinatorial links.
31.Infinite Monkey Theorem: Generate text matching Shakespeare excerpt; time
runs on your hardware.
Assessment Rubric (out of 100): Marks only awarded after successful
demonstration
Category Weight Criteria
Originality &
Functionality
30
Code runs, includes personal elements (e.g., ID
seeding), 50%+ original. Ties to suggestions with
unique aspects. Originality
Conceptual Ties to
Computer Systems
25
Explains hardware/OS interactions (e.g., memory,
I/O); depth in reflection.
Process & Artifacts 20
Complete evidence (videos, diagrams, logs); shows
human iteration/debugging.
Testing &
Documentation
15 Thorough tests, screenshots; clear, labelled report.
Reflection &
Presentation
10 Insightful conclusion; professional structure.