Lecture

Solving Problems - Richard Buckland UNSW 2008

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.


Course Lectures
  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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.

  • 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 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.

  • 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.

  • 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.

  • 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.

  • 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.