Course Timetable

When you have completed this course, you will be able to systematically design small programs using the Python programming language. You will be able to take a problem from an academic discipline of your choice, appropriately represent the domain information as data in your program, and design functions that successfully solve your problem. You will learn how to break down a large problem into well-structured sub-problems, each of which will be solved systematically. You will understand how programs work which will help you better understand the computer-based world that you interact with every day. You will be better able to communicate with computer scientists in your future workplace. This course is designed for students who are not computer science majors. There are no prerequisites.

When you have completed this course, you will be able to systematically design small programs using the Python programming language. You will be able to take a problem from an academic discipline of your choice, appropriately represent the domain information as data in your program, and design functions that successfully solve your problem. You will learn how to break down a large problem into well-structured sub-problems, each of which will be solved systematically. You will understand how programs work which will help you better understand the computer-based world that you interact with every day. You will be better able to communicate with computer scientists in your future workplace. This course is designed for students who are not computer science majors. There are no prerequisites.

When you have completed this course, you will be able to systematically design small programs using the Python programming language. You will be able to take a problem from an academic discipline of your choice, appropriately represent the domain information as data in your program, and design functions that successfully solve your problem. You will learn how to break down a large problem into well-structured sub-problems, each of which will be solved systematically. You will understand how programs work which will help you better understand the computer-based world that you interact with every day. You will be better able to communicate with computer scientists in your future workplace. This course is designed for students who are not computer science majors. There are no prerequisites.

Computation, programs and programming play a vital role in the work of scientists, engineers, artists and other professionals: they allow us to organize, store, analyze and visualize information; create animations, music, and online communities; control devices in our environment; develop computational models and simulations; and much much more. The major goal of this course is to introduce students to the practice of systematic problem solving through the design of programs. The course will also help you understand more deeply how computation and programs work, and how they have the power to do what they do. Do you know how to design a computer animation? Or a multi-player game? Or how to combine information from sources like eBay and Google automatically? Or a game that runs on your phone? Do you know how to use the process of writing a computer program to better understand ecosystems or Translink schedules? This course will show you how—we will explore systems like these as part of our lab projects. The course presents an approach to systematic problem analysis and solution design, and prepares students for further course-based and/or independent learning of Computer Science skills and concepts. The course is designed to be interesting, accessible and useful to a wide range of students. No prior programming experience is assumed, and very little math and science background is required. This makes the course appropriate for all UBC students—CS majors and non-majors alike.

CPSC 121 explores formal modeling systems that help us to understand and to explore the capabilities of computers and, more generally, of any problem solving process. Our exploration of these systems will be guided by the desire to answer the following four practical questions:

1. How can we convince ourselves that an algorithm does what it's supposed to do?
2. How do we determine whether or not one algorithm is better than another one?
3. How does the computer (e.g. Dr. Racket) decide if the characters of your program represent a name, a number, or something else? How does it figure out if you have mismatched " " or ( )?
4. As of 2019, processors have six to seven billion transistors. How can we build a computer that is able to execute a user-defined program?

CPSC 121 explores formal modeling systems that help us to understand and to explore the capabilities of computers and, more generally, of any problem solving process. Our exploration of these systems will be guided by the desire to answer the following four practical questions:

1. How can we convince ourselves that an algorithm does what it's supposed to do?
2. How do we determine whether or not one algorithm is better than another one?
3. How does the computer (e.g. Dr. Racket) decide if the characters of your program represent a name, a number, or something else? How does it figure out if you have mismatched " " or ( )?
4. As of 2019, processors have six to seven billion transistors. How can we build a computer that is able to execute a user-defined program?

CPSC 121 explores formal modeling systems that help us to understand and to explore the capabilities of computers and, more generally, of any problem solving process. Our exploration of these systems will be guided by the desire to answer the following four practical questions:

1. How can we convince ourselves that an algorithm does what it's supposed to do?
2. How do we determine whether or not one algorithm is better than another one?
3. How does the computer (e.g. Dr. Racket) decide if the characters of your program represent a name, a number, or something else? How does it figure out if you have mismatched " " or ( )?
4. As of 2019, processors have six to seven billion transistors. How can we build a computer that is able to execute a user-defined program?

The following broad topics will be covered. The main learning goals for each topic are also provided.

Data Abstraction

• describe how data abstraction makes possible the construction of larger software systems
• specify, use, test and implement a data abstraction in Java

Control Flow Models

• produce inter- and intra-method control flow diagrams from Java code

Type Hierarchies, Polymorphism and Dispatching

• trace the execution of Java source code that uses polymorphism, inheritance and dynamic dispatching
• determine if one type is substitutable for another

Robust Data Abstractions

• specify, test and implement a robust data abstraction using exceptions

Object-Oriented Design

• record the design of an existing system using a UML class diagram
• extract UML sequence diagrams from existing code
• express a UML class diagram as a Java program
• make effective use of the Java Collections Framework

Design Patterns

• apply the Composite, Observer, and Iterator patterns to a given design problem

The following broad topics will be covered. The main learning goals for each topic are also provided.

Data Abstraction

• describe how data abstraction makes possible the construction of larger software systems
• specify, use, test and implement a data abstraction in Java

Control Flow Models

• produce inter- and intra-method control flow diagrams from Java code

Type Hierarchies, Polymorphism and Dispatching

• trace the execution of Java source code that uses polymorphism, inheritance and dynamic dispatching
• determine if one type is substitutable for another

Robust Data Abstractions

• specify, test and implement a robust data abstraction using exceptions

Object-Oriented Design

• record the design of an existing system using a UML class diagram
• extract UML sequence diagrams from existing code
• express a UML class diagram as a Java program
• make effective use of the Java Collections Framework

Design Patterns

• apply the Composite, Observer, and Iterator patterns to a given design problem

The following broad topics will be covered. The main learning goals for each topic are also provided.

Data Abstraction

• describe how data abstraction makes possible the construction of larger software systems
• specify, use, test and implement a data abstraction in Java

Control Flow Models

• produce inter- and intra-method control flow diagrams from Java code

Type Hierarchies, Polymorphism and Dispatching

• trace the execution of Java source code that uses polymorphism, inheritance and dynamic dispatching
• determine if one type is substitutable for another

Robust Data Abstractions

• specify, test and implement a robust data abstraction using exceptions

Object-Oriented Design

• record the design of an existing system using a UML class diagram
• extract UML sequence diagrams from existing code
• express a UML class diagram as a Java program
• make effective use of the Java Collections Framework

Design Patterns

• apply the Composite, Observer, and Iterator patterns to a given design problem

Help students develop a model of computation that is rooted in what really happens when a program executes. 
 

Help students develop a model of computation that is rooted in what really happens when a program executes. 
 

Help students develop a model of computation that is rooted in what really happens when a program executes. 
 

The preliminary syllabus is here: https://www.students.cs.ubc.ca/~cs-304/2021W1/cpsc304_2021w1_syllabus.pdf 

The preliminary syllabus is here: https://www.students.cs.ubc.ca/~cs-304/2021W1/cpsc304_2021w1_syllabus.pdf 

The preliminary syllabus is here: https://www.students.cs.ubc.ca/~cs-304/2021W1/cpsc304_2021w1_syllabus.pdf 

This will be a challenging course that we have designed to integrate many of the ideas and concepts from your prior courses in order to help you learn how to apply them to engineer modern software systems. The official course learning outcomes for CPSC310 are: 

1. Evaluate software engineering processes used to build modern industrial-calibre systems by justifying their benefits and tradeoffs.

2. Elicit, deconstruct, and refine functional requirements and quality attributes such that they are described succinctly, completely, and precisely.

3. Devise and justify high- and low-level designs to support a given set of requirements and in support of future evolutionary needs.

4. Iteratively derive implementations of a design of reasonable complexity incorporating emergent design implications, and applying code-level restructuring for the sake of facilitating changes.

5. Carry out the implementation of a design incorporating ethical and security implications of code-level choices and software process and methodological approaches.

6. Independently acquire and apply modern and unfamiliar technology and language stacks.

7. Validate systems using both black-box and white-box approaches to reason about, and improve the quality of a software system.

This will be a challenging course that we have designed to integrate many of the ideas and concepts from your prior courses in order to help you learn how to apply them to engineer modern software systems. The official course learning outcomes for CPSC310 are: 

1. Evaluate software engineering processes used to build modern industrial-calibre systems by justifying their benefits and tradeoffs.

2. Elicit, deconstruct, and refine functional requirements and quality attributes such that they are described succinctly, completely, and precisely.

3. Devise and justify high- and low-level designs to support a given set of requirements and in support of future evolutionary needs.

4. Iteratively derive implementations of a design of reasonable complexity incorporating emergent design implications, and applying code-level restructuring for the sake of facilitating changes.

5. Carry out the implementation of a design incorporating ethical and security implications of code-level choices and software process and methodological approaches.

6. Independently acquire and apply modern and unfamiliar technology and language stacks.

7. Validate systems using both black-box and white-box approaches to reason about, and improve the quality of a software system.

In CPSC 213, you learned how computers execute programs and how common programming language constructs can be translated into assembly language. You also discussed how to deal with multiples processes and threads and how you can synchronize their operations. Finally, you discussed virtual memory. In this course, we will dig a bit deeper and examine how computers are designed and some techniques that are used to make them execute the programs we write as quickly as possible. At the end of this course you will be able to:

1. Describe a possible high-level architecture for a pipelined CPU.
2. Explain the importance of, and issues with, instruction-level parallelism.
3. Describe the various types of memory used by modern computers, and explain how the hardware and the operating system cooperate to manage this memory.
4. Explain the issues that must be considered while designing file systems, and how file systems are managed.
5. Utilize your knowledge of the CPU and memory systems to optimize C/C++ code and make it run faster.

In CPSC 213, you learned how computers execute programs and how common programming language constructs can be translated into assembly language. You also discussed how to deal with multiples processes and threads and how you can synchronize their operations. Finally, you discussed virtual memory. In this course, we will dig a bit deeper and examine how computers are designed and some techniques that are used to make them execute the programs we write as quickly as possible. At the end of this course you will be able to:

1. Describe a possible high-level architecture for a pipelined CPU.
2. Explain the importance of, and issues with, instruction-level parallelism.
3. Describe the various types of memory used by modern computers, and explain how the hardware and the operating system cooperate to manage this memory.
4. Explain the issues that must be considered while designing file systems, and how file systems are managed.
5. Utilize your knowledge of the CPU and memory systems to optimize C/C++ code and make it run faster.

The course will provide an introduction to the theory and practice of computer graphics algorithms, including different aspects of modelling, rendering and basic animation. We will focus on the modern programmable graphics pipeline with vertex and fragment shaders. This course is the first in our sequence on computer graphics, followed by Modeling (CPSC 424) and Animation (CPSC 426) as well as several graduate CG courses.

Topics to be covered include most or all of the following: geometric transformations; the rendering pipeline, including perspective projection, scan conversion, and hidden surface removal; lighting and illumination; texture mapping; colour models; geometry modeling and data structures; complex shading algorithms; ray-tracing; animation; graphics APIs; GPUs.

Computer networks are pervasive and we use them  daily yet we often do not give a lot of thought to how they are put together, work, how applications  use them, and what the underlying fundamental principles are that allow us to build and design applications using computer networks.  In this course you should:

• Become comfortable with writing and working with different programs that use computer networks
• Learn the terminology associated with networking
• Learn the key paradigms and strategies used in developing applications that use computer networks
• Be able to apply the key paradigms and strategies to write programs and/or explain the operation of the Internet.
• Become familiar with the basic concepts of how the Internet is put together and operates and basic protocols that are used.

In particular the material will be framed by looking at the key strategies and models for addressing:

• Design strategies for scalability and reliability in distributed systems
• The use of layers and abstractions to understand and simplify designs.
• Routing, naming and addressing
• Isolation, data loss and performance
• Privacy and Security

Computer networks are pervasive and we use them  daily yet we often do not give a lot of thought to how they are put together, work, how applications  use them, and what the underlying fundamental principles are that allow us to build and design applications using computer networks.  In this course you should:

• Become comfortable with writing and working with different programs that use computer networks
• Learn the terminology associated with networking
• Learn the key paradigms and strategies used in developing applications that use computer networks
• Be able to apply the key paradigms and strategies to write programs and/or explain the operation of the Internet.
• Become familiar with the basic concepts of how the Internet is put together and operates and basic protocols that are used.

In particular the material will be framed by looking at the key strategies and models for addressing:

• Design strategies for scalability and reliability in distributed systems
• The use of layers and abstractions to understand and simplify designs.
• Routing, naming and addressing
• Isolation, data loss and performance
• Privacy and Security

The topics that we will be discuss in this course fall into two main categories. First, we will look at techniques that we can use to design efficient data structures and algorithms. Second, we will learn tools that make it possible to prove the correctness and the efficiency of the algorithms and data structures that we designed. More specifically, we will look at the following broad topics (not necessarily in this order):

• Searching and sorting;
• Data structures, such as skip lists.
• Mathematical tools, like O notation, recurrence relations, and amortized analysis;
• Algorithm design techniques, for instance randomization, greediness and dynamic programming.

Much of the material is formal (mathematical) in nature, and hence proofs will constitute an important part of the course.

At the end of the course, you will be able to:

1. Recognize which algorithm design technique(s), such as divide and conquer, prune and search, greedy strategies, or dynamic programming was used in a given algorithm.
2. Select and judge several promising paradigms and/or data structures (possibly slightly modified) for a given problem by analyzing the problem's properties.
3. Implement a solution to a problem using a specified algorithm design paradigm, given sufficient information about the form of that problem's solution.
4. Select, judge and apply promising mathematical techniques (such as asymptotic notations, recurrence relations, amortized analysis and decision trees) to establish reasonably tight upper and lower bounds on the running time of algorithms.
5. Recognize similarities between a new problem and some of the problems they have encountered, and judge whether or not these similarities can be leveraged towards designing an algorithm for the new problem.

The topics that we will be discuss in this course fall into two main categories. First, we will look at techniques that we can use to design efficient data structures and algorithms. Second, we will learn tools that make it possible to prove the correctness and the efficiency of the algorithms and data structures that we designed. More specifically, we will look at the following broad topics (not necessarily in this order):

• Searching and sorting;
• Data structures, such as skip lists.
• Mathematical tools, like O notation, recurrence relations, and amortized analysis;
• Algorithm design techniques, for instance randomization, greediness and dynamic programming.

Much of the material is formal (mathematical) in nature, and hence proofs will constitute an important part of the course.

At the end of the course, you will be able to:

1. Recognize which algorithm design technique(s), such as divide and conquer, prune and search, greedy strategies, or dynamic programming was used in a given algorithm.
2. Select and judge several promising paradigms and/or data structures (possibly slightly modified) for a given problem by analyzing the problem's properties.
3. Implement a solution to a problem using a specified algorithm design paradigm, given sufficient information about the form of that problem's solution.
4. Select, judge and apply promising mathematical techniques (such as asymptotic notations, recurrence relations, amortized analysis and decision trees) to establish reasonably tight upper and lower bounds on the running time of algorithms.
5. Recognize similarities between a new problem and some of the problems they have encountered, and judge whether or not these similarities can be leveraged towards designing an algorithm for the new problem.

The topics that we will be discuss in this course fall into two main categories. First, we will look at techniques that we can use to design efficient data structures and algorithms. Second, we will learn tools that make it possible to prove the correctness and the efficiency of the algorithms and data structures that we designed. More specifically, we will look at the following broad topics (not necessarily in this order):

• Searching and sorting;
• Data structures, such as skip lists.
• Mathematical tools, like O notation, recurrence relations, and amortized analysis;
• Algorithm design techniques, for instance randomization, greediness and dynamic programming.

Much of the material is formal (mathematical) in nature, and hence proofs will constitute an important part of the course.

At the end of the course, you will be able to:

1. Recognize which algorithm design technique(s), such as divide and conquer, prune and search, greedy strategies, or dynamic programming was used in a given algorithm.
2. Select and judge several promising paradigms and/or data structures (possibly slightly modified) for a given problem by analyzing the problem's properties.
3. Implement a solution to a problem using a specified algorithm design paradigm, given sufficient information about the form of that problem's solution.
4. Select, judge and apply promising mathematical techniques (such as asymptotic notations, recurrence relations, amortized analysis and decision trees) to establish reasonably tight upper and lower bounds on the running time of algorithms.
5. Recognize similarities between a new problem and some of the problems they have encountered, and judge whether or not these similarities can be leveraged towards designing an algorithm for the new problem.

This course covers application of machine learning tools, with an emphasis on solving practical problems. Also included in the course are data cleaning, feature extraction, supervised and unsupervised machine learning, reproducible workflows, and communicating results.

This course covers application of machine learning tools, with an emphasis on solving practical problems. Also included in the course are data cleaning, feature extraction, supervised and unsupervised machine learning, reproducible workflows, and communicating results.

This course covers application of machine learning tools, with an emphasis on solving practical problems. Also included in the course are data cleaning, feature extraction, supervised and unsupervised machine learning, reproducible workflows, and communicating results.

We introduce basic principles and techniques in the fields of data mining and machine learning. These are some of the key tools behind the emerging field of data science and the popularity of the "big data" buzzword. These techniques are now running behind the scenes to discover patterns and make predictions in various applications in our daily lives. We'll focus on many of the core data mining and machine learning technologies, with motivating applications from a variety of disciplines.

Either 211 or 210 will automatically suffice for the 344 pre-requisite.

Whereas CPSC 304 focuses on using a relational database management system (RDBMS), CPSC 404 focuses on the internals and performance issues of an RDBMS. Topics include: disks and the storage hierarchy, the I/O cost model, buffer pool management, disk scheduling, record layouts, metadata, system catalogs, tree-structured indexes (especially B+ trees), hash indexes, query evaluation, query optimization, transaction processing, concurrency, and crash recovery. 

Course learning outcomes for a typical term may include: 

• Explain and justify the I/O cost-based model for query evaluation in relational database management systems (RDBMSs).
• Recommend the most useful indexes for a set of tables, given some information about the expected query mix (e.g., the importance and frequency of expected queries).
• Show how to use an index (e.g., B+ tree, extendible hash structure, linear hash structure) to look up search keys in an index and the corresponding rows in a table. Demonstrate insertions and deletions of keys in the index, by performing splitting or merging of nodes.  Analyze the
• complexity of operations against these data structures.
• Explain the query evaluation and optimization decisions regarding joins, indexes, pipelining, selection, projection, etc. made by an RDBMS optimizer, given appropriate metadata.
• Estimate the I/O cost of evaluating and optimizing a given SQL query, given a set of indexes and appropriate metadata about the tables and indexes.
• Estimate the I/O cost of sorting a large file using external mergesort.
• Explain how transactions and concurrency are managed to permit greater throughput in an RDBMS. Explain how scheduling and deadlock are managed in a system that uses locks, and identify the types of anomalies and performance issues that can result.
• Define the following properties of database transactions, and give practical examples of their
• characteristics or desirable features: ACID properties, serializability, and isolation levels.
• Explain how logging works in a DBMS that uses the ARIES crash recovery algorithm. Provide
• guidelines for setting appropriate checkpoint intervals. Explain in detail, using examples, how crash recovery is performed.

The goal of this course is to give students experience designing, implementing, and extending programming languages. Students will start from a machine language, the x86-64 CPU instruction set with Linux system calls (x64), and incrementally build a compiler for a subset of Racket to this machine language. In the process, students will practice building, extending, and maintaining a complex piece of software, and practice creating, enforcing, and exploiting abstractions formalized in programming languages.
 
The course assumes familiarity with basic functional programming in Racket, and some simple imperative programming in assembly.

CPSC_V 417 approaches the modern Internet through a sequence of thematic modules covering application and content delivery, network security, Internet freedom, privacy and anonymity, and emerging directions such as QUIC, IPv6, programmable networks, and decentralized systems. Alongside the lectures, students complete hands-on assignments in which they operate real infrastructure, including setting up a virtual private server, registering a domain, deploying a website with TLS, hardening firewall rules, configuring a content delivery network and web application firewall, running their own mail domain, and analyzing QUIC traffic. Full details, including the reading list, grading breakdown, and project expectations, are posted at https://homepage.np-tokumei.net/teaching. Course pages are served only to the UBC network. If you are off campus, connect through the university VPN first.