Lecture

Introduction to Haskell

This module introduces Haskell, focusing on its unique features and advantages. Key topics include:

  • Exploring the history and evolution of Haskell.
  • Understanding safeguards that prevent runtime errors.
  • Examining user-defined data types and their implementations.

Students will learn about Haskell's lazy evaluation and its implications for function definitions, enhancing their functional programming skills.


Course Lectures
  • This module provides an overview of the course structure and administrative details, including important information about exams, assignments, and communication channels. Students will learn about:

    • Course prerequisites and expectations.
    • Differences between programming languages and paradigms.
    • Concurrent programming basics.
    • Overview of functional programming in Scheme.
    • Introduction to Python and its applications.

    This foundational knowledge will set the stage for a deeper understanding of various programming paradigms throughout the course.

  • This module explores data types in C and C++, examining their interpretations, sizes, and memory representations. Key topics include:

    • Understanding how bytes are broken into bits.
    • Representations of negative numbers and two's complement addition.
    • Conversion between different data types, including chars, shorts, and floats.

    Students will gain insights into how data types are represented in memory and the importance of type conversions in programming.

  • This module focuses on converting between types of different sizes using pointers. Students will learn about:

    • The concepts of little-endian vs. big-endian data storage.
    • How structs store data and how to access it.
    • Pointer arithmetic on arrays and the implications of casting.
    • Memory layout of structs and dynamically allocated strings.

    By mastering these concepts, students will enhance their understanding of memory management and data manipulation in C and C++.

  • This module covers the creation of a generic swap function for data types of arbitrary size. Key topics include:

    • Using void* type for generic pointers.
    • Implementing a swap function with memcpy.
    • The client interface for the generic swap function.
    • Comparative analysis of C and C++ generics.

    Students will understand the pros and cons of using generics in C and C++ and learn about potential errors that can arise from improper usage.

  • This module introduces the prototype for a generic linear search function. Topics covered include:

    • Creating a comparison function for different data types.
    • Client usage of the generic linear search.
    • Handling more complex data types, such as C-strings.
    • Implementing a non-generic stack and its interface.

    Students will learn how to implement and utilize generic algorithms effectively, as well as understand the implications of type compatibility during comparisons.

  • This module elaborates on the integer stack implementation, focusing on constructors and destructors. Key learning points include:

    • Implementing stack operations such as push and pop.
    • Memory reallocation with realloc when stack grows.
    • Generic struct implementation and memory handling techniques.

    Students will gain practical skills in managing stack memory, understanding the importance of memory management in dynamic data structures.

  • This module covers memory ownership issues, specifically in stack implementations. Key concepts include:

    • Understanding the ownership of dynamically allocated memory.
    • How to properly free memory in stack implementations.
    • C library functions relevant to memory management.
    • The global layout of memory, stack segment, and heap segment.

    By the end of this module, students will understand the implications of memory management in software development and the importance of proper memory cleanup.

  • This module focuses on heap management and how allocation information is stored. Key topics include:

    • How free blocks are managed in the heap.
    • Algorithms for choosing free blocks for allocation.
    • Understanding memory fragmentation and compaction techniques.
    • Activation records and the stack pointer during function calls.

    Students will learn about the internal workings of memory management, including allocation strategies and the importance of efficient memory usage.

  • This module illustrates how code snippets are translated into assembly instructions. Topics covered include:

    • Understanding basic assembly operations: store, load, and ALU operations.
    • Translating high-level constructs like loops into assembly.
    • Branch instructions and how they affect control flow.

    Students will gain insights into the lower-level operations that underlie high-level programming constructs and how they translate into machine instructions.

  • This module provides more detail on activation records and the memory layout during function calls. Key concepts include:

    • How the return address of functions is stored on the stack.
    • Construction of activation records and their layout.
    • Understanding the call and ret instructions in assembly.

    Students will understand the function call mechanics and the role of activation records in managing function parameters and return addresses.

  • This module compares C code generation to C++ code generation, focusing on a basic swap example. Key topics include:

    • Code generation techniques for pointers vs. references.
    • Understanding the "this" pointer in class methods.
    • Compilation, linking, and preprocessor directives.

    Students will gain insights into how different paradigms affect code generation and memory handling, particularly in object-oriented programming.

  • This module introduces preprocessing commands in C and C++. Key topics include:

    • The function of #define as a macro substitution tool.
    • Handling complex arguments in macros.
    • Understanding the role of #include and circular loops.

    Students will learn practical applications of preprocessing commands and their impact on the compilation process, enhancing code maintainability.

  • This module reviews the compilation process of a simple program, highlighting several key aspects. Students will cover:

    • The impact of standard library files on the compilation process.
    • How the GCC linker functions in linking library files.
    • Debugging techniques related to segmentation faults and alignment issues.

    Understanding these concepts will help students navigate common compilation challenges and improve their debugging skills.

  • This module contrasts sequential programming with concurrent programming. Key topics include:

    • Understanding the differences between sequential and concurrent execution.
    • Examples of data sharing issues in concurrent programming.
    • Real-world applications of multithreading and multiprocessing.

    Students will comprehend the complexities of concurrent programming and the challenges it poses in managing shared data safely.

  • This module examines the transition from sequential to concurrent programming using a ticket sale example. Key learning points include:

    • Identifying problems inherent to the sequential model.
    • Implementing threading interfaces to enhance performance.
    • Understanding critical regions and semaphore usage to protect shared data.

    Students will analyze how to effectively transition existing applications to leverage concurrency, identifying potential pitfalls in the process.

  • Semaphores
    Jerry Cain

    This module provides a detailed review of semaphore operations in concurrent programming. Key topics include:

    • Understanding semaphore syntax and its operations.
    • Using semaphores to prevent race conditions in multithreaded functions.
    • Different patterns of semaphore usage, including binary locks and rendezvous.

    Students will learn how to implement semaphores effectively in their concurrent applications to ensure safe and predictable behavior.

  • This module continues the exploration of the dining philosopher problem, emphasizing its implications in concurrent programming. Key aspects include:

    • Modeling philosophers as threads and the potential for deadlock.
    • Implementing semaphore strategies to avoid deadlock scenarios.
    • Examples of thread synchronization in real-world applications.

    Students will gain insights into designing systems that effectively manage concurrency while avoiding common pitfalls such as deadlock.

  • This module introduces the ice cream store concurrency problem, involving multiple threads for customers, cashiers, and clerks. Key learning points include:

    • Setting up various types of threads and their interactions.
    • Implementing semaphores for coordinating actions between threads.
    • Managing shared resources and ensuring thread safety.

    Students will work on writing and implementing thread functions, gaining practical experience in designing and managing concurrent systems.

  • This module introduces students to the functional paradigm using Scheme. Key topics covered include:

    • Understanding the core principles of functional programming.
    • Defining and evaluating functions in Scheme.
    • Exploring environment details and primitive operations.

    Students will learn to express functions as lists and gain hands-on experience with recursive functions and fundamental operations in Scheme.

  • This module tackles the Car-Cdr recursion problem in Scheme, allowing students to deepen their understanding of functional programming. Key concepts include:

    • Recursive implementation of functions such as summation and Fibonacci.
    • Error checking and type validation in runtime versus compile-time.
    • Using conditional structures to manage different recursive cases.

    Students will practice writing recursive functions and discover the nuances of function evaluation in a functional programming context.

  • This module covers the Kawa development environment, focusing on evaluating expressions and loading function definitions. Key topics include:

    • Mapping functions over lists using the map operation.
    • Using apply and eval for function application in real time.
    • Implementing higher-order functions and utilizing lambda expressions.

    Students will enhance their skills in functional programming by utilizing various mapping techniques and evaluating expressions dynamically.

  • This module focuses on writing a recursive power set function in Scheme, emphasizing the power of recursion. Students will learn about:

    • Using lambda functions to construct power sets efficiently.
    • Understanding let bindings and their role in recursion.
    • Exploring the immutability of lists in functional programming.

    Students will practice implementing powerful recursive algorithms that showcase the effectiveness of functional programming paradigms.

  • Scheme Memory Model
    Jerry Cain

    This module covers the Scheme memory model, detailing how memory is allocated and managed. Key points include:

    • The internal representation of lists and how they are stored.
    • Garbage collection techniques and their importance in memory management.
    • Exploring high-level mechanics of garbage collection.

    Students will gain insights into memory management in functional programming and understand how memory allocation affects performance.

  • This module provides an overview of Python, highlighting its features and applications. Key topics include:

    • Understanding Python as a scripting language with dynamic typing.
    • Exploring the use of whitespace and tabs in the Python environment.
    • Working with Python strings, lists, and dictionaries.

    Students will learn how to execute basic statements and utilize Python’s powerful features to manage data effectively.

  • Python Object Model
    Jerry Cain

    This module delves into Python's object model, focusing on how objects are structured and utilized. Key topics include:

    • Understanding how Python implements objects and classes.
    • Exploring dictionary implementations for object storage.
    • Working with class constructors and object initialization.

    Through practical examples, students will learn the intricacies of Python’s object model, including object references and copying mechanisms.

  • This module addresses XML processing in Python, highlighting two different processing models. Key points include:

    • How to parse XML streams using Python.
    • Implementing a function to list feed titles from an RSS feed.
    • Understanding the advantages of tree-based vs. stream-based XML parsing.

    Students will gain practical experience in XML handling and learn how to effectively implement XML parsers in their applications.

  • This module introduces Haskell, focusing on its unique features and advantages. Key topics include:

    • Exploring the history and evolution of Haskell.
    • Understanding safeguards that prevent runtime errors.
    • Examining user-defined data types and their implementations.

    Students will learn about Haskell's lazy evaluation and its implications for function definitions, enhancing their functional programming skills.