Course Timetable

“Computational thinking is the thought processes involved in formulating problems and their solutions so that the solutions are in a form that can be effectively carried out by an information-processing agent” [Cuny, Snyder, Wing 10]. Computational thinking and its outcomes (i.e., computers, software, and their usage) are increasingly shaping the world in which we live. In order to be productive citizens of the 21st century, UBC students need to have the opportunity to learn concepts such as how data can be processed to gain insights, how computers use their personal data, and why computational thinking enables some amazing tasks (e.g., finding directions, sharing videos, and communicating instantly) but is as yet so bad at others (e.g., translating documents between languages). CPSC 100 will give non-computer science majors key insights into (1) the building blocks necessary for computational thinking (2) applications of computational thinking and (3) how computational thinking and its applications impact the world around them. Students will explore the past, present, and future of computing including a student directed exploration of computing and computational thinking issues in the news. This course is targeted to first year students, but is open to all.

“Computational thinking is the thought processes involved in formulating problems and their solutions so that the solutions are in a form that can be effectively carried out by an information-processing agent” [Cuny, Snyder, Wing 10]. Computational thinking and its outcomes (i.e., computers, software, and their usage) are increasingly shaping the world in which we live. In order to be productive citizens of the 21st century, UBC students need to have the opportunity to learn concepts such as how data can be processed to gain insights, how computers use their personal data, and why computational thinking enables some amazing tasks (e.g., finding directions, sharing videos, and communicating instantly) but is as yet so bad at others (e.g., translating documents between languages). CPSC 100 will give non-computer science majors key insights into (1) the building blocks necessary for computational thinking (2) applications of computational thinking and (3) how computational thinking and its applications impact the world around them. Students will explore the past, present, and future of computing including a student directed exploration of computing and computational thinking issues in the news. This course is targeted to first year students, but is open to all.

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.

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.

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.

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.

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.

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.

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?

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?

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

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. 
 

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 

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 

CPSC 310 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 to learn how to apply them to engineering modern software systems. The official course learning outcomes (CLOs) for CPSC 310 are:

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

CPSC 310 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 to learn how to apply them to engineering modern software systems. The official course learning outcomes (CLOs) for CPSC 310 are:

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

CPSC 310 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 to learn how to apply them to engineering modern software systems. The official course learning outcomes (CLOs) for CPSC 310 are:

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

CPSC 310 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 to learn how to apply them to engineering modern software systems. The official course learning outcomes (CLOs) for CPSC 310 are:

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

CPSC 310 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 to learn how to apply them to engineering modern software systems. The official course learning outcomes (CLOs) for CPSC 310 are:

1. 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 this course, we will streeeeetch our minds around two programming languages that you may find strange. Why bother doing that? You might go out and use these as your “home” programming languages for the rest of your career, but the real point is that stretching your concept of programs and programming will make you a better designer, programmer, and thinker.

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.

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.

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

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.

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.

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.

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.

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.

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.

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

This course continues with database topics beyond CPSC 304.  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, hash indexes, query evaluation, query optimization, transaction processing, concurrency, and crash recovery.  Note that some of these important topics also have applicability to areas outside of database systems.

This course continues with database topics beyond CPSC 304.  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, hash indexes, query evaluation, query optimization, transaction processing, concurrency, and crash recovery.  Note that some of these important topics also have applicability to areas outside of database systems.