CCIT4026 - Introduction to Computer Organization

HKU SPACE Community College

📚 OVERVIEW

This repository contains comprehensive teaching materials for Introduction to Computer Organization (CCIT4026). The materials cover all aspects of teaching MIPS assembly programming and computer organization fundamentals, from basic concepts to advanced topics.

📁 MATERIALS INCLUDED

Individual Chapter Files (NEW!)

For easier navigation and focused study, the comprehensive teaching material has been split into 5 individual chapter files:

  1. Chapter1_Introduction.md - Computer Organization fundamentals, number systems, performance metrics
  2. Chapter2_Instruction_Set_Design_Part1.md - MIPS architecture, registers, basic instructions
  3. Chapter3_Instruction_Set_Design_Part2.md - Control flow, loops, multiplication/division
  4. Chapter4_Instruction_Set_Design_Part3.md - Functions, stack, recursion, arrays
  5. Chapter5_Instruction_Set_Design_Part4.md - I/O operations, strings, advanced topics

1. Comprehensive_Teaching_Material.md (200+ pages)

The complete teaching guide covering all course content in one document.

Contents: - Chapter 1: Introduction to Computer Organization - Chapter 2: Instruction Set Design (Part 1) - Basic MIPS Instructions - Chapter 3: Instruction Set Design (Part 2) - Control Flow - Chapter 4: Instruction Set Design (Part 3) - Functions and Stack - Chapter 5: Instruction Set Design (Part 4) - I/O and Advanced Topics - Laboratory Work Guidelines - Teaching Strategies - Assessment Methods

Use this for: - Preparing detailed lectures - Understanding course progression - Reference for teaching techniques - Creating custom presentations

2. Course_Syllabus.md

Official course syllabus document with all administrative details.

Contents: - Course description and learning outcomes - Week-by-week schedule - Assessment breakdown and grading - Course policies - Important dates - Contact information

Use this for: - First day of class handout - Course planning - Setting student expectations - Administrative reference

3. Quick_Reference_Guide.md

Concise reference card for MIPS assembly programming.

Contents: - Register quick reference - All MIPS instructions - Syscall services - Program templates - Common patterns - Memory map - Debugging checklist

Use this for: - Student handout - Exam reference sheet - Quick lookup during labs - Posting in classroom

4. Practice_Problems_with_Solutions.md

Extensive problem set with detailed solutions.

Contents: - 30+ problems covering all chapters - Step-by-step solutions - Multiple difficulty levels - Complete working programs - Explanation of approaches

Use this for: - Homework assignments - Exam preparation - Lab exercises - Self-study materials

🎯 COURSE STRUCTURE

Course Information

  • Course Code: CCIT4026
  • Credits: 3
  • Format: 2 hours lecture + 2 hours lab per week
  • Duration: 15 weeks
  • Prerequisites: Basic programming knowledge

Learning Path

Week 1-2:  Introduction & Fundamentals
           ↓
Week 3-4:  Basic MIPS Instructions
           ↓
Week 5-7:  Control Flow & Loops
           ↓
Week 8:    Midterm Exam
           ↓
Week 9-10: Functions & Recursion
           ↓
Week 11-13: I/O & Advanced Topics
           ↓
Week 14:   Project Due
           ↓
Week 15:   Final Exam

🛠️ REQUIRED TOOLS

Software

  1. MARS (MIPS Assembler and Runtime Simulator) - Download: http://courses.missouristate.edu/KenVollmar/MARS/ - Version: 4.5 or higher - Requires: Java Runtime Environment (JRE) 8+

  2. Text Editor (Optional but recommended) - VS Code with MIPS syntax extension - Sublime Text - Notepad++

Hardware

  • Any computer capable of running Java
  • Minimum 4GB RAM recommended
  • 500MB free disk space

📖 HOW TO USE THESE MATERIALS

For Instructors

First-Time Course Setup

  1. Read Comprehensive_Teaching_Material.md completely
  2. Customize Course_Syllabus.md with your details
  3. Print Quick_Reference_Guide.md as handouts
  4. Review Practice_Problems_with_Solutions.md
  5. Install and test MARS simulator

Weekly Preparation

  1. Review relevant chapter in teaching material
  2. Prepare slides/demonstrations from content
  3. Select practice problems for homework
  4. Test all code examples in MARS
  5. Prepare lab exercises

During Class

  • Use teaching material as lecture notes
  • Demonstrate all code in MARS
  • Use quick reference for student questions
  • Assign problems from practice set

Assessment Creation

  • Use practice problems as templates
  • Create variations of existing problems
  • Test all solutions before assigning
  • Provide rubrics from teaching material

For Students

Self-Study Path

  1. Start with syllabus to understand expectations
  2. Read one chapter at a time in teaching material
  3. Try examples in MARS as you read
  4. Keep quick reference handy
  5. Complete practice problems
  6. Check solutions after attempting

Exam Preparation

  1. Review quick reference guide
  2. Redo all practice problems
  3. Create own reference card
  4. Practice timing on sample problems
  5. Test code in MARS

Lab Work

  1. Read lab instructions carefully
  2. Use program template from quick reference
  3. Test incrementally
  4. Comment your code
  5. Follow submission guidelines

📚 TEACHING PHILOSOPHY

Core Principles

  1. Progressive Complexity - Start simple, add layers gradually - Build on previous knowledge - Provide scaffolding, then remove it

  2. Hands-On Learning - Every concept has code example - Students write code, not just read - Immediate feedback through MARS

  3. Real-World Connection - Relate to high-level languages - Show practical applications - Explain "why" not just "how"

  4. Active Engagement - Think-pair-share exercises - Live coding demonstrations - Peer programming in labs

🎓 ASSESSMENT STRUCTURE

Grade Distribution

Component Weight Description
Labs 40% Weekly programming assignments
Quizzes 20% Regular knowledge checks
Midterm 20% Chapters 1-3
Final 20% Comprehensive

Lab Grading Criteria

  • Functionality (50%): Does it work correctly?
  • Code Quality (20%): Comments, formatting, style
  • Documentation (30%): Lab report completeness

💡 TEACHING TIPS

Effective Lecture Techniques

  • Start with analogies: House = computer, rooms = memory
  • Use visualizations: Draw memory maps, register usage
  • Live code: Write programs during lecture
  • Make mistakes: Show debugging process
  • Check understanding: Frequent questions

Lab Success Strategies

  • Structure labs: Mini-lecture → Demo → Guided practice → Independent work
  • Circulate frequently: Help students get unstuck
  • Common errors: Keep list of frequent mistakes
  • Peer helping: Encourage students to help each other
  • Time management: Ensure most finish during lab time

Common Student Challenges

  1. Register confusion: Use visual aids, posters
  2. Stack operations: Physical demonstration helps
  3. Recursion: Trace on board step-by-step
  4. Debugging: Teach systematic approach
  5. Syntax errors: Provide checklist

📋 LABORATORY ASSIGNMENTS

Lab Schedule

Lab Week Topic Graded?
Lab 1 2 MARS Setup & Hello World No
Lab 2 4 User Input/Output Yes
Lab 3 5 Arithmetic Operations No
Lab 4 6 Loops and Arrays No
Lab 5 8 Array Processing Yes
Lab 6 9 Functions Yes
Lab 7 10 Recursion No
Lab 8 11 String Processing No
Lab 9 12-13 Final Project Yes

Submission Requirements

  • Assembly source code (.asm)
  • PDF lab report with:
  • Student information and ID photo
  • Colored source code screenshots
  • Assembled machine code
  • Program output
  • Brief explanation (graded labs only)

🔧 TROUBLESHOOTING

Common MARS Issues

Problem: "Exception occurred at PC=..." - Solution: Check array bounds, verify addresses

Problem: "Invalid instruction" - Solution: Check spelling, verify instruction exists

Problem: Infinite loop - Solution: Verify loop condition, check counter updates

Problem: Wrong results - Solution: Single-step through code, check register values

Getting Help

  • Use MARS debugger (F7 to step)
  • Print intermediate values
  • Check register window
  • Review quick reference
  • Ask instructor or TA

📞 SUPPORT

For Instructors

  • Review teaching material thoroughly
  • Join computer organization teaching communities
  • Share experiences with other instructors
  • Continuously update examples

For Students

  • Attend all lectures and labs
  • Start assignments early
  • Use office hours
  • Form study groups
  • Practice regularly

🔄 UPDATES AND MAINTENANCE

Version History

  • v1.0 (February 2026): Initial release
  • Complete teaching material
  • Course syllabus
  • Quick reference guide
  • Practice problems with solutions

Future Enhancements

  • Additional practice problems
  • Video demonstrations
  • Interactive quizzes
  • Online judge system
  • More lab exercises

📜 LICENSE AND USAGE

Academic Use

These materials are designed for educational purposes: - ✅ Use in classroom teaching - ✅ Modify for your course needs - ✅ Share with students - ✅ Adapt to different contexts

Please:

  • Acknowledge source if sharing publicly
  • Report errors or improvements
  • Share your successful teaching strategies
  • Contribute additional problems or examples

🤝 CONTRIBUTING

How to Improve These Materials

  1. Report Issues - Unclear explanations - Code errors - Missing topics

  2. Suggest Enhancements - Additional examples - Better explanations - New practice problems

  3. Share Success Stories - What worked well - Student feedback - Innovative teaching methods

📚 ADDITIONAL RESOURCES

  1. Patterson & Hennessy: "Computer Organization and Design"
  2. Britton: "MIPS Assembly Language Programming"
  3. Bryant & O'Hallaron: "Computer Systems: A Programmer's Perspective"

Online Resources

  • MIPS Reference: Official documentation
  • MARS Wiki: Tutorials and guides
  • YouTube: MIPS tutorial videos
  • Stack Overflow: Programming help

Communities

  • Computer Architecture educators forums
  • SIGCSE (CS Education)
  • Local CS teacher groups

✅ QUICK START CHECKLIST

Instructor Setup

  • [ ] Install MARS simulator
  • [ ] Test all example programs
  • [ ] Customize syllabus
  • [ ] Print quick reference guides
  • [ ] Set up course website/SOUL
  • [ ] Prepare first lecture
  • [ ] Create lab schedule

Student Setup

  • [ ] Install MARS
  • [ ] Download course materials
  • [ ] Read syllabus
  • [ ] Test "Hello World" program
  • [ ] Print quick reference
  • [ ] Join course discussion forum
  • [ ] Note important dates

📞 CONTACT

Course Materials Questions

For questions about these materials: - Review teaching material first - Check practice problems - Consult quick reference

Technical Support

  • MARS issues: See MARS documentation
  • Java issues: Update JRE
  • Lab submission: Follow guidelines in syllabus

🎯 LEARNING OUTCOMES

By the end of this course, students will:

✅ Understand computer organization fundamentals
✅ Write MIPS assembly programs confidently
✅ Translate high-level code to assembly
✅ Implement functions with proper conventions
✅ Debug assembly programs effectively
✅ Understand hardware-software relationship
✅ Optimize code for performance
✅ Apply knowledge to other architectures

🌟 SUCCESS METRICS

For Students

  • Complete all labs on time
  • Pass all quizzes
  • Achieve desired grade
  • Understand low-level computing
  • Build foundation for advanced courses

For Instructors

  • High student engagement
  • Good exam performance
  • Positive course evaluations
  • Students prepared for advanced courses
  • Effective knowledge transfer

📖 DOCUMENT ORGANIZATION

Computer_Organization/
│
├── README.md (this file)
│   └── Overview and usage guide
│
├── Comprehensive_Teaching_Material.md
│   └── Complete course content (200+ pages)
│
├── Chapter1_Introduction.md
│   └── Computer fundamentals, number systems, performance
│
├── Chapter2_Instruction_Set_Design_Part1.md
│   └── MIPS basics, registers, instructions, formats
│
├── Chapter3_Instruction_Set_Design_Part2.md
│   └── Control flow, loops, multiplication, addressing
│
├── Chapter4_Instruction_Set_Design_Part3.md
│   └── Functions, stack, recursion, arrays, structures
│
├── Chapter5_Instruction_Set_Design_Part4.md
│   └── I/O, syscalls, strings, floating-point, advanced
│
├── Course_Syllabus.md
│   └── Administrative details and schedule
│
├── Quick_Reference_Guide.md
│   └── MIPS instruction reference card
│
├── Practice_Problems_with_Solutions.md
│   └── 30+ problems with detailed solutions
│
└── Original PDF files/
    ├── chp1_ICO_eddieY.pdf
    ├── chp2_ICO_eddieY.pdf
    ├── chp3_ICO_eddoeY.pdf
    ├── chp4_ICO_eddieY.pdf
    ├── chp5_ICO_eddieY.pdf
    └── co_Lab02_wf ay2526_mon.pdf

🚀 GETTING STARTED NOW

Immediate Actions

If you're an instructor starting next week: 1. Read Comprehensive_Teaching_Material.md (Chapters 1-2) 2. Install and test MARS 3. Prepare Week 1 lecture on computer fundamentals 4. Print Quick_Reference_Guide.md for students 5. Set up lab environment

If you're a student starting to learn: 1. Install MARS simulator 2. Read Chapter 1 in Comprehensive_Teaching_Material.md 3. Try the "Hello World" example 4. Keep Quick_Reference_Guide.md open 5. Attempt Problem 2.1 from Practice Problems

If you're preparing for an exam: 1. Review Quick_Reference_Guide.md 2. Redo all assigned practice problems 3. Create your own summary notes 4. Time yourself on sample problems 5. Test everything in MARS

💬 FEEDBACK

Your feedback helps improve these materials!

What's working well? What could be better? What's missing? Suggestions for improvement?

🎉 ACKNOWLEDGMENTS

These materials are based on: - Standard MIPS architecture documentation - Years of teaching computer organization - Student feedback and learning patterns - Best practices in CS education - Industry-standard assembly programming techniques

⚡ FINAL NOTES

Remember

  • Practice is key: Write code, don't just read
  • Understand concepts: Don't memorize instructions
  • Ask questions: No question is too basic
  • Help others: Teaching reinforces learning
  • Be patient: Assembly takes time to master
  • Have fun: Low-level programming is powerful!

Success Formula

Practice + Understanding + Persistence = Mastery

Ready to teach or learn Computer Organization?

Start with: Comprehensive_Teaching_Material.md → Chapter 1

These materials were created in February 2026 to provide comprehensive support for teaching Introduction to Computer Organization (CCIT4026) at HKU SPACE Community College.

Good luck with your teaching or learning journey! 🚀

END OF README