Program Level OutcomesA successful student in the B.Sc. CS Major should meet the following educational goals:
 Technical understanding of computer science — Graduates should have a mastery of computer science, i.e., by applying ideas to solve problems from at least \( N \) of the core areas of computer science: algorithms and complexity, computer/systems architecture, computer/information security, data and information science, graphics/visualization, humancomputer interaction, intelligent systems, information management, networked/parallel/distributed computing, programming languages, software requirements/development.
(120, 125, 127, 130, 135, 213, 225, 295, 300, 307, 308, 310, 318, 340, 353, 354, 361, 365, 371, 383, 384, 404, 405, 407, 412, 414, 419, 431, 433, 454, 464, 466, 470, 471, 473, 474, 475)
 Problem solving skills — Graduates need to understand how to apply the knowledge they have gained to solve real problems, not just write code and move bits. They should be able to accurately assess problems and think about them creatively/conceptually/critically and to apply appropriate and efficient algorithms and mathematical models. They should realize that there are multiple solutions to a given problem and that selecting among them is not a purely technical activity, as these solutions will have a real impact on people's lives.
(M101, 120, 125, 127, 130, 135, 213, 225, 295, 307, 308, 340, 353, 354, 361, 363, 365, 371, 373, 384, 404, 405, 407, 412, 414, 419, 431, 456, 464, 466, 471, 473, 474, 475)
 Software development skills — Graduates should be able to apply good design principles for developing computer programs: elegance, simplicity, clear structure, flexibility, efficiency, usability, maintainability, and durability. They should be able to decompose simple application design problems into functional components, design/write/test/debug software solutions using appropriately chosen languages/tools for their implementation. Good design should be evident to both end users and other developers.
(120, 125, 127, 135, 213, 225, 295, 340, 354, 361, 363, 365, 371, 373, 383, 384, 412, 414, 419, 431, 433, 456, 464, 466, 470, 471, 473, 474, 475)
 Mathematics: theory and practice — Graduates should have a core set of mathematical skills and the related formal reasoning skills that are broadly applicable to computer science. Induction, recursion, asymptotic analysis, computability and heuristics are fundamental themes that graduates should be able to apply in practice.
(M101, 125, 127, 307, 308, 340, 361, 365, 384, 405, 407, 414, 419, 456, 466)
 Project experience — All graduates should have been involved in at least one substantial project. In most cases, this experience will be a software development project. Such projects should challenge students by being integrative, requiring evaluation of potential solutions, and requiring work on a larger scale than typical course projects.
(130, 135, 276, 353, 363, 365, 373, 414, 419, 433, 470, 471, 474)
 Commitment to professional responsibility — Graduates should recognize the social, legal, ethical, and cultural issues inherent in the discipline of computing. They must further recognize that social, legal, and ethical standards vary internationally. They should be knowledgeable about the interplay of ethical issues, technical problems, and aesthetic values that play an important part in the development of computing systems, including the burden of responsibility and the possible consequences of failure.
(105W, 125, 130, 135, 276, 320, 340, 373, 376W)
 Professional conduct — Graduates should embrace professional values like these: be honest and polite, take responsibility, meet obligations, be accountable, be dependable and consistent. They should perform work to high standards using all available best practices and will not sacrifice quality of work without the agreement of stakeholders.
(127, 276, 373)
 Communication and organizational skills — Graduates should have the ability to make effective presentations to a range of audiences about technical problems and their solutions, including why and how a solution solves the problem and what assumptions were made. This may involve facetoface, written, or electronic communication. They should be prepared to work effectively within diverse groups of people toward common goals. Graduates should be able to manage their own learning and development, including managing time, priorities, and progress.
(105W, 320, 353, 363, 376W, 414, 419)
 Awareness of the broad applicability of computing — Platforms range from embedded microsensors to highperformance clusters and distributed clouds. Computer applications impact nearly every aspect of modern life. Graduates should understand the full range of opportunities available in computing and be able to assess various technologies for use in a new development project.
(120, 307, 308, 320, 340, 361, 363, 404, 405, 407, 419, 456, 466, 470)
 Commitment to lifelong learning — Graduates should have information literacy, i.e., they should realize that the computing field advances at a rapid pace: specific languages and technology platforms change over time. Therefore, graduates need to realize that they must continue to learn and adapt their skills throughout their careers. To develop this ability, students should be exposed to multiple programming languages, tools, paradigms, and technologies as well as the fundamental underlying principles throughout their education.
(307, 308, 318, 320, 361, 404, 405, 407, 466)

Software Systems MajorThe core set of CS Major educational goals are amended as follows:
 Software development methodologies — Graduates should be able to develop largescale software within the software development life cycle, applying best practices within the spheres of: object oriented design and methodologies, collaborative and iterative software development processes, and software testing and reliability. They will be able to apply objectoriented concepts such as inheritance, polymorphism, interfaces and abstract classes, as well as object oriented design patterns such as observer, iterator, and singleton. Graduates will focus on the best practices of collaborative software development including managing complexity, designing maintainable software, and requirements gathering. They should be capable of systematic software testing and quality assurance, including systematic methods for security vulnerability discovery.
(135, 213, 276, 373, 433)
 Computer systems — Graduates will have deep knowledge in several areas of computer systems including operating systems, database systems, embedded systems, networks, and distributed systems.
(433, 471)
 Project experience — Graduates will have undertaken at least one semester long group project, refining their skills in communication, presentations, collaboration, and team dynamics. Many of the projects will have a real world problem/partner as their basis.
(130, 135, 276, 353, 363, 365, 373, 414, 419, 433, 470, 471, 474)

Dual Degree ProgramIn addition to meeting the core set of CS Major educational goals, successful students also meet the following educational goals:
 Multicultural/multilingual experience — Graduates should have an understanding of cultural and linguistic issues in diverse work environments through indepth experience studying and applying computing science concepts in both Eastern and Western cultures. They will appreciate cultural diversity in working environments, including extensive experience as a member of a cultural minority. Graduates will have a working ability to use two of the world's two most widely spoken languages.
 Personal growth — Graduates gain an understanding of their own abilities to work in diverse environments and how to overcome difficulties in new and challenging situations.
 Global leadership — Graduates have a solid foundational experience for career paths that lead to global technology leadership.

MACM 101 — Discrete Mathematics I 
Prereqs: BC Math 12 
Incomes: Upon entry to MACM 101, every student is expected to be able to ...  perform high school algebra

Outcomes: A — Assignment E — ExamAt the end of MACM 101, students will be able to ...  solve basic counting problems involving permutations and combinations. (A, E)
 use logical connectives and quantifiers in mathematical arguments. (A, E)
 prove validity of arguments employing rules of logical inference. (A, E)
 write simple Englishlanguage proofs using notation from logic and set theory. (A, E)
 use mathematical induction in simple proofs (A, E)
 introduce recursively defined sets and their relationship to mathematical induction. (A, E)
 define relations and functions using set theory (A, E)
 manipulate functions and relations and determine their common properties (A, E)
 solve problems and prove theorems related to divisibility, primality, and greatest common divisor. (A, E)
 solve basic probability problems (A, E)
 construct and manipulate sets, both finite and infinite, and apply the InclusionExclusion Principle to counting problems. (A, E)
 solve basic mathematical problems related to finite state machines. (A, E)

Program Level Educational Goals:  Mathematics: theory and practice (Introductory)
 Problem solving skills (Introductory)

CMPT 105W — Process, Form, and Convention in Professional Genres 
Prereqs: None 
Incomes: Upon entry to CMPT 105W, every student is expected to be able to ...  read/write/oralize/argue within the domain of the English language, at a level of mastery within the BC ENGL 12 (or equivalent) curriculum

Outcomes: A — Assignment Act — Inclass activity E — ExamAt the end of CMPT 105W, students will be able to ...  history of computing and engineering (E)
 modes of thinking in the sciences, computing, and engineering (E)
 ethical and moral responsibilities of computing and engineering professionals (Act, E)
 critical thinking (valid arguments, Bloom’s taxonomy, the scientific method) (A)
 discussion topics: free speech, privacy, intellectual property, big data, AI, etc (A, E)
 design persuasive and informative papers (rhetorical style) (A)
 presentation strategies and public speaking guidelines (A)
 copy editing (A)

Program Level Educational Goals:  Communication and organizational skills (IntroductoryIntermediate)
 Commitment to professional responsibility (IntroductoryIntermediate)

CMPT 120 — Intro to Computing Science and Programming I 
Prereqs: BC Math 12 
Incomes: Upon entry to CMPT 120, every student is expected to be able to ...  solve/manipulate/simplify/apply/analyse polynomial expressions and equations, perhaps containing several unknowns, at a level of mastery within the BC MATH 12 (or equivalent) curriculum
 read/write/oralize/argue within the domain of the English language, at a level of mastery within the BC ENGL 12 (or equivalent) curriculum

Outcomes: A — Assignment E — Exam MA — Major assignmentAt the end of CMPT 120, students will be able to ...  describe fundamental concepts pertaining to computing science: algorithms, programming, etc. (E)
 describe and apply fundamental concepts and terminology of Python: variables, types, functions, execution flow, etc. (A, E)
 create, analyze, and explain the behaviour of simple algorithms. (A, E)
 design, create, and test programs in Python (A, MA, E)
 create programs requiring approximately 100 lines.
 decompose logic into functions.
 use Python's data types (including objects) appropriately.
 program using predefined classes.
 design and implement simple recursive functions. (A, E)
 manipulate binary encodings of simple data types. (A, E)
 describe fundamental concepts of time complexity. (E)
 identify the order of basic algorithms. (E)
 describe the concept of recursive definitions and recursive functions; analyze, design and implement simple recursive functions. (E)
 use data files (subject to time availability) (A, E)
 apply programming to solve problems in fields outside of computing (A)

Program Level Educational Goals:  Technical understanding of computer science (Introductory)
 Problem solving skills (Introductory)
 Software development skills (Introductory)
 Awareness of the broad applicability of computing (Introductory)

CMPT 125 — Intro to Computing Science and Programming II 
Prereqs: CMPT 120 
Incomes: Upon entry to CMPT 125, every student is expected to be able to ...  understand/apply all basic syntax and control structures: variables, type, expression, condition, if/else, for, while, function, method.
 perform function parameter passing and determine the ramifications of using mutable/immutable types
 differentiate return vs print
 write program syntax to perform basic algebraic manipulations with simple functions, e.g. \( x \), \( x^2 \), \( 2^x \), \( \log_2{x} \), \( \log_{10}{x} \).
 derive binary representation of numbers and convert between decimal, hexadecimal, binary

Outcomes: A — Assignment Act — Inclass activity E — Exam L — LabAt the end of CMPT 125, students will be able to ...  program design, specification, and testing; problem solving [embedded in topics below] (L, E)
 write code in C (Act, L)
 measuring performance of algorithms [applied to all algorithms below] (A, E)
 recursion (A)
 searching and sorting algorithms (A, Act, E)
 abstract data types (stacks, queues, linked lists, graphs, trees) (Act, E)
 basic OOP concepts in C++ (Act)
 formal languages and finite state automata (A, E)
 computability (A) and complexity (A, E)
 introduction to ethics, copyright, and reliability. (E)

Program Level Educational Goals:  Technical understanding of computer science (Introductory)
 Problem solving skills (IntroductoryIntermediate)
 Software development skills (Introductory)
 Mathematics: theory and practice (IntroductoryIntermediate)
 Commitment to professional responsibility (IntroductoryIntermediate)

CMPT 127 — Computing Laboratory 
Prereqs: CMPT 120 
Incomes: Upon entry to CMPT 127, every student is expected to be able to ...  understand/apply all basic syntax and control structures: variables, type, expression, condition, if/else, for, while, function, method
 perform function parameter passing and determine the ramifications of using mutable/immutable types
 differentiate return vs print
 write program syntax to perform basic algebraic manipulations with simple functions
 create, analyze, and explain the behaviour of simple algorithms
 describe fundamental concepts of time complexity
 identify the order of basic algorithms
 design and implement simple recursive functions

Outcomes: At the end of CMPT 127, students will be able to ... Linux
 manipulate files and directories using Linux commands at the linux command line.
 compile and execute C programs using Linux commands at the linux command line and using makefiles.
Software Development Process
 design, implement and test C programs from a given problem statement and set of requirements.
 create and use header files containing function declarations.
 compile and execute C programs using Linux commands at the linux command line and using makefiles.
 compile a program from two source files.
 link to the standard math library.
 build programs from multiple source files.
Testing
 writing tests, using a test driver, to determine the correctness of functions.
Version Control System
 describe what a version control system and the advantages of using such system.
 set up a repository on a version control system.
 submit code for evaluation using a version control system.
 obtain the evaluation results through the version control system and interpret these results to facilitate troubleshooting.
C
 create and use variables of the native types and obtain their addresses.
 perform basic input and output on the console.
 create and use header files containing function declarations.
 write loops using the while and for syntax.
 write conditionals using the if syntax.
 create and use functions.
 create and use statically allocated arrays.
 create and use text strings (nullterminated character arrays).
 use arguments passed to main().
 write nested loops.
 create and use structured composite data types with typedef and struct.
 implement an interface to a data collection using structures.
 use fixedsize integer types.
 interpret integer arrays as images and operate on them.
 describe the difference between the size (capacity) of an array and the number of elements it contains.
 use variables (constants) to represent the size (capacity) of an array and the number of elements it contains in C programs (functions).
Memory
 state the difference between heap and stack memory allocation.
 for any variable declaration, determine whether it will be allocated on the stack or the heap and why.
 use malloc() and free() to manage heap memory.
File IO
 explain what XDR is, and how it relates to files.
 open files with fopen() with correct usage mode, and fclose() them.
 handle error codes returned from the relevant system calls.
 read and write to files with fread() and fwrite() using simple arrays and structs.
 describe the difference between a binary file and a text file.
 describe the possible formats of a file JSON.
Linked List
 implementing operations on linked lists.
 write an efficient list sort function.
Benchmarking
 use an explicit memory allocation strategy for high performance.
 measure runtime performance with gettimeofday().
C++
 use classes instead of structs.
 write constructors and destructors for classes.
 use twodimensional arrays.
 refactor code.
Assessment methods: All of the above learning outcomes are assessed using
 lab work (students submit their programs which are then compiled and tested using scripts),
 weekly assignments (which include code review), and
 examinations (lab quizzes) which include compilation and testing of submitted programs as well as code review.

Program Level Educational Goals:  Technical understanding of computer science (IntroductoryIntermediate)
 Problem solving skills (IntroductoryIntermediate)
 Software development skills (IntroductoryIntermediate)
 Mathematics: theory and practice (IntroductoryIntermediate)
 Professional conduct (IntroductoryIntermediate)

CMPT 128 — Intro to Computing Science and Programming for Engineers 
Prereqs: BC Math 12 
Incomes: Upon entry to CMPT 128, every student is expected to be able to ...  use a computer for basic tasks, including: booting up; logging in; using a webbrowser; downloading/uploading files from/to websites; installing software via GUI or terminal/command prompt (by following given instructions).

Outcomes: At the end of CMPT 128, students will be able to ...  navigate through folders on local disk; open, copy/paste, rename, and delete files; edit text files
 explain the basic components of a computer (memory, storage, processor, input/output devices)
 understand concepts related to programming:
 the basic functionality of a compiler and linker
 how variables are saved in memory, including the different computer representation of integers (unsigned and signed) and real numbers (floats and doubles)
 count number of operations performed by some code and understand Big O notation
 understand ASCII code
 read and understand the basic building blocks of a C/C++ code, predict what a given C/C++ code does, find errors in a given C/C++ code
 use C/C++ functions and write code to
 declare and initialize variables and constants of different types (e.g. integers and real numbers, Boolean, characters) and change the values of variables
 read data from user and display data on screen with specific formatting
 perform arithmetic, relational, and logical operations
 branch into and execute different statements based on certain conditions
 write loops and control their behaviour (e.g., number of iterations, terminate loops or skip to the next iteration)
 use file streams and functions to open files, read and write data from/to files, check for errors in handling files
 declare, initialize, and manipulate 1D and 2D arrays of different data types
 declare, initialize and manipulate pointers / addresses of different data types
 call, declare, and define functions
 solve some problems via recursion
 pass variables by value or by reference and pass pointers to functions
 perform dynamic memory allocation
 declare and manipulate strings of characters
 declare and manipulate structures
 write a piece of code solving a specified problem of at least 350 lines in length, by combining the use of many or all of the individual skills listed above.

Program Level Educational Goals: None 
CMPT 129 — Intro to Computing Science and Programming for Maths and Statistics 
Prereqs: CMPT 120 
Incomes: Upon entry to CMPT 129, every student is expected to be able to ...  write simple programs in Python including
 using loops and decision statements in Python Programs
 using I/O statements in Python
 using Python lists

Outcomes: At the end of CMPT 129, students will be able to ...  write C++ programs to solve a simple specified problem including
 creating, initializing and using C++ variables and constants including pointers, C++ loops and C++ decision statements (for, while, if, else, else if, switch)
 using C++ I/O, including file I/O. Understanding how stream I/O works and how to use it to verify input (using simple tests and exceptions.
 constructing and using C++ arrays (1D, 2D)
 constructing and using C++ functions using pass by value arguments and pass by reference arguments. This includes overloaded and recursive functions.
 constructing and using simple classes in C++ (not inheritance or polymorphism)
 use C++ libraries/objects for input/output, mathematical functions, random numbers, exceptions, timing and one example of basic containers.

Program Level Educational Goals: None 
CMPT 130 — Intro to Computer Programming I 
Prereqs: BC Math 12 
Incomes: Upon entry to CMPT 130, every student is expected to be able to ...  perform high school algebra

Outcomes: A — Assignment L — LabAt the end of CMPT 130, students will be able to ...  write small programs using C++ that are correct, efficient, and readable.
 solve small programming problems given just the statement of the problem.
 use all the basic concepts of mainstream programming languages, e.g. values, variables, ifstatements, loops, functions, parameter passing, records, files, arrays/vectors, etc.
 describe a simple model of computer memory useful for writing programs: e.g. simple stack frames, pointers.
 use basic software tools for editing, compiling, linking, building, debugging, etc. (A, L)
 describe a few of the main interest areas and applications of computer science.
 describe the representation of integer values in a computer system

Program Level Educational Goals:  Technical understanding of computer science (Introductory)
 Problem solving skills (Introductory)
 Project experience (Introductory)
 Commitment to professional responsibility (Introductory)

CMPT 135 — Intro to Computer Programming II 
Prereqs: CMPT 130 
Incomes: Upon entry to CMPT 135, every student is expected to be able to ...  write small programs using C++ that are correct, efficient, and readable.
 solve small programming problems given just the statement of the problem.
 use all the basic concepts of mainstream programming languages, e.g. values, variables, ifstatements, loops, functions, parameter passing, records, files, arrays/vectors, etc.
 describe a simple model of computer memory useful for writing programs: e.g. simple stack frames, pointers.
 use basic software tools for editing, compiling, linking, building, debugging, etc.
 describe a few of the main interest areas and applications of computer science.
 describe the representation of integer values in a computer system

Outcomes: At the end of CMPT 135, students will be able to ...  solve small programming problems using objectoriented programming.
 solve small programming problems using a premade library of standard algorithms and data structures.
 implement basic sorting and searching algorithms, such as linear search, binary search, insertion sort, and quicksort.
 design small programs using invariants, preconditions, and postconditions.
 test and debug programs.
 empirically estimate the running time of algorithms, and use elementary \( O\)notation to describe those running times.

Program Level Educational Goals:  Software development skills (IntroductoryIntermediate)
 Software development methodologies (Introductory)
 Problem solving skills (IntroductoryIntermediate)
 Technical understanding of computer science (IntroductoryIntermediate)
 Project experience (IntroductoryIntermediate)
 Commitment to professional responsibility (IntroductoryIntermediate)

CMPT 165 — Intro to the Internet and the World Wide Web 
Prereqs: None 
Incomes: Upon entry to CMPT 165, every student is expected to be able to ... This course has no universitylevel prerequisites, so our only assumptions are basic university entrance requirements...
 solve equations at a level of mastery within the BC Foundations of Mathematics 11 (or equivalent) curriculum.
 read/write/oralize/argue within the domain of the English language, at a level of mastery within the BC ENGL 12 (or equivalent) curriculum.

Outcomes: A — Assignment E — Exam L — LabAt the end of CMPT 165, students will be able to ...  list the different components associated with web based information systems. (E)
 explain how information is transmitted on the Internet, listing different data formats, protocols, and networks. (E)
 identify and design visually appealing and usable web sites. (A, L)
 use HTML to create static web pages and websites. (A, L, E)
 use a scripting language (such as Python or Javascript) to create simple dynamic web pages (clientside). (A, L, E)
 analyse the strengths and weaknesses of interactive web sites. (A, L)

Program Level Educational Goals: None 
CMPT 213 — Object oriented design in Java 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 213, every student is expected to be able to ...  write a small sized C++/Java object oriented program.
 design small object oriented program.
 apply knowledge of simple data structures like a list/array.

Outcomes: A — Assignment At the end of CMPT 213, students will be able to ...  competently write medium sized (615 class) programs in Java. (A)
 explain and apply code construction best practices, code quality smells, and refactoring.
 explain and apply object oriented ideas to medium sized programs: e.g., encapsulation, inheritance, polymorphism, interface/abstract base classes, immutability, anonymous classes, etc.
 create and express object oriented designs using CRC cards and UML class diagrams (practical parts only).
 critique the quality of a class’s public interface.
 understand and apply simple design patterns such as observer, iterator, strategy, modelview architecture.
 create a simple REST API on a Java backend (Springboot)

Program Level Educational Goals:  Software development skills (IntroductoryIntermediate)
 Software development methodologies (IntroductoryIntermediate)
 Problem solving skills (IntroductoryIntermediate)
 Technical understanding of computer science (Introductory)

CMPT 225 — Data Structures and Programming 
Prereqs: MACM 101, CMPT 125, CMPT 127, CMPT 135 
Incomes: Upon entry to CMPT 225, every student is expected to be able to ...  use all basic syntax and fundamental control structures of an object oriented programming language such as C++
 describe at least one simple sorting algorithm (such as selection sort, insertion sort and bubble sort) and linear and binary search
 implement simple programs using arrays, linked lists and/or vectors
 use classes to implement a simple ADT
 implement simple recursive algorithms
 describe \(O\)Notation and apply it to analyze algorithms
 write a proof using mathematical induction
 apply the basic principles of software design, implementation and testing

Outcomes: A — Assignment E — ExamAt the end of CMPT 225, students will be able to ...  select an appropriate data structure, from the data structures covered in CMPT 225, for a solution to a problem. (E)
 implement an application design, including an implementation of the chosen data structure(s) in an objectoriented programming language. (A, E)
 for each of the following data structures: lists, stacks, queues, trees, hash tables, heaps, priority queues (A, E):
 describe them
 list their public interface specifications
 implement them using both indexbased data structures and pointer based data structures where appropriate
 implement data structure methods both iteratively and recursively and discuss the impact of the implementation choice
 analyze the implementations in terms of time and space efficiency
 discuss their advantages and disadvantages
 describe, implement and analyze the time and space efficiency of the following sorting algorithms: merge sort, quick sort and simple sorting algorithms such as selection sort, insertion sort and bubble sort (A, E)
 explain \( O\)Notation and and describe the time complexity of arbitrary algorithms using \(O\)Notation (E)
 perform operations on data that are too large to fit in memory, e.g., external mergesort, index files and data files.

Program Level Educational Goals:  Software development skills (Intermediate)
 Problem solving skills (Intermediate)
 Technical understanding of computer science (Intermediate)

CMPT 276 — Intro to Software Engineering 
Prereqs: MACM 101, MATH 151, CMPT 225 
Incomes: Upon entry to CMPT 276, every student is expected to be able to ...  write simple object oriented C++ or Java programs
 do simple object oriented design

Outcomes: E — Exam P — ProjectAt the end of CMPT 276, students will be able to ...  software Processes: software life cycle, Agile vs plandriven development. (E)
 practical experience with a group applying an agile process. (P)
 requirements: system analysis and modeling, requirements specification (E)
 highlevel Design: UML, architectural, design patterns (E)
 implementation: coding style, code review, pair programming, refactoring (E)
 quality assurance: unit & integration testing (E)
 development tools: MVC pattern, revision control (P)
 ethics of software development (IEEE Guidelines) (E)
 introduction to legal issues such as non disclosure agreements and software licences (E)
 fundamental theories on group psychology and cognitive bias in Software Engineering (E)

Program Level Educational Goals:  Project experience (Intermediate)
 Software development methodologies (IntermediateAdvanced)
 Commitment to professional responsibility (Intermediate)
 Professional conduct (Intermediate)

CMPT 295 — Intro to Computer Systems 
Prereqs: MACM 101, CMPT 125, CMPT 127, CMPT 135 
Incomes: Upon entry to CMPT 295, every student is expected to be able to ...  proficiently write correct C programs of up to 150 lines, by applying the core programming constructs (variables, data types, pointers, if/else, switch/case, for/while/dowhile, function calls, recursion)
 recognize the basic stack operations
 derive binary conversions of unsigned data types, and perform basic arithmetic in binary
 interpret and manipulate Boolean algebra using and, or, not, xor
 perform basic combination/permutations combinatorics

Outcomes: A — Assignment E — Exam L — LabAt the end of CMPT 295, students will be able to ... Assembly language programming:
 proficiently write correct assembly language programs of moderate complexity (L, A, E)
 read, understand, and evaluate assembly language programs generated by a compiler (L, A, E)
C programming:
 apply low level code optimization techniques to C programs, including: memory aliasing, code motion, loop unrolling, factoring, inlining, cache friendly algorithms (A, E)
 benchmark the performance of their programs (L, A)
Binary Manipulation:
 encode/decode and perform simple arithmetic on binary numerical encodings: unsigned, 2’s complement, and IEEE 754 floating point (A, E)
 propose simple Instruction Set Architectures (ISA), perform binary encodings/decodings of machine level instructions with a variety of addressing modes, and evaluate an ISA within the context of the von Neumann bottleneck (L, A, E)
Architecture Design:
 describe the architecture of a computer and explain the purpose of each of its components: CPU, memory, peripherals and bus (E)
 describe the following concepts in digital design: combinational circuit, propagation delay, function unit, sequential circuit, state transition, systemwide clock (L, A, E)
 describe a staged model of computation for digital design, both serial and pipelined, and analyze the quantitative and qualitative aspects of such systems, including throughput, latency, cycle time, hazards/conflicts and speculation. (L, A, E)
 describe in detail cache algorithms (A, E)

Program Level Educational Goals:  Technical understanding of computer science (Intermediate)
 Problem solving skills (Intermediate)
 Software development skills (Intermediate)

CMPT 300 — Operating Systems I 
Prereqs: MACM 101, CMPT 225 
Incomes: Upon entry to CMPT 300, every student is expected to be able to ...  write simple C or C++ programs
 use makefile, gdb to build and debug C or C++ programs
 understand basic concepts in computer architecture, e.g., caching, storage
 think and solve problems

Outcomes: A — Assignment E — ExamAt the end of CMPT 300, students will be able to ...  explain the various concepts related to operating systems including: processes and threads, synchronization, memory management and virtual memory, file systems, deadlock handling, system calls, data races, classic IPC problems (A, E)
 implement OS components, e.g., syscall, synchronization primitives, file system, memory allocator, scheduling algorithms (A)
 implement efficient multithreaded programs in C/C++ using pthread libraries with synchronization and dynamic memory management, and evaluate the performance benefits of multithreading (A)
 use atomic instructions to construct synchronization primitives, e.g., mutex, semaphores (A, E)
 understand the fundamental issues of concern to computer security (E)

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)

CMPT 307 — Data Structures and Algorithms 
Prereqs: MATH 151, MACM 201, CMPT 225, MATH 232 
Incomes: Upon entry to CMPT 307, every student is expected to be able to ...  understand formal mathematical definitions.
 apply logical reasoning and give proofs (by induction, contradiction, etc.)
 provide asymptotic analysis of the time complexity for algorithms, and compare function using the asymptotic notation.
 read pseudocode descriptions of algorithms, and convert a pseudocode into an executable program in some programming language
 know basic data structures (and be able to implement them in some programming language): arrays, queues, stacks, linked lists, heaps
 understand the time complexity of an algorithm as a function of the input size.
 reason about graphs and trees by deriving and proving basic properties.
 reason using basic probability theory (probability and expectation calculations).
 know some efficient sorting algorithms (e.g., MergeSort)
 asymptotically solve basic recurrence relations (by substitution)

Outcomes: A — Assignment E — ExamAt the end of CMPT 307, students will be able to ...  understand and apply the basic mathematical foundations to build an RSA cryptosystem (A, E)
 formulate an algorithm design task for a given informally described realworld problem (A, E)
 know and apply basic algorithm design templates: greedy, divide & conquer, dynamic programming, network flows, randomized algorithms. (A, E)
 apply the Master Theorem to determine the run time of algorithms based on recurrence relations (A, E)
 apply some basic (and some advanced) data structures to speed up an implementation of an algorithm. (A, E)
 perform amortized analysis of a sequence of operations in an algorithm (on data structures). (A, E)
 reason about the correctness of algorithms (prove their correctness) (A, E)
 reason about the runtime of algorithms (argue the algorithm always terminates and show a reasonably tight upper bound on the number of steps needed). (A, E)
 apply an algorithm design template (e.g., greedy) to a given algorithm design task, and analyze the success (e.g., decide whether the algorithm is correct on all inputs: find a counterexample or prove the correctness) (A, E)
 know about NPcomplete problems for which none of the existing algorithm design templates are known to work, and be prepared to weaken the requirements for an algorithm (e.g., approximation, certain type of inputs only, “nontrivial” exponential time). (A, E)
 prove NPcompleteness using simple reductions. (A, E)
 design and analyze for correctness and runtime simple randomized algorithms. (A, E)

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Problem solving skills (IntermediateAdvanced)
 Mathematics: theory and practice (Advanced)
 Awareness of the broad applicability of computing (IntermediateAdvanced)
 Commitment to lifelong learning (IntermediateAdvanced)

CMPT 308 — Computability and Complexity 
Prereqs: MACM 201 
Incomes: Upon entry to CMPT 308, every student is expected to be able to ...  understand formal mathematical definitions.
 apply logical reasoning and give proofs (by induction, contradiction, etc.)
 provide asymptotic analysis of the time complexity for algorithms, and compare function using the asymptotic notation.
 reason about infinite sets (comparing the set of Naturals to the set of Reals).
 understand and reason in predicate logic.
 have a basic understanding of the concept of an algorithm.
 reason about graphs and trees.
 reason using basic probability theory.

Outcomes: E — Exam At the end of CMPT 308, students will be able to ...  prove that certain problems are undecidable (or not even semidecidable). (E)
 reason about regular expressions and languages: construct finite automata, or showing that no finite automata exist for a given language (using the Pumping Lemma). (E)
 write a computer program that prints itself, and understand the general principles that allow one to write such “selfaware” computer programs (via the Recursion Theorem). (E)
 prove that no perfect computer virus checking algorithm is possible. (E)
 understand the limitations of mathematical logic to reason about numbers (Godel’s Incompleteness Theorems), and understand the intrinsic connections between logic and computation. (E)
 understand the significance of NPcompleteness, and be able to prove certain problems NPcomplete. (E)
 work with randomized algorithms, and understand the extra power that randomness brings to computation. (E)
 show the limitations of approximation algorithms for NPhard problems (via the PCP Theorem). (E)
 understand that more computational resources (more time or memory) allows one to decide more languages (via the Hierarchy Theorems). (E)

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Problem solving skills (IntermediateAdvanced)
 Mathematics: theory and practice (Advanced)
 Awareness of the broad applicability of computing (IntermediateAdvanced)
 Commitment to lifelong learning (IntermediateAdvanced)

CMPT 310 — Artificial Intelligence Survey 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 310, every student is expected to be able to ...  employ propositional and predicate logic
 have basic knowledge of probability theory
 learn a new programming language
 design, implement, test, and document a significant programming project

Outcomes: At the end of CMPT 310, students will be able to ...  describe the general goals and major approaches of AI
 use the statebased model to describe and solve search problems
 use logic to describe and solve problems in knowledge representation
 formulate and solve constraint satisfaction problems
 be familiar with the agent based approach to AI
 describe approaches and problems in machine learning, and be able to apply certain machine learning techniques to solve problems involving data
 learn in more detail one, or more specific applications of AI, such as natural language processing, planning, uncertain reasoning, neural nets, robotics, etc.
Grading is made up of 4 assignments, a midterm test and a final exam 
Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)

CMPT 318 — Cybersecurity 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 318, every student is expected to be able to ...  effectively use their theoretical knowledge and practical skills related to algorithms and data structures, programming concepts, programming languages and coding for practical problem solving
 build on their mathematical knowledge and analytic skills, including a basic understanding of simple statistical and probability theory concepts
 collaborate with other students in small groups working on a term project
 master English language sufficiently well to follow lectures and tutorials, manage homework assignments and complete written exams under time constraints

Outcomes: A — Assignment Act — Inclass activity E — Exam P — Project Pres — PresentationAt the end of CMPT 318, students will be able to ...  appreciate cybersecurity as an interdisciplinary field of study building on classical information security, risk management, situation analysis, data analytics, applied cryptography, cyber forensics and several other areas; they will be able to differentiate the broader interdisciplinary scope from the core of cybersecurity which is a computingbased discipline involving technology, people, information, and processes to enable assured operations in the context of adversaries
(A, Act, E)
 understand fundamental cybersecurity concepts such as advanced persistent threat, attack surface, attack vector, zeroday exploits, intrusion detection and prevention, botnets, crypto currencies, blockchain technology, cyber intelligence, cyber situational awareness, risk assessment and mitigation strategies (A, E)
 combine basic concepts of statistical inference and learning with anomaly detection methods for behaviour based intrusion detection
(A, E)
 analyze and model simple stochastic processes such as Markov chains and Hidden Markov Models using basic time series analysis and forecasting methods (A, E)
 apply cyber security analytics to the problem of intrusion detection using streaming data from cyberphysical systems (P, Pres)
 understand systematic approaches to risk assessment based on Bayesian logic
(E)
 appreciate common concepts and applications of blockchain technology (Act, E)

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Commitment to lifelong learning (IntermediateAdvanced)

CMPT 320 — Social Implications  Computerized Society 
Prereqs: None 
Incomes: Upon entry to CMPT 320, every student is expected to be able to ...  express thoughts, ideas, and arguments, verbally and in writing, in English
 have had exposure to some university level courses (this is expressed as students being required to having earned 45 credits before taking this course)
 have taken at least one CS university level course

Outcomes: A — Assignment E — ExamAt the end of CMPT 320, students will be able to ... Demonstrate Theoretical Core Knowledge (A, E)
 distinguish and articulate different issues and problems with the use of computers and technology in general, from a philosophical, ethical, legal, social, and economic point of view.
 be aware of the conceptual foundations and historical background, of issues pertaining to information technology.
 explain and apply the following foundational concepts:
 epistemology, Science, scientific method, limits of knowledge.
 determinism (economic, technological)
 ethics: utilitarianism, deontology, relativism, objectivism.
 understand facts and terms pertaining to a number of major areas, such as:
 privacy and confidentiality.
 intellectual property, patents, contracts and licenses.
 hacking, computer crime, security, and frauds.
 free speech, netneutrality, international regulations.
Apply Theoretical Knowledge (A, E)
 demonstrate an ability to grow beyond one’s own assumptions/views/philosophy and move between different viewpoints on the social implications of computerization.
 demonstrate a critical awareness of current information technology issues and controversies that you may face as a computer professional, and as a member of a complex technological society.
 ability to ask critical, relevant, and substantial social questions regarding technology.
 analyze safety critical information systems failures from both technical and social factor perspectives.
 ability to discuss the benefits, the risks and the problems associated with computer technology in a number of major areas, such as:
 do research of scholarly materials relying on other tools besides popular search engines such as Google
 ask questions and reflect about the issues dealt in the course
 apply critical thinking in arguments and discussions
Understand Ethics and Professional Obligations (A, E)
 describe common sources of computer errors and failures; assign responsibility for failures.
 apply ethical standards with respect to privacy, confidentiality, piracy, plagiarism, and personal behaviour while using tools to gather information
 show respect for the opinions and contributions of others while participating in teamwork and discussions
Display Professional Communication Skills (A, E)
 ability to communicate effectively; present arguments and case studies, both orally and in writing.
 apply the course material to give reasoned arguments for their positions on specific problems arising from technology.
 apply the course material in decision making, in both personal and professional situations.
 write arguments in an informed way and with a respectful critical perspective about the issues dealt in the course

Program Level Educational Goals:  Commitment to professional responsibility (Advanced)
 Communication and organizational skills (IntermediateAdvanced)
 Awareness of the broad applicability of computing (Advanced)
 Commitment to lifelong learning (IntermediateAdvanced)

CMPT 340 — Biomedical Computing 
Prereqs: CMPT 125, CMPT 135 
Incomes: Upon entry to CMPT 340, every student is expected to be able to ...  write code using some programming or scientific computing language (e.g. C/C++, Java, Python, MATLAB)
 understand documentation for using and calling functions from external libraries
 follow instructions for installing software and perform other basic IT tasks
 describe highschool level concept in physics, biology, and chemistry
 apply highschool and firstyear undergraduate level concepts in mathematics (e.g. calculus, probability, trigonometry, vectors and matrices)

Outcomes: At the end of CMPT 340, students will be able to ...  define different biomedical data acquisition devices and biosignals
 explain the different mathematical and computer representation of biodata modalities
 give several examples of biomedical applications of computing
 extract various types of features from multimodal biodata
 appreciate the meaning and utility of some mathematical and computational methods and concepts and their application to biomedical data (e.g. Fourier analysis, convolution, correlation, nD histogram, highdimensional data, probability distributions, entropy, covariance matrix, eigendecomposition)
 perform/interpret basic feature selection and dimensionality reduction
 appreciate how computing plays a role in decision support
 represent some biomedical tasks (e.g. diagnosis) as classification problems
 calculate basic classification evaluation measures (e.g. true positive, confusion matrix, area under ROC)
 state/utilize Bayes’ theorem for estimating answers to healthrelated problems
 appreciate the strengths and limitations of using computers for biomedical applications
The above are evaluated via pencilandpaper/coding assignments, quizzes/exams, and project work. 
Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Problem solving skills (IntermediateAdvanced)
 Software development skills (IntermediateAdvanced)
 Mathematics: theory and practice (IntermediateAdvanced)
 Commitment to professional responsibility (IntermediateAdvanced)
 Awareness of the broad applicability of computing (IntermediateAdvanced)

CMPT 353 — Computational Data Science 
Prereqs: CMPT 225, STAT 270 
Incomes: Upon entry to CMPT 353, every student is expected to be able to ...  construct basic programs in Python.
 work with abstracted data structures and APIs.
 read API/library documentation and be able to use the API as a result.
 understand basic ideas of statistics: probability distributions, inferential statistics.

Outcomes: A — Assignment E — Exam P — ProjectAt the end of CMPT 353, students will be able to ...  assess a new data set and determine the kinds of manipulations that are necessary before performing further analysis (such as statistics or machine learning). (P)
 evaluate a new data set and determine data cleaning and extracttransformload operations that are necessary before further analysis; implement these steps with common programming tools (such as NumPy and Pandas). (A, P)
 describe various statistical tests: their assumptions, null and alternative hypotheses, how to interpret their results; assess their usefulness for a particular problem; use these tests with common programming libraries (such as SciPy). (A, E)
 describe various machine learning algorithms: their basic operation, what they assume about their inputs, and what kinds of predictions they make; assess their usefulness for a particular problem; use these techniques with common programming libraries (such as ScikitLearn); tune the models for best results. (A, E)
 carry out basic analysis on "big data" using common big data tools (such as Spark); interpret performance of these tools, diagnose the performance, and develop reasonably efficient implementations of analyses using them. (A, E)
 communicate results of data analysis in a way that is both correct and readable to a nontechnical audience. (A, P)
 when presented with a databased problem, assess various tools and techniques for applicability; construct a plan to clean and analyze the data, and present results. (P)

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Problem solving skills (IntermediateAdvanced)
 Project experience (IntermediateAdvanced)
 Communication and organizational skills (IntermediateAdvanced)

CMPT 354 — Database Systems I 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 354, every student is expected to be able to ...  design and implement programs with multiple classes
 define set operations  union, intersection, set difference and Cartesian product)
 describe data structures (arrays, linked lists, trees and hash tables)
 describe the efficiency of algorithms using \(O\)Notation

Outcomes: A — Assignment E — ExamAt the end of CMPT 354, students will be able to ...  describe concepts relating to the design and implementation of DBs: the advantages and the components of a DBMS, and levels of abstraction. (E)
 design and create entity relationship diagrams. (A, E)
 describe the relational model, translate an ERD into a set of tables, and create an SQL DB using the SQL DDL. (A, E)
 construct relational algebra queries. (A, E)
 construct SQL queries for data retrieval. (A, E)
 create SQL queries to implement constraints, assertions and triggers. (A, E)
 describe normalization and apply normalization concepts to decompose a DB schema into 3NF or BCNF. (A, E)
 describe methods for integrating a DB with an application. (A, E)
 design, create and test a DB using a DBMS. (A, E)
 describe the major types of NoSQL DBs (E)

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Problem solving skills (IntermediateAdvanced)
 Software development skills (IntermediateAdvanced)

CMPT 361 — Introduction to Computer Graphics 
Prereqs: CMPT 225, MATH 232 
Incomes: Upon entry to CMPT 361, every student is expected to be able to ...  understand basic linear algebra concepts such as vectors and matrices.
 understand basic trigonometry.
 use data structures such as arrays, trees, and graphs.
 write basic algorithms such as depthfirst tree traversal, recursive functions.

Outcomes: At the end of CMPT 361, students will be able to ...  carry out 3D geometric, viewing and projection transformations in homogeneous coordinates.
 implement the Phong local illumination model and Phong shading method.
 use basic modeling techniques such as meshing and subdivision.
 use discrete techniques such as texture mapping and environment mapping.
 describe most commonly used clipping, rasterization, and hidden surface removal algorithms.
 explain sampling issues and basic antialiasing techniques.
 construct and use hierarchical models such as Scene Graphs.
 write OpenGL/WebGL code with vertex and fragment shaders for displaying and interacting with static and dynamic/animated scenes.
 explain pipeline graphics, and its pros and cons wrt global rendering techniques such as ray tracing.

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Problem solving skills (IntermediateAdvanced)
 Mathematics: theory and practice (Advanced)
 Software development skills (IntermediateAdvanced)
 Awareness of the broad applicability of computing (IntermediateAdvanced)
 Commitment to lifelong learning (IntermediateAdvanced)

CMPT 363 — User Interface Design 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 363, every student is expected to be able to ...  write computer programs of at least 200 lines of code
 be able to coherently present a short argument, in oral and written form (in English)
 understand the fundamentals of computing science

Outcomes: At the end of CMPT 363, students will be able to ... Design process:
 design and evaluate a simple interactive user interface using an iterative, usercentered approach
 understand similarities and differences in designing for a range of interactive systems from graphical user interfaces to natural user interfaces
 present (in either oral or written form) their designs and evaluation results, supporting their claims with evidence from usability tests and inspections and justifying their recommendations according to psychology and design principles
User research:
 conduct user research using techniques such as contextual inquiry and interviews to learn about end users of a system
 analyze data from user research to summarize users’ goals, tasks, and domain, and the environment where the system will be used
Interaction design:
 develop several styles of prototypes: paper and executable forms, low and highfidelity, as appropriate using user interface (UI) and user experience (UX) design principles
 describe the range of abilities that must be supported by interfaces for a broad audience, including ranges of sensory, cognitive and physical capabilities
Usability evaluation:
 evaluate a user interface with a usability test, including interacting with the user, directing the session to gather the most interesting results, recording the data, and operating the prototype.
 evaluate a user interface using inspection methods (such as heuristic evaluation), which do not require sample users and testing methods.
 describe problems in usability or usefulness using the language of psychology and interface design and suggest designs based on this analysis.
General:
 pay attention to their discomforts, problems, and satisfaction when using interfaces in every area of their life
 create usercentered interfaces for any interactive application that they build in the future

Program Level Educational Goals:  Problem solving skills (IntermediateAdvanced)
 Software development skills (IntermediateAdvanced)
 Project experience (Advanced)
 Communication and organizational skills (Advanced)
 Awareness of the broad applicability of computing (IntermediateAdvanced)

CMPT 365 — Multimedia Systems 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 365, every student is expected to be able to ...  design and create programs in at least one programming language (C/C++ or Java preferred).
 recall basic terms and operations of calculus, linear algebra and probability
 design data structures for list/tree/matrix representations, and implement their relevant algorithms.
 plan a development project from requirements to final implementation

Outcomes: A — Assignment E — Exam P — Project Q — QuizAt the end of CMPT 365, students will be able to ...  understand the digitization process of audio, image, and video, including signal sampling, discretization, color representation (A, Q, E, P)
 familiar with the typical formats of uncompressed digital audio, image and video in computer (A, Q, E, P)
 understand the theory of lossless compression and the typical tools, including Huffman coding and arithmetic coding (A, Q, E, P)
 understand the theory of lossy coding and the typical tools, including quantization, 1D and 2D transforms (A, Q, E, P)
 familiar with the typical formats of compressed digital audio, image and video on computer, including MP3, JPEG, MPEG and H.26x (A, Q, E, P)
 understand the system and protocol design for multimedia streaming over the Internet (A, Q, E, P)

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Problem solving skills (IntermediateAdvanced)
 Software development skills (IntermediateAdvanced)
 Mathematics: theory and practice (IntermediateAdvanced)
 Project experience (Advanced)

CMPT 371 — Data Communications and Networking 
Prereqs: MATH 151, CMPT 225 
Incomes: Upon entry to CMPT 371, every student is expected to be able to ...  create and run programs (C/C++, Python preferred)
 apply basic concepts of calculus, linear algebra, and probability

Outcomes: A — Assignment E — Exam P — Project Q — QuizAt the end of CMPT 371, students will be able to ... Knowledge Base (Q, E)
 describe layered architecture, identify the network edge and the network core, and explain what a protocol is
 explain the client/server model, and describe some application layer protocols (e.g., Web, FTP, email)
 describe the implementation of multiplexing and demultiplexing as well as connectionoriented and connectionless networks
 describe the key functions of UDP
 explain how to construct a reliable data transport protocol
 describe the flow control and congestion control for TCP
 describe the hierarchy of Internet and the algorithms for intraAS and interAS routing
 describe the IP addressing mechanism
 describe how multiple access protocols work, including channel partitioning and random access protocols
Design Skills (A, E)
 analyze network performance at various levels of the stack
Handson Skills (A, P)
 evaluate various protocols using software tools (e.g., Wireshark)
 create socket programs
 create networks with specified addressing and subnettig

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Problem solving skills (IntermediateAdvanced)
 Software development skills (IntermediateAdvanced)

CMPT 373 — Software Development Methods 
Prereqs: CMPT 276 
Incomes: Upon entry to CMPT 373, every student is expected to be able to ...  design and write medium sized object oriented programs in C++/Java
 be familiar with basic design patterns (such as observer, or iterator)
 be familiar with code quality.
 use a revision control system such as Git.
 create tests and use unit testing

Outcomes: A — Assignment CR — Code review P — Project Q — QuizAt the end of CMPT 373, students will be able to ...  work effectively as a developer in a large agile software development team (~8 people) on a large project; work within a development process (e.g. Scrum), and have effective teamwork skills. (P, Q)
 competently use revision control for source code management and project coordination (pull/merge requests, issues, etc.) (A, P, Q)
 elicit requirements and product feedback from an end user. (P, Q)
 critique object oriented designs by using knowledge of design principles and a couple design patterns. (P, Q)
 understand trade offs between performance, reliability, and ease of extension in system design. (P, Q)
 construct new system designs and design patterns that meet requirements. (P, Q)
 create comprehensive unit tests for a simple module. (A, Q)
 contribute substantial high quality code to a large software project. (P, CR)

Program Level Educational Goals:  Project experience (Advanced)
 Software development skills (Advanced)
 Software development methodologies (Advanced)
 Problem solving skills (IntermediateAdvanced)
 Commitment to professional responsibility (Advanced)
 Professional conduct (Advanced)

CMPT 376W — Technical Writing and Group Dynamics 
Prereqs: CMPT 276 
Incomes: Upon entry to CMPT 376W, every student is expected to be able to ...  write a basic academic argument of two pages or more.
 write in accordance with the basic elements of punctuation and grammar for formal edited English
 describe the basic concepts in a range of computer subfields, equivalent to what they would have learned in the CMPT 1XX and 2XX courses.
 use diagrams to portray complex relationships between entities and actions, as they would have learned in CMPT 275 or CMPT 276

Outcomes: A — Assignment E — Exam J — JournalingAt the end of CMPT 376W, students will be able to ...  have familiarity with the technical document creation process: (A, J, E)
 rough draft/prototype
 iterative drafts
 "final" draft
 make appropriate use of diagrams and figures to support their argumentation. (A, E)
 incorporate use of examples and formulas to help explain complex concepts (A, E)
 use sources correctly and ethically (A, E)
 edit writing to: (A, J, E)
 improve clarity
 to make it cohesive and coherent
 add elements of grace
 style and voice
 organize articles according to the standard genres of computing science (A, J)
 use the argument styles characteristic of computing, including explanatory articles, persuasive articles, and descriptions of processes (A, J, E)
 argue from performance data by incorporating quantitative arguments, summarizing results at a level that conveys the main argument while also presenting any substantial qualifications (A, J, E)
 develop familiarity with writing guidelines, conventions, and etiquette; resolve contradictions & inconsistencies in guidelines, "writing rules", code reviews , etc. (A, J, E)
 have familiarity with the spectrum of technical document types (resumes, emails, documentation, proposals, etc.) (A, J)
 write collaboratively through peer reviews (A, J)
 edit realworld documentation (e.g., on GitHub, Stack Overflow, etc.) (A, J)

Program Level Educational Goals:  Communication and organizational skills (Advanced)
 Commitment to professional responsibility (IntermediateAdvanced)

CMPT 379 — Principles of Compiler Design 
Prereqs: MACM 201, CMPT 225, CMPT 295 
Incomes: Upon entry to CMPT 379, every student is expected to be able to ...  write complex, 1000+ line programs
 write code in more than one programming language
 understand the compiler tool chain
 understand concepts in assembly language
 understand modern computer architecture

Outcomes: At the end of CMPT 379, students will be able to ...  write a compiler for a programming language
 understand syntax of programming languages
 understand semantics of programming languages
 understand code generation
 understand basics of code optimization

Program Level Educational Goals: None 
CMPT 383 — Comparative Programming Languages 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 383, every student is expected to be able to ...  implement data structures and algorithms in at least one programming language.
 use major programming language features, such as objects and recursion.
 use firstorder logic and set theory

Outcomes: At the end of CMPT 383, students will be able to ...  design and implement programs using functional programming techniques.
 compare and contrast major features of a variety of different programming languages.
 use some other major programming approach, such as declarative or logic programming, or one of the many approaches to concurrency.
 specify the syntax and semantics of programs.
 define important programming language concepts, such as scope, static/dynamic features, types, flow constructs, etc.

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Software development skills (Advanced)

CMPT 384 — Symbolic Computing 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 384, every student is expected to be able to ...  understand mathematical induction.
 understand the elements of propositional and predicate calculus.
 recognize and understand regular and contextfree grammars.
 design and implement programs and data structures.

Outcomes: A — Assignment E — ExamAt the end of CMPT 384, students will be able to ...  understand the representation of mathematical expressions, logical formulas, regular expressions and programming language structures as symbolic data domains (A, E)
 design and implement abstract syntax tree representations for symbolic data domains (A, E)
 represent the concrete form of symbolic data using contextfree grammars (A, E)
 design and implement simple recursivedescent parsers for symbolic data (A, E)
 design and implement insideout simplification algorithms on symbolic data (A, E)
 design and implement evaluators for mathematical expressions and logical formulas (A, E)
 design and implement simple interpreters for programming languages (A, E)
 understand important transformations in logic including conversion to conjunctive normal form, unification and the resolution inference rule (A, E)
 design and implement symbolic computing applications using functional programming languages (A, E)

Program Level Educational Goals:  Technical understanding of computer science (IntermediateAdvanced)
 Problem solving skills (IntermediateAdvanced)
 Software development skills (IntermediateAdvanced)
 Mathematics: theory and practice (IntermediateAdvanced)

CMPT 404 — Cryptography and Cryptographic Protocols 
Prereqs: MACM 201 
Incomes: Upon entry to CMPT 404, every student is expected to be able to ...  understand formal mathematical definitions.
 apply logical reasoning and give proofs (by induction, contradiction, etc.)
 provide asymptotic analysis of the time complexity for algorithms as they relate to the input size, and compare such functions using asymptotic notation.
 read pseudocode descriptions of algorithms, and convert pseudocode into an executable program in some programming language
 reason using basic probability theory (probability and expectation calculations).
 understand modular arithmetic and basic number theory
 have a basic understanding of the structure of the Internet

Outcomes: At the end of CMPT 404, students will be able to ...  summarize the goals and the place of cryptography in the broad computer security area
 apply the general principles and standards of modern cryptosystems
 use the basic cryptographic primitives such as pseudorandom generators, hash functions, etc.
 explain the main types attack on a cryptosystem and how they are prevented
 understand the design of main symmetric cryptosystems, AES
 describe the basic asymmetric cryptosystems and their vulnerabilities
 apply cryptographic primitives for authentication and other simple protocols
 be aware of the ways cryptosystems used in communication protocols such as WPA, SSL, etc
 be aware of modern applications of cryptography in zero knowledge, electronic commerce, crypto currencies, online voting, etc.

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Awareness of the broad applicability of computing (Advanced)
 Commitment to lifelong learning (IntermediateAdvanced)

CMPT 405 — Design and Analysis of Computing Algorithms 
Prereqs: CMPT 307 
Incomes: Upon entry to CMPT 405, every student is expected to be able to ...  understand formal mathematical definitions.
 apply logical reasoning and give proofs (by induction, contradiction, etc.)
 provide asymptotic analysis of the time complexity for algorithms as a function of the input size, and compare functions using the asymptotic notation.
 read pseudocode descriptions of algorithms, and convert pseudocode into an executable program in some programming language
 discuss/implement basic data structures: arrays, queues, stacks, linked lists, heaps
 derive and prove basic properties of graphs and trees
 reason using basic probability theory (probability and expectation calculations).
 describe some efficient sorting algorithms
 asymptotically solve basic recurrence relations (by substitution)
 apply basic algorithm design templates: greedy, divide and conquer, dynamic programming, network flows, randomized algorithms
 apply some basic (and some advanced) data structures to speed up an implementation of an algorithm
 perform amortized analysis of a sequence of operations in an algorithm (on data structures)
 prove the correctness of algorithms
 reason about the runtime of algorithms (argue the algorithm always terminates and show a reasonably tight upper bound on the number of steps needed)
 apply an optimization design template (e.g., greedy) to a given algorithm design task, and decide whether the algorithm is correct on all inputs
 have an awareness of NPcomplete problems for which none of the existing algorithm design templates are known to work, and be prepared to weaken the requirements for an algorithm
 prove NPcompleteness using simple reductions
 design and analyze for correctness and runtime simple randomized algorithms

Outcomes: At the end of CMPT 405, students will be able to ...  design and analyze efficient algorithms using basic templates (greedy, divide and conquer, dynamic programming, network flows), as well as combine different templates to design more efficient "hybrid"type algorithms.
 use Linear Programming to design efficient algorithms (for exact and approximation algorithms).
 cope with NPcomplete problems using more advanced understanding of different types of algorithms (exact, approximation, special classes of inputs, heuristics).
 use and analyze some simple cases of Local Search algorithms.
 design and reason about randomized algorithms (including the use of Chebyshev and Chernoff bounds).
 derandomize a certain class of randomized algorithms using pairwise independent hash functions.
 design and analyze some basic streaming algorithms (e.g., Heavy Hitters and Distinct Elements)

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Mathematics: theory and practice (Advanced)
 Awareness of the broad applicability of computing (Advanced)
 Commitment to lifelong learning (IntermediateAdvanced)

CMPT 407 — Computational Complexity 
Prereqs: CMPT 307 
Incomes: Upon entry to CMPT 407, every student is expected to be able to ...  understand formal mathematical definitions.
 apply logical reasoning and give proofs (by induction, contradiction, etc.)
 provide asymptotic analysis of the time complexity for algorithms as a function of the input size, and compare functions using the asymptotic notation.
 reason about infinite sets (comparing the set of Naturals to the set of Reals).
 explain the concept of an efficient algorithm
 reason probabilistically
 do basic linear algebra (know about matrices and matrix operations).

Outcomes: At the end of CMPT 407, students will be able to ...  reason about the complexity of computational problems in different frameworks (time, space, circuit complexity, randomized, and quantum complexity)
 understand the concept of the universal Turing machine (UTM), and be aware of an efficient construction of the UTM.
 be aware of the intermediate problems in NP (between P and NPcomplete), as well as the dichotomy (either P or NPcomplete) for the special case of Constraint Satisfaction Problems.
 understand the proof of CookLevin’s Theorem that kSAT is NPcomplete, and understand the complexity of SAT variants.
 reason about the Polynomial Time Hierarchy, and understand that a fast algorithm for kSAT would imply a fast algorithm for formulas with a bounded number of firstorder quantifiers.
 be aware of various circuit complexity classes, and the relation between algorithms and circuits.
 be familiar with various randomized complexity classes, and the power of randomness in computation (including randomized generalizations of NP, interactive proofs, and PCPs).
 reason about simple Quantum Algorithms (understand the model of Quantum Computer).
 appreciate the importance of open questions in Complexity Theory (P vs NP, circuit complexity, etc.), and understand some formal “barriers” we currently face trying to resolve these fundamental questions (e.g., relativization, and natural proofs).

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Mathematics: theory and practice (Advanced)
 Awareness of the broad applicability of computing (Advanced)
 Commitment to lifelong learning (IntermediateAdvanced)

CMPT 411 — Knowledge Representation 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 411, every student is expected to be able to ...  be broadly aware of the core themes within artificial intelligence
 manipulate formal logic

Outcomes: A — Assignment E — ExamAt the end of CMPT 411, students will be able to ... The student will have knowledge of: (A, E)
 logic: expressing knowledge, firstorder logic, Horn clause logic
 rulebased systems (including working with definite clauses and Datalog)
 answer set programmming
 description Logics
 defaults
 diagnosis and abductive explanation
 reasoning about action
 argumentation
 expressiveness and tractability

Program Level Educational Goals: None 
CMPT 412 — Computational Vision 
Prereqs: MATH 152, CMPT 225 
Incomes: Upon entry to CMPT 412, every student is expected to be able to ...  create/apply basic data structures
 perform linear algebra and write code executing matrix vector operations.
 perform basic calculus
 implement/debug complex algorithms

Outcomes: At the end of CMPT 412, students will be able to ...  describe/explain a wide range of computer vision concepts such as image filtering, convolution, Laplacian, gradient, image warping, camera parameters, reconstruction, recognition, stereo, optical flow, and deep neural networks as applied to vision.
 implement computer vision algorithms following their highlevel descriptions.
 implement/debug very complex algorithms

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Software development skills (Advanced)

CMPT 413 — Computational Linguistics 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 413, every student is expected to be able to ...  perform basic probability and statistics
 perform vector calculus and linear algebra
 design and write nontrivial (~500 line) programs in a high level language like Python
 think, and not expect spoon feeding of every single fact or inference required to solve assignments and exams
 describe some machine learning concepts

Outcomes: A — Assignment E — Exam P — Project Pres — PresentationAt the end of CMPT 413, students will be able to ...  apply NLP models and algorithms to build applications (A, P)
 appreciate the complexity of understanding human languages using computers (A, P, Pres, E)
 be aware of multilingual NLP, not just NLP for English (A)

Program Level Educational Goals: None 
CMPT 414 — ModelBased Computer Vision 
Prereqs: MATH 152, CMPT 225 
Incomes: Upon entry to CMPT 414, every student is expected to be able to ...  implement/apply basic data structures and algorithms
 design and write code of at least 500 lines
 work as a member of a team project
 perform basic probability and statistics
 perform vector calculus and linear algebra

Outcomes: A — Assignment E — Exam P — ProjectAt the end of CMPT 414, students will be able to ...  implement/test several image processing techniques (filtering, enhancement, edge detection, etc.) using MATLAB as a primary tool (A, E)
 describe/explain the fundamentals of modelbased computer vision: 2D and 3D representations of visual objects, basic and modern matching algorithms, stereo vision, and machine learning (neural network) approach to computer vision. (A, P, E)

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Software development skills (Advanced)
 Mathematics: theory and practice (Advanced)
 Project experience (Advanced)
 Communication and organizational skills (IntermediateAdvanced)

CMPT 417 — Intelligent Systems 
Prereqs: CMPT 225 
Incomes: None 
Outcomes: None 
Program Level Educational Goals: None 
CMPT 419 — Machine Learning 
Prereqs: CMPT 225 
Incomes: Upon entry to CMPT 419, every student is expected to be able to ...  perform the basic manipulations of linear algebra, calculus, and probability
 design and implement programs of a reasonable size in Python
 plan a group development project from requirements to final implementation

Outcomes: At the end of CMPT 419, students will be able to ...  create, train, and validate basic machine learning models such as linear models, graphical models, and neural networks
 describe/apply methods for addressing overfitting and their probabilistic implications
 describe/apply basic optimization algorithms used in machine learning
 apply and repurpose existing machine learning models for a different application
 read, understand, and reproduce results of stateoftheart academic papers in Machine Learning

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Awareness of the broad applicability of computing (Advanced)
 Problem solving skills (Advanced)
 Mathematics: theory and practice (Advanced)
 Software development skills (Advanced)
 Communication and organizational skills (Advanced)
 Project experience (Advanced)

CMPT 431 — Distributed Systems 
Prereqs: CMPT 300, CMPT 371 
Incomes: Upon entry to CMPT 431, every student is expected to be able to ...  think and solve problems
 explain basic concepts in operating systems, computer networks and computer architecture
 write efficient C++ programs, and simple C++ programs with Pthreads and synchronization primitives
 use makefiles to build and gdb to debug C++ programs

Outcomes: A — Assignment E — ExamAt the end of CMPT 431, students will be able to ...  explain concepts related to parallel and distributed systems including: (A, E)
 concurrency
 task decomposition and mapping
 consistency models (linearizability, sequential consistency)
 concurrent data structures
 advanced synchronization/coordination primitives (barriers, reduction/aggregation)
 distributed computing principles (causal ordering)
 timing
 global state and snapshots
 group communication
 fault tolerance and consensus
 implement efficient parallel and distributed programs (A, E)
 measure and analyze performance and scalability issues in parallel and distributed programs (A, E)
 identify, formulate and solve complex engineering problems using scalable parallel and distributed system designs (A, E)
 develop and conduct appropriate experimentation, analyze and interpret data, and use engineering judgment to draw conclusions. (A, E)

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Software development skills (Advanced)

CMPT 433 — Embedded Systems 
Prereqs: CMPT 295, CMPT 300 
Incomes: Upon entry to CMPT 433, every student is expected to be able to ...  implement medium size programs in C/C++/Java which use some dynamic memory allocation.
 write programs that apply processes, threads, synchronization.
 apply OS related concepts of file systems, syscalls, interrupts

Outcomes: At the end of CMPT 433, students will be able to ...  proficiently develop medium sized multithreaded embedded Linux programs
 write well designed modular C programs
 understand and write programs to use embedded hardware via Linux (GPIO, I2C, A2D, PWM, etc)
 use crossplatform development tools (gcc, gdb, etc)
 understand and develop simple Linux drivers
 write simple bare metal (no OS) programs
 describe how to interact with and wire basic hardware circuits (LEDs, resistors, buttons)
 create embedded systems which use a network (e.g., UDP, basic Node.js, basic HTML/CSS/JavaScript)

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Computer systems (Advanced)
 Project experience (Advanced)
 Software development skills (Advanced)
 Software development methodologies (IntermediateAdvanced)

CMPT 441 — Computational Biology 
Prereqs: CMPT 307 
Incomes: Upon entry to CMPT 441, every student is expected to be able to ...  understand formal mathematical definitions.
 apply logical reasoning and give proofs (by induction, contradiction, etc.)
 provide asymptotic analysis of the time complexity for algorithms as a function of the input size, and compare functions using the asymptotic notation.
 read pseudocode descriptions of algorithms, and convert pseudocode into an executable program in some programming language
 discuss/implement basic data structures: arrays, queues, stacks, linked lists, heaps
 derive and prove basic properties of graphs and trees
 asymptotically solve basic recurrence relations (by substitution)
No prior knowledge in Molecular Biology is assumed. 
Outcomes: At the end of CMPT 441, students will be able to ...  describe the basics of Molecular Biology
 identify problems in Molecular Biology that are suitable for a computational solution
 describe/design/analyze the following algorithms:
 search algorithms for mapping DNA and finding signals
 greedy algorithms for finding signals and genome rearrangements, including approximation algorithms
 dynamic programming algorithms for comparing sequences
 evolutionary algorithms for ordering problems including RNA folding
 divideandconquer algorithms for comparing sequences
 combinatorial algorithms for repeat finding
 clustering and tree approaches for gene expression analysis
 hidden Markov models for finding signals
 formally explain the complexity and incompleteness of mathematical and physical models to describe real biological phenomena and then design appropriate algorithms to deal with this

Program Level Educational Goals: None 
CMPT 454 — Database Systems II 
Prereqs: CMPT 300, CMPT 354 
Incomes: Upon entry to CMPT 454, every student is expected to be able to ...  apply basic database concepts such as SQL
 be familiar with basic OS concepts such as memory, disk architectures, locking mechanisms
 be familiar with basic architecture concepts such as processors, caching, storage hierarchy
 write simple programs in C/C++

Outcomes: A — Assignment E — Exam P — ProjectAt the end of CMPT 454, students will be able to ...  describe the I/O based cost metrics of database processing (A, E)
 explain the physical details of query processing (A, E)
 explain how data integrity may be violated (A, E)
 explain how data integrity is enforced through concurrency control in multiuser settings (A, E)
 explain how data consistency is maintained against system crashes (A, E)
 implement major components of a database system, e.g., lock manager, index, buffer pool, concurrency control (A, P)
 use tools from operating systems and programming runtime/libraries such as pthread libraries, C++ STL (A, P)
 compare the pros and cons different highlevel design decisions of database systems (E)
 explain physical database storage and buffer management (A, E)
 describe B+ trees and extensible and linear hashing indexes in the context of a database system and understand their search, insertion and removal algorithms (A, E)

Program Level Educational Goals:  Technical understanding of computer science (Advanced)

CMPT 456 — Information Retrieval and Web Search 
Prereqs: CMPT 354 
Incomes: Upon entry to CMPT 456, every student is expected to be able to ...  create/analyze/apply data structures, algorithm design and analysis, principles in information retrieval systems and applications.

Outcomes: A — Assignment E — ExamAt the end of CMPT 456, students will be able to ...  explain/apply the principles of information retrieval (A, E)
 use open source search engines (e.g., Apache Lucene) and cloud search services (e.g., ElasticSearch) (A)

Program Level Educational Goals:  Problem solving skills (Advanced)
 Software development skills (Advanced)
 Mathematics: theory and practice (Advanced)
 Awareness of the broad applicability of computing (Advanced)

CMPT 461 — Image Synthesis 
Prereqs: MACM 201, MACM 316, CMPT 361 
Incomes: None 
Outcomes: None 
Program Level Educational Goals: None 
CMPT 464 — Geometric Modelling in Computer Graphics 
Prereqs: MACM 316, CMPT 361 
Incomes: Upon entry to CMPT 464, every student is expected to be able to ...  write a computer program to display simple geometric primitives such as a triangle, a cube, with basic shading, on the screen, using the graphics library OpenGL or WebGL.
 code basic data structures such as arrays, linked lists, and priority queues.

Outcomes: A — Assignment At the end of CMPT 464, students will be able to ...  implement an efficient data structure to represent a 3D object in the form of a triangle mesh and write a program with a graphical user interface (GUI) that displays and allows manipulation of the 3D object on the screen. (A)
 describe/apply basic shape representations including tensorproduct curves/surfaces, polygonal meshes, volumetric grids, point clouds, and implicit representations, and the pros and cons of each representation.
 describe/apply basic geometric modeling and processing techniques including: 3D shape acquisition and surface reconstruction, level of details and multiresolution modeling, digital shape processing and analysis (smoothing, feature extraction, segmentation, correspondence)
 describe/apply basic concepts in machine learning (e.g., supervised vs. unsupervised learning, convolutional neural networks, deep generative models) as they pertain to geometric modeling and processing
 describe/apply basic concepts of 3D printing and basic techniques in tool path planning and setup planning

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Software development skills (Advanced)

CMPT 466 — Animation 
Prereqs: MACM 316, CMPT 361 
Incomes: Upon entry to CMPT 466, every student is expected to be able to ...  write simple OpenGL/WebGL program for 3D graphics applications
 compute the Jacobian of a vectorvalued function and solve a linear system
 understand discretization and iterative numerical methods

Outcomes: A — Assignment E — Exam L — LabAt the end of CMPT 466, students will be able to ...  make simple 3D models, particle systems, and character animations in Maya (A, L)
 understand principles of traditional animation (E)
 choose among basic interpolation algorithms for 3D positions and orientations; reimplement CatmullRom splines (E)
 implement forward and inverse kinematics on a 3D skeleton (A)
 understand basic principles of physicsbased animation (E)
 understand a few fundamental deep learning and deep reinforcement learning algorithms for 3D character animation (A, E)
 understand different options of making deformable characters (E)

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Mathematics: theory and practice (Advanced)
 Software development skills (Advanced)
 Awareness of the broad applicability of computing (Advanced)
 Commitment to lifelong learning (IntermediateAdvanced)

CMPT 470 — Webbased Information Systems 
Prereqs: CMPT 276, CMPT 354 
Incomes: Upon entry to CMPT 470, every student is expected to be able to ...  design appropriate schema for an application's data in a relational database.
 design appropriate objects/classes to store an application's data.
 design and implement programs of a reasonable size.
 plan a group development project from requirements to final implementation.

Outcomes: At the end of CMPT 470, students will be able to ...  create web pages by applying web standards.
 explain the purpose of, and evaluate, various HTTP features and apply these when creating web systems.
 develop a web information system using a modern MVC framework
 create secure web applications.
 implement clientside logic using JavaScript.
 create serverside logic to interface with clientside logic (AJAX).
 deploy web applications using configuration management tools (such as Chef, Docker).

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Awareness of the broad applicability of computing (Advanced)
 Software development skills (Advanced)
 Project experience (Advanced)

CMPT 471 — Networking II 
Prereqs: CMPT 300, CMPT 371 
Incomes: Upon entry to CMPT 471, every student is expected to be able to ...  create and run significant programs in Python, C/C++, or Java
 apply networking concepts such as
 Internet Protocol Stack
 application layer (especially HTTP, DNS, Mail)
 transport layer (TCP and UDP)
 network layer (Routing, Forwarding, IP)
 link Layer (EDC, Channel Access)
 apply Operating System concepts such as
 processes and threads
 interprocess communication within a host
 CPU, I/O, and memory access
 apply basic concepts of calculus, linear algebra, and probability

Outcomes: E — Exam Q — QuizAt the end of CMPT 471, students will be able to ...  explain in detail the following core concepts, protocols and implementations of realworld networks using: (Q, E)
 Internet Protocol Stack (HTTP, DNS, DHCP, IPv4, IPv6, TCP & UDP, Routing & Forwarding, 802.1x, MPLS)
 Software Defined Networking (Generalized Forwarding, Flows, OpenFlow, SDN Controller, Northbound and Southbound interfaces, Virtual Network Functions)
 Cloud Computing (Service Models, Challenges, Network Infrastructure)
 Data Center Networks (Hierarchical, Modular, Highly Connected, FatTree, Clos Topology, Randomized)
 Multimedia Networks
 Wireless & Mobility (Medium Access, WLANs and 802.11x, Cellular Wireless Networks, Mobility & Mobile IP)
 Security

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Software development skills (Advanced)
 Computer systems (Advanced)
 Project experience (Advanced)

CMPT 473 — Software Testing, Reliability and Security 
Prereqs: CMPT 276 
Incomes: Upon entry to CMPT 473, every student is expected to be able to ...  use linux systems competently and effectively
 think critically and solve problems beyond memorization
 design and write a medium sized program in Java/C++
 design and write simple unit tests

Outcomes: E — Exam P — Project Q — QuizAt the end of CMPT 473, students will be able to ...  design and write code that is easier to test (and more composable) (Q, E)
 design and write unit tests for code with complex behaviors and requirements (P, Q, E)
 apply, interpret, and implement modern black box and white box techniques for assessing the quality of software (P, Q, E)
 apply program analysis tools to improve software quality and understand the limitations of those tools (P, Q, E)
 assess performance metrics of software using good statistical techniques (Q, E)
 describe contemporary approaches for managing, triaging, and debugging software defects (Q, E)
 explain the core principles of software security, threats to achieving those principles, and how to mitigate those threats (P, Q, E)

Program Level Educational Goals:  Software development skills (Advanced)
 Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)

CMPT 474 — Web Systems Architecture 
Prereqs: CMPT 371 
Incomes: Upon entry to CMPT 474, every student is expected to be able to ...  create and run programs (C/C++, Python preferred)
 apply Operating System, and networking concepts such as
 CPU, Memory, Kernel, I/O, Interrupt, Clock
 load balancing
 interconnection networks
 data center networks
 TCP/IP

Outcomes: A — Assignment Act — Inclass activity E — Exam P — Project Q — QuizAt the end of CMPT 474, students will be able to ... Knowledge Base (Q, E)
 explain/define the following key concepts:
 web/cloudbased systems
 IaaS, PaaS, SaaS, and serverless computing
 scalability, virtualization and resource elasticity
 dockers and containers
 web application architectures (monolithic, tiered (\(N\)tier), servicebased, serviceoriented, microservices, webqueueworker, eventdriven, big data/big compute)
 service management and orchestration
 availability, consistency, reliability, and fault tolerance
 meeting user expectations: performance requirements and tradeoffs
 privacy and security
 service delivery, measurement, and pricing
 tools, platforms, and experiments
Analytical & Design Skills (A, E)
 apply/analyze/evalute web/cloudbased systems, including:
 identify the usage of a discussed architecture
 evaluate performance, scalability, availability, and consistency in a given architecture
 identify design tradeoffs based on evaluation criteria
 identify vulnerabilities in a design
Handson skills (A, Act, P)
 create IaaS using compute, store, and network resources (preferred tool: OpenStack)
 create and manage containerized workloads (preferred tool: Kubernetes)
 create web applications running on private (using OpenStack) or public cloud (using AWS, Azure, Google Cloud)

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Software development skills (Advanced)
 Project experience (Advanced)

CMPT 475 — Requirements Engineering 
Prereqs: MACM 201, CMPT 276 
Incomes: Upon entry to CMPT 475, every student is expected to be able to ...  explain the Software Development Lifecycle
 write programs and scripts in languages such as Java, C++, JavaScript, Python, powershell
 create/design a basic database, tables, views and indexes.
 recognize of Systems Architecture concepts such as client server, desktop or mobile

Outcomes: A — Assignment E — Exam P — ProjectAt the end of CMPT 475, students will be able to ...  create viable Requirement Engineering plans (A, P, E)
 look at projects from a requirements engineering perspective (A, P, E)
 understand the roles of all participants in a project (A, P, E)
 develop a Scope Document for a project, including a summary, a problem statement, goals and objectives and boundaries of the project. (A, P, E)
 identify who and what are the sources of requirements and which sources are most important to consider as part of requirements (A, P, E)
 determine which external systems need to be included in requirements (A, P, E)
 apply Methodologies for eliciting requirements ranging from interviews to stakeholder workshops (A, P, E)
 explain the differences between functional, nonfunctional, technical, and business requirements (A, P, E)
 develop functional as well as technical requirements (A, P, E)
 analyze data requirements and designing a data model (A, P, E)
 analyze architectural requirements (Mobile, Server, Desktop, Cloud, etc) and choose an architectural solution. (A, P, E)
 analyze which software solutions/tools are needed to meet requirements (A, P, E)
 identify when reuse or off the shelf products are the correct solution (A, P, E)
 derive risks from requirements (A, P, E)
 use Modeling Techniques to graphically illustrate and analyze the processes and data requirements (A, P, E)
 understand the sources and importance of standards and regulatory bodies (A, P, E)
 discuss how good requirements improve quality, value and usability (A, P, E)
 connect how requirements are related to the development of acceptance testing and test cases (A, P, E)
 apply tools to track and manage requirements (A, P, E)
 apply prototyping to confirm requirements (A, P, E)

Program Level Educational Goals:  Technical understanding of computer science (Advanced)
 Problem solving skills (Advanced)
 Software development skills (Advanced)

CMPT 477 — Introduction to Formal Verification 
Prereqs: CMPT 276 
Incomes: None 
Outcomes: None 
Program Level Educational Goals: None 

Program Level Goals 
M101 
213 
300 
404 
105W 
225 
307 
405 
120 
276 
308 
407 
125 
295 
310 
411 
127 

318 
412 
128 

320 
413 
129 

340 
414 
130 

353 
417 
135 

354 
419 
165 

361 
431 


363 
433 


365 
441 


371 
454 


373 
456 


376W 
461 


379 
464 


383 
466 


384 
470 



471 



473 



474 



475 



477 
