Courses

Course

CS1: Higher Computing

University of New South Wales

CS1: Higher Computing at UNSW is designed as an introductory course for aspiring computer scientists and engineers. The course encompasses three main strands:

  • Programming:
    • Small scale programming in the first half.
    • Team-based software development in the second half.
  • Systems: Understanding how computers function, focusing on:
    • Microprocessors
    • Memory
    • Machine code
  • Computer Science Literacy: General computer science principles.

The course modules include hands-on programming experiences in C, exploring machine code, and discussions on clarity and problem-solving strategies. Students will engage with practical projects, including creating a simple C program and understanding function mechanics, all while fostering teamwork and collaboration.

Course Lectures
  • Higher Computing - Richard Buckland UNSW 2008
    Higher Computing - Richard Buckland UNSW 2008
    Richard Buckland
    Play

    This module features Richard Buckland teaching the Higher Computing course at UNSW. It introduces the foundational aspects of computer science, including programming, systems, and essential computer literacy skills. Students will learn about programming fundamentals and how to work effectively in teams. The course emphasizes understanding how computers operate at a fundamental level.

  • Inside a Computer - Richard Buckland UNSW
    Inside a Computer - Richard Buckland UNSW
    Richard Buckland
    Play

    This module offers an overview of the computing landscape as presented by Richard Buckland. It encompasses key concepts such as:

    • The essence of computing for first-year students.
    • Basic C programming examples.
    • Understanding core components of a computer, including transistors and microprocessors.
    • An introduction to the homemade 4917 microprocessor.

    Students will also engage with practical experimentation to enhance their learning experience.

  • Machine Code - Richard Buckland UNSW
    Machine Code - Richard Buckland UNSW
    Richard Buckland
    Play

    This module delves into machine code programming, where students will:

    • Review the function of transistors as switches.
    • Learn how to program the basic 4-bit microprocessor using the 4917 machine code.
    • Utilize the 4917 emulator for hands-on practice.

    Through practical exercises, participants will gain a deeper understanding of low-level programming and how it interacts with hardware.

  • Simple C Program - Richard Buckland UNSW
    Simple C Program - Richard Buckland UNSW
    Richard Buckland
    Play

    In this session, Richard Buckland introduces the foundational elements of a simple C program. Key topics include:

    • The structure of C programming.
    • Utilizing the gcc compiler.
    • Implementing basic input/output functions, such as printf and scanf.
    • Understanding comments, data types, and program clarity.

    Students will learn best practices in programming style and how to write clear and maintainable code.

  • Clarity (C programming #2) - Richard Buckland UNSW
    Clarity (C programming #2) - Richard Buckland UNSW
    Richard Buckland
    Play

    This module focuses on enhancing code clarity and style in C programming. Richard Buckland discusses:

    • The difference between hackers and elite programmers.
    • Simple programming techniques and avoiding side effects.
    • Understanding compiler options and common errors like segmentation faults.
    • Strategies for adhering to programming specifications.

    This session aims to improve students' coding practices and their ability to troubleshoot issues effectively.

  • Solving Problems - Richard Buckland UNSW 2008
    Solving Problems - Richard Buckland UNSW 2008
    Richard Buckland
    Play

    This module centers on problem-solving strategies in programming. Richard Buckland discusses:

    • The importance of testing during development.
    • Top-down problem-solving approaches.
    • How to initiate a problem-solving process.
    • Concepts like magic numbers and style in programming.

    Students will explore how to maintain motivation and cope with challenges in software development.

  • Side Effects - Richard Buckland UNSW 2008
    Side Effects - Richard Buckland UNSW 2008
    Richard Buckland
    Play

    This session discusses the concept of side effects in programming. Richard Buckland covers:

    • Adversary models in computation.
    • The significance of side effects in both machine code and C functions.
    • Returning values from functions and understanding ASCII.
    • The impact of engaging discussions during lectures.

    Students will gain insights into writing robust code that minimizes unintended consequences.

  • Writing a Simple C Program - Richard Buckland
    Writing a Simple C Program - Richard Buckland
    Richard Buckland
    Play

    In this module, Richard Buckland guides students through writing a simple C program named "countdown." The session includes:

    • Top-down design principles.
    • Using functions and prototypes effectively.
    • Integer arithmetic and input/output techniques.
    • Discussions on program style, clarity, and simplicity.

    This collaborative programming effort emphasizes learning through trial and error, fostering essential coding skills.

  • COMP1917 Higher Computing - Richard Buckland UNSW
    COMP1917 Higher Computing - Richard Buckland UNSW
    Richard Buckland
    Play

    This module serves as an introduction to the COMP1917 Higher Computing course, tailored for first-year Computer Science and Engineering students. The content includes:

    • Foundational computing concepts.
    • Overview of course objectives and structure.
    • Basic programming principles.

    Students will gain a solid grounding in computing that will support their further studies.

  • COMP1917 Higher Computing - Richard Buckland UNSW: Part 1
    COMP1917 Higher Computing - Richard Buckland UNSW: Part 1
    Richard Buckland
    Play

    This module is a revision session designed for students to consolidate their learning after the first two weeks of lectures. Richard Buckland discusses:

    • Key topics covered in the course so far.
    • Addressing common challenges faced by new programmers.
    • Revisiting fundamental programming concepts.

    The aim is to help students reinforce their understanding and build confidence in their programming abilities.

  • COMP1917 Higher Computing - Richard Buckland UNSW: Part 2
    COMP1917 Higher Computing - Richard Buckland UNSW: Part 2
    Richard Buckland
    Play

    This module continues the revision process for the COMP1917 course, enabling students to solidify their grasp of early programming concepts. Richard Buckland emphasizes:

    • Feedback from students regarding their learning experiences.
    • Discussion of areas where students are struggling.
    • Reinforcement of key programming principles.

    Students will benefit from further discussions and problem-solving strategies aimed at enhancing their skills.

  • A Simple Recursive Function - Richard Buckland UNSW
    A Simple Recursive Function - Richard Buckland UNSW
    Richard Buckland
    Play

    This module introduces students to the concept of recursion in programming through a practical example. Richard Buckland covers:

    • Summing numbers from 0 to n using a recursive approach.
    • Understanding arithmetic progression through Gauss's formula.
    • Discussion on coding style, craftsmanship, and the use of different data types.

    Students will grasp the importance of recursion within computer science and its practical applications.

  • Functions - Richard Buckland UNSW
    Functions - Richard Buckland UNSW
    Richard Buckland
    Play

    This module focuses on understanding functions in programming. Richard Buckland explains:

    • The fundamental purpose and benefits of using functions.
    • Abstraction and code reuse concepts.
    • Scope in programming and its implications.
    • How functions operate in C at a machine code level.

    Students will learn how to effectively utilize functions to improve their programming practices.

  • What To Do When Things Go Wrong? Richard Buckland UNSW
    What To Do When Things Go Wrong? Richard Buckland UNSW
    Richard Buckland
    Play

    In this module, Richard Buckland discusses strategies for addressing problems that arise during programming. Key topics include:

    • Identifying potential issues in code.
    • Strategies for troubleshooting and resolving errors.
    • Understanding the roles and responsibilities of programmers.
    • Exploring the concept of assertions in documenting assumptions.

    This session equips students with tools to navigate challenges effectively in their coding journey.

  • The Mechanics of Function Calls - Richard Buckland UNSW
    The Mechanics of Function Calls - Richard Buckland UNSW
    Richard Buckland
    Play

    This module explores the mechanics of function calls within C programming. Richard Buckland addresses:

    • How function calls are implemented in machine code.
    • The roles of calling and called functions.
    • The concept of frames in the context of function execution.

    Students will gain insights into the underlying operations of function calls, enhancing their understanding of program execution.

  • The Mechanics of Function Calls (part 2) - Richard Buckland UNSW
    The Mechanics of Function Calls (part 2) - Richard Buckland UNSW
    Richard Buckland
    Play

    This module continues the discussion on function calls, delving deeper into their implementation. Richard Buckland covers:

    • Saving registers and local variables during function calls.
    • Returning values from functions.
    • Safe programming conventions and their importance.

    Students will solidify their understanding of function mechanics and best practices in programming.

  • The Amazing Alan Turing - Richard Buckland (extension lecture) UNSW 2008
    The Amazing Alan Turing - Richard Buckland (extension lecture) UNSW 2008
    Richard Buckland
    Play

    This extension lecture by Richard Buckland highlights the groundbreaking contributions of Alan Turing to the field of computing. Key points include:

    • Turing's decryption work during WWII and the Enigma Machine.
    • The concept of the Turing Machine and its implications for computation.
    • Insights into the Turing Test and what it means to be human.

    Students will gain a deeper appreciation for Turing's legacy and its relevance to modern computing.

  • The Turing Test - Richard Buckland UNSW
    The Turing Test - Richard Buckland UNSW
    Richard Buckland
    Play

    This module continues the exploration of Alan Turing's ideas, particularly the Turing Test. Richard Buckland discusses:

    • The philosophical implications of the Turing Test in understanding personhood.
    • Links between design, computer science, and human experiences.
    • Common mistakes in programming loops and control structures.

    Students will reflect on the intertwining of philosophy and computing in Turing's work.

  • UNSW COMP1917 Higher Computing 2008 S1W4L3
    UNSW COMP1917 Higher Computing 2008 S1W4L3
    Richard Buckland
    Play

    This module introduces students to the COMP1917 course in its fourth week. Richard Buckland discusses:

    • The foundational concepts of programming introduced so far.
    • Expectations for the remainder of the course.
    • Strategies for success in programming.

    Students will be equipped with the necessary tools and mindset to thrive in their programming studies.

  • Frames (revision) - Richard Buckland (UNSW)
    Frames (revision) - Richard Buckland (UNSW)
    Richard Buckland
    Play

    This module revises the concept of frames in programming, a key component of function calls. Richard Buckland addresses:

    • What frames are and their role in function calls.
    • Understanding the return address and frame pointer.
    • Common problems encountered with frames and their resolutions.

    Students will enhance their understanding of function mechanics and how frames facilitate program execution.

  • Arrays (part 1) - Tim Lambert UNSW
    Arrays (part 1) - Tim Lambert UNSW
    Richard Buckland
    Play

    This module covers the topic of arrays in C programming. Tim Lambert introduces:

    • How to declare and use arrays for data manipulation.
    • Practical examples, such as calculating averages.
    • Consulting man pages for scanf and common pitfalls.

    Students will learn about the utility of arrays in programming and how to avoid common mistakes.

  • Arrays (part 2) - Tim Lambert UNSW
    Arrays (part 2) - Tim Lambert UNSW
    Richard Buckland
    Play

    In this session, Tim Lambert continues the exploration of arrays in C programming. Key topics include:

    • Advanced examples using arrays, such as letter frequency analysis.
    • Introduction to substitution ciphers.
    • Using array initializers and string manipulation.

    Students will deepen their knowledge of arrays and their applications in programming.

  • Pass By Reference: Arrays#3 - Tim Lambert UNSW
    Pass By Reference: Arrays#3 - Tim Lambert UNSW
    Richard Buckland
    Play

    This module introduces the concept of "Pass By Reference" in relation to arrays in C programming. Tim Lambert discusses:

    • The significance of passing arrays into functions.
    • How arrays are handled differently compared to other data types.
    • Practical examples to illustrate pass by reference.

    Students will understand the implications of reference passing on memory and performance in programming.

  • Game Design - Malcolm Ryan UNSW
    Game Design - Malcolm Ryan UNSW
    Richard Buckland
    Play

    In this module, we will explore the concept of fun in game design, led by UNSW researcher Malcolm Ryan. The lecture will cover:

    • Definitions of fun in gaming contexts
    • Key elements that contribute to enjoyable gameplay
    • Research findings and theories in game design

    Students will gain insights into what makes games engaging and the psychological aspects that influence player enjoyment.

  • Everything U Need 2 Know About Pointers -Richard Buckland
    Everything U Need 2 Know About Pointers -Richard Buckland
    Richard Buckland
    Play

    This module provides a comprehensive review of pointers and indirect addressing in programming. Topics include:

    1. Understanding pointers and their significance
    2. Pass by reference vs. pass by value
    3. Passing arrays into functions
    4. Dynamic data structures and their applications
    5. Introduction to Abstract Data Types (ADTs)

    Practical examples will demonstrate how pointers can enhance programming efficiency and flexibility.

  • The Most Important Thing - Richard Buckland UNSW
    The Most Important Thing - Richard Buckland UNSW
    Richard Buckland
    Play

    This engaging lecture challenges students to solve a Sudoku puzzle in real-time while discussing problem-solving approaches:

    • Understanding Sudoku puzzles
    • Estimation techniques in programming
    • Contrasting novice and expert problem-solving strategies
    • Algorithms and data structures relevant to Sudoku

    Students will learn the most important aspects of programming and how to effectively approach problem-solving.

  • Stack Frames - Richard Buckland UNSW
    Stack Frames - Richard Buckland UNSW
    Richard Buckland
    Play

    In this module, students will review the code from the previous lecture, discussing:

    • Backtracking vs. brute force methods
    • Understanding stack memory and its significance
    • Introduction to buffer overflows and their implications
    • Practical examples and course updates

    This interactive session focuses on deepening understanding of programming concepts through real-world examples.

  • eXtreme Programming - Richard Buckland
    eXtreme Programming - Richard Buckland
    Richard Buckland
    Play

    This module introduces students to extreme programming methodologies, featuring:

    1. Unit testing and its importance
    2. Test-driven development techniques
    3. Refactoring code for better efficiency
    4. Managing multi-file programs in C

    Through examples, students will understand the benefits of extreme programming practices in software development.

  • A Miracle - Richard Buckland UNSW
    A Miracle - Richard Buckland UNSW
    Richard Buckland
    Play

    This module presents an unexpected miracle in programming, contrasting:

    • Programming in the small vs. programming in the large
    • Collaboration in software development
    • Best practices for tackling complex projects

    Students will reflect on their programming experiences and learn how to approach larger projects effectively.

  • Programming in the Large - Richard Buckland UNSW
    Programming in the Large - Richard Buckland UNSW
    Richard Buckland
    Play

    This lecture focuses on standards and interfaces in programming, highlighting:

    1. Importance of standards in team programming
    2. Writing interface functions
    3. Using unit tests to ensure code quality
    4. Comparing strings and arrays of characters
    5. Understanding static functions and their roles

    Students will learn how to write robust large-scale programs effectively.

  • Stress - Richard Buckland UNSW
    Stress - Richard Buckland UNSW
    Richard Buckland
    Play

    This module discusses handling stress during programming, covering:

    • Common programming errors involving arrays
    • Writing reflective diary entries for personal growth
    • Engaging with puzzles to enhance logical thinking

    Students will explore strategies for managing stress and improving their programming skills.

  • Random Numbers - Richard Buckland UNSW (2008)
    Random Numbers - Richard Buckland UNSW (2008)
    Richard Buckland
    Play

    This extension lecture introduces the concept of randomness, discussing:

    • What constitutes a random process
    • Generating random output on deterministic computers
    • Applications and challenges of randomness in programming
    • Von Neumann's algorithm and its implications

    Students will gain a deeper understanding of how randomness is used in computational contexts.

  • The Trouble with Concrete Types - Richard Buckland UNSW
    The Trouble with Concrete Types - Richard Buckland UNSW
    Richard Buckland
    Play

    This lecture addresses the complexities of concrete types, focusing on:

    • Insights from Task 2 diaries on time management
    • Setting up for Abstract Data Types (ADTs)
    • Separating problems into independent files

    Students will learn how to implement better programming practices through effective organization.

  • Abstract Data Types in C - Richard Buckland UNSW
    Abstract Data Types in C - Richard Buckland UNSW
    Richard Buckland
    Play

    This module focuses on Abstract Data Types (ADTs) and their implementation in C, covering:

    • Understanding the need for ADTs
    • How to implement ADTs effectively
    • Memory management techniques, including stack and heap

    Students will explore the advantages of using ADTs in programming and their impact on code quality.

  • The Major Project - Richard Buckland UNSW
    The Major Project - Richard Buckland UNSW
    Richard Buckland
    Play

    This module discusses the major project for the course, focusing on:

    • The card game "Blackadder and Baldrick"
    • Project expectations and objectives
    • Recognition for outstanding contributions

    Students will learn about project management and collaboration in a competitive environment.

  • Task2 rewritten as an ADT - Richard Buckland UNSW
    Task2 rewritten as an ADT - Richard Buckland UNSW
    Richard Buckland
    Play

    This module focuses on converting SudokuGrid into an Abstract Data Type (ADT), discussing:

    • The process of converting existing code into an ADT
    • Accessing struct components using dot and arrow notation
    • Best practices for structuring code

    Students will gain practical skills in implementing ADTs in their programming projects.

  • Steganography (hidden messages) - Richard Buckland UNSW
    Steganography (hidden messages) - Richard Buckland UNSW
    Richard Buckland
    Play

    This extension lecture introduces steganography, exploring:

    • The concept of hidden messages in various contexts
    • Applications in cryptography, film, and teaching
    • Techniques for digital watermarking

    Students will engage with intriguing examples and consider the implications of hidden information.

  • Don't give up - Richard Buckland UNSW
    Don't give up - Richard Buckland UNSW
    Richard Buckland
    Play

    This module encourages students to persevere in programming, discussing:

    • Personal trainer insights and exercise for mental health
    • Project Q&A sessions
    • Algorithms vs. Data Structures
    • Approaches to programming the Josephus problem

    Students will learn how to tackle complex problems with resilience and creativity.

  • The Australian National Anthem - Richard Buckland UNSW
    The Australian National Anthem - Richard Buckland UNSW
    Richard Buckland
    Play

    This module delves into the Australian National Anthem and its implications in programming, discussing:

    • File I/O in C and understanding files
    • Memory management challenges in programming
    • Exploring linked lists and their role in coding

    Students will engage with practical coding exercises related to file operations and memory management.

  • Linked Lists - Richard Buckland UNSW
    Linked Lists - Richard Buckland UNSW
    Richard Buckland
    Play

    This module focuses on linked lists, covering:

    • The concept of indirect addressing
    • Setting up and manipulating linked lists
    • Doubly linked lists and their applications

    Students will learn hands-on coding techniques for implementing linked lists effectively.

  • Experimenting with CMOS - Richard Buckland UNSW
    Experimenting with CMOS - Richard Buckland UNSW
    Richard Buckland
    Play

    This extension lecture introduces students to do-it-yourself digital design using CMOS chips, discussing:

    • Overview of digital design concepts
    • Hands-on projects using breadboards
    • Practical applications and experiments

    Students will explore the exciting world of digital design and its real-world applications.

  • Complexity & Trees - Richard Buckland UNSW
    Complexity & Trees - Richard Buckland UNSW
    Richard Buckland
    Play

    This module discusses complexity and trees in programming, covering:

    • Best, worst, and expected case scenarios
    • Binary search and insert operations
    • Understanding trees and ordered binary trees

    Students will learn how to implement tree structures and analyze their complexity in different programming scenarios.

  • Programming Errors - Richard Buckland UNSW
    Programming Errors - Richard Buckland UNSW
    Richard Buckland
    Play

    This module focuses on programming errors and their prevention, covering:

    • Runtime and compile-time errors in C
    • Using tools like gcc, valgrind, and mudflap
    • Understanding array bounds and segmentation faults

    Students will learn how to identify and avoid common programming pitfalls to improve code reliability.

  • Taste of Graphics - Tim Lambert, Yose Widjaja UNSW
    Taste of Graphics - Tim Lambert, Yose Widjaja UNSW
    Richard Buckland
    Play

    This module provides a taste of graphics programming, featuring:

    • Insights from third-year graphics projects
    • Demos of simulation techniques for visualizations
    • Comparison of DirectX vs. OpenGL

    Students will gain a foundational understanding of graphics programming and its applications in real-world projects.

  • Sample Tree Code: Loop Detection - Richard Buckland UNSW 2008
    Sample Tree Code: Loop Detection - Richard Buckland UNSW 2008
    Richard Buckland
    Play

    This module discusses sample tree code for loop detection, focusing on:

    • Detecting fixed points in algorithms
    • Implementing simple tree structures
    • Exploring data structure revisions and improvements

    Students will learn practical applications of tree structures in programming and algorithm design.

  • Ethics - Richard Buckland UNSW
    Ethics - Richard Buckland UNSW
    Richard Buckland
    Play

    This module delves into the ethical considerations in computing, covering:

    • What constitutes ethics in programming
    • Whistleblowing and its implications
    • Intellectual property and copyright laws

    Students will engage in discussions about ethical responsibilities and the impact of technology on society.

  • Hamming Error Correcting Code - Richard Buckland UNSW
    Hamming Error Correcting Code - Richard Buckland UNSW
    Richard Buckland
    Play

    The Hamming Error Correcting Code module provides an in-depth exploration of error detection and correction techniques used in computing. Students will learn about:

    • Hamming codes and their significance in data transmission
    • Parity bits and their role in error detection
    • Techniques to correct errors in transmitted information
    • Real-world applications and implications of these coding strategies

    This knowledge is essential for anyone looking to understand data integrity and reliability in computing systems.

  • Professionalism - Richard Buckland UNSW
    Professionalism - Richard Buckland UNSW
    Richard Buckland
    Play

    The Professionalism module delves into the ethical and professional standards expected in the computing industry. Key topics include:

    • The definition of professionalism and its importance in computing
    • Case studies of ethical dilemmas in technology companies
    • Advice for future professionals on managing projects and ethical considerations
    • The role of ethics in engineering and technology
    • Insights from historical events and their impact on public perception

    Students will be equipped with the knowledge to navigate their professional lives with integrity.

  • What Makes a Good Programmer? - Richard Buckland UNSW
    What Makes a Good Programmer? - Richard Buckland UNSW
    Richard Buckland
    Play

    This module focuses on answering the question, "What makes a good programmer?" Topics include:

    • Essential qualities and skills of effective programmers
    • The relationship between craftsmanship, science, and design in programming
    • Reflections on the course journey and learning methods
    • Real-life examples and inspiration from renowned figures
    • Considerations for lifelong learning in computing

    Through discussions and reflections, students will gain insights into becoming proficient programmers.

  • The Entire Semester in 46 Minutes and 2 Seconds - Richard Buckland
    The Entire Semester in 46 Minutes and 2 Seconds - Richard Buckland
    Richard Betts
    Play

    This module presents a comprehensive review of the entire semester in computing, covering key concepts and experiences. Students will:

    • Reflect on important topics discussed throughout the term
    • Understand the relevance of the material to future studies
    • Engage with a recap of core programming principles
    • Experience a light-hearted summary of the course events

    This fast-paced review helps solidify understanding and prepares students for future challenges in computing.

  • Learning and Teaching Computing - Richard Buckland UNSW
    Learning and Teaching Computing - Richard Buckland UNSW
    Richard Buckland
    Play

    The Learning and Teaching Computing module concludes the course with a focus on educational philosophies and motivations. Key points include:

    • The philosophy behind teaching and learning in computing
    • Intrinsic vs. extrinsic motivation in education
    • Deep learning versus surface learning techniques
    • Acknowledgment of student achievements and contributions
    • Advice for future learning paths in computing

    This reflective session prepares students for their ongoing learning experiences beyond the course.

  • The Strange Case of the Erotic Kiss - Richard Buckland UNSW
    The Strange Case of the Erotic Kiss - Richard Buckland UNSW
    Richard Buckland
    Play

    The Strange Case of the Erotic Kiss module provides an engaging conclusion to the first computing course. This session covers:

    • The structure and expectations for the final exam
    • Importance of preparation and understanding exam formats
    • Advice from previous students on effective study habits
    • Future courses and paths in computing
    • Parting thoughts and life lessons from the instructor

    This module aims to leave students with lasting knowledge and memories as they transition to the next stage of their education.

  • Coding Samples C: Extracting Digits Using % /, Recursion
    Coding Samples C: Extracting Digits Using % /, Recursion
    Richard Buckland
    Play

    This module showcases live C coding samples, providing students with practical coding experience. The content includes:

    • Extracting digits using various methods
    • Understanding recursion in programming
    • Hands-on coding examples to reinforce theoretical knowledge
    • Visual aids to help students grasp complex concepts

    These coding demonstrations are designed to enhance understanding and application of C programming techniques.

  • Coding Samples B: Scope, Pass By Copy
    Coding Samples B: Scope, Pass By Copy
    Richard Buckland
    Play

    This module presents additional live C coding samples focused on scope and pass-by-copy methodology. Key features include:

    • Understanding variable scope in programming
    • Exploring the concept of pass-by-copy
    • Demonstrating these concepts through practical coding examples
    • Encouraging interaction and questions to foster learning

    These coding samples aim to solidify foundational knowledge in C programming and enhance the learning process.

  • Coding Samples A: xcode, .hfiles
    Coding Samples A: xcode, .hfiles
    Richard Buckland
    Play

    This module features introductory live C coding samples that cover essential programming techniques. Students will learn about:

    • Using .h files and their significance in C programming
    • Setting up the Xcode environment for coding
    • Basic coding practices for new programmers
    • Real-time coding demonstrations to illustrate concepts

    This foundational module will prepare students for more advanced programming challenges in the course.

  • Gamification and The Joy of Learning - Richard Buckland
    Gamification and The Joy of Learning - Richard Buckland
    Richard Buckland
    Play

    This module discusses the innovative concept of gamification in education and its impact on student engagement. Topics covered include:

    • Understanding why university learning can feel burdensome
    • Exploring the benefits of gamification in enhancing motivation
    • Examining real-life experiments in large computing courses
    • Strategies for implementing non-traditional assessments

    This insightful discussion encourages educators to rethink traditional teaching methods and explore new ways to foster joy in learning.

About | Terms | Privacy | Contact Us | Schools
© 2009-2025 Courses.com. All rights reserved.