Program Level Outcomes

A 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, human-computer 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 face-to-face, 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 micro-sensors to high-performance 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 life-long 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 Major

• Software development methodologies — Graduates should be able to develop large-scale 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 object-oriented 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 Program

• Multicultural/multilingual experience — Graduates should have an understanding of cultural and linguistic issues in diverse work environments through in-depth 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.

Upon entry to MACM 101, every student is expected to be able to ...

• perform high school algebra

At 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 English-language 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 Inclusion-Exclusion Principle to counting problems. (A, E)
• solve basic mathematical problems related to finite state machines. (A, E)

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

At 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)

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

At 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)

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

At 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)

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

At the end of CMPT 127, students will be able to ...

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

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

• writing tests, using a test driver, to determine the correctness of functions.

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

• 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 (null-terminated 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 fixed-size 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).

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

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

• implementing operations on linked lists.
• write an efficient list sort function.

• use an explicit memory allocation strategy for high performance.
• measure runtime performance with gettimeofday().

• use classes instead of structs.
• write constructors and destructors for classes.
• use two-dimensional arrays.
• refactor code.

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

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 web-browser; downloading/uploading files from/to websites; installing software via GUI or terminal/command prompt (by following given instructions).

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.

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

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 (1-D, 2-D)
• 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.

Upon entry to CMPT 130, every student is expected to be able to ...

• perform high school algebra

At 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, if-statements, 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

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, if-statements, 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

At the end of CMPT 135, students will be able to ...

• solve small programming problems using object-oriented programming.
• solve small programming problems using a pre-made 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, pre-conditions, and post-conditions.
• test and debug programs.
• empirically estimate the running time of algorithms, and use elementary \( O\)-notation to describe those running times.

Upon entry to CMPT 165, every student is expected to be able to ...

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

At 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 (client-side). (A, L, E)
• analyse the strengths and weaknesses of interactive web sites. (A, L)

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.

At the end of CMPT 213, students will be able to ...

• competently write medium sized (6-15 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, model-view architecture.
• create a simple REST API on a Java backend (Spring-boot)

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

At 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 object-oriented 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 index-based 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.

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

At the end of CMPT 276, students will be able to ...

• software Processes: software life cycle, Agile vs plan-driven development. (E)
• practical experience with a group applying an agile process. (P)
• requirements: system analysis and modeling, requirements specification (E)
• high-level 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)

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

At the end of CMPT 295, students will be able to ...

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

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

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

• 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, system-wide 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)

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

At 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 multi-threaded 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)

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)

At 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 real-world 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 NP-complete 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 NP-completeness using simple reductions. (A, E)
• design and analyze for correctness and runtime simple randomized algorithms. (A, E)

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.

At the end of CMPT 308, students will be able to ...

• prove that certain problems are undecidable (or not even semi-decidable). (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 “self-aware” 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 NP-completeness, and be able to prove certain problems NP-complete. (E)
• work with randomized algorithms, and understand the extra power that randomness brings to computation. (E)
• show the limitations of approximation algorithms for NP-hard 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)

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

At the end of CMPT 310, students will be able to ...

• describe the general goals and major approaches of AI
• use the state-based 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.

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

At 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 computing-based 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, zero-day 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 cyber-physical systems (P, Pres)
• understand systematic approaches to risk assessment based on Bayesian logic
(E)
• appreciate common concepts and applications of blockchain technology (Act, E)

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

At the end of CMPT 320, students will be able to ...

• 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, net-neutrality, international regulations.

• 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

• 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

• 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

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 high-school level concept in physics, biology, and chemistry
• apply high-school and first-year undergraduate level concepts in mathematics (e.g. calculus, probability, trigonometry, vectors and matrices)

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 multi-modal bio-data
• 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, n-D histogram, high-dimensional data, probability distributions, entropy, covariance matrix, eigen-decomposition)
• 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 health-related problems
• appreciate the strengths and limitations of using computers for biomedical applications

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.

At 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 extract-transform-load 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 Scikit-Learn); 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 non-technical audience. (A, P)
• when presented with a data-based problem, assess various tools and techniques for applicability; construct a plan to clean and analyze the data, and present results. (P)

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

At 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)

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 depth-first tree traversal, recursive functions.

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.

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

At the end of CMPT 363, students will be able to ...

• design and evaluate a simple interactive user interface using an iterative, user-centered 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

• 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

• develop several styles of prototypes: paper and executable forms, low- and high-fidelity, 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

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

• pay attention to their discomforts, problems, and satisfaction when using interfaces in every area of their life
• create user-centered interfaces for any interactive application that they build in the future

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

At 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)

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

At the end of CMPT 371, students will be able to ...

• 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 connection-oriented 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 intra-AS and inter-AS routing
• describe the IP addressing mechanism
• describe how multiple access protocols work, including channel partitioning and random access protocols

• analyze network performance at various levels of the stack

• evaluate various protocols using software tools (e.g., Wireshark)
• create socket programs
• create networks with specified addressing and subnettig

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

At 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)

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

At 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 real-world documentation (e.g., on GitHub, Stack Overflow, etc.) (A, J)

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

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

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 first-order logic and set theory

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.

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 context-free grammars.
• design and implement programs and data structures.

At 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 context-free grammars (A, E)
• design and implement simple recursive-descent parsers for symbolic data (A, E)
• design and implement inside-out 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)

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

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.

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 NP-complete 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 NP-completeness using simple reductions
• design and analyze for correctness and runtime simple randomized algorithms

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 NP-complete 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)

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

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 NP-complete), as well as the dichotomy (either P or NP-complete) for the special case of Constraint Satisfaction Problems.
• understand the proof of Cook-Levin’s Theorem that k-SAT is NP-complete, and understand the complexity of SAT variants.
• reason about the Polynomial Time Hierarchy, and understand that a fast algorithm for k-SAT would imply a fast algorithm for formulas with a bounded number of first-order 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).

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

At the end of CMPT 411, students will be able to ...

• logic: expressing knowledge, first-order logic, Horn clause logic
• rule-based 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

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

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 high-level descriptions.
• implement/debug very complex algorithms

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 non-trivial (~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

At 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)

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

At 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 model-based 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)

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

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 state-of-the-art academic papers in Machine Learning

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

At 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)

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, sys-calls, interrupts

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 cross-platform 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)

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)

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 re-arrangements, including approximation algorithms
• dynamic programming algorithms for comparing sequences
• evolutionary algorithms for ordering problems including RNA folding
• divide-and-conquer 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

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++

At 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 multi-user 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 high-level 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)

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.

At 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)

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.

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 tensor-product 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 multi-resolution 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

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 vector-valued function and solve a linear system
• understand discretization and iterative numerical methods

At 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 Catmull-Rom splines (E)
• implement forward and inverse kinematics on a 3D skeleton (A)
• understand basic principles of physics-based 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)

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.

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 client-side logic using JavaScript.
• create server-side logic to interface with client-side logic (AJAX).
• deploy web applications using configuration management tools (such as Chef, Docker).

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
• inter-process communication within a host
• CPU, I/O, and memory access
• apply basic concepts of calculus, linear algebra, and probability

At the end of CMPT 471, students will be able to ...

• explain in detail the following core concepts, protocols and implementations of real-world 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, Fat-Tree, Clos Topology, Randomized)
• Multimedia Networks
• Wireless & Mobility (Medium Access, WLANs and 802.11x, Cellular Wireless Networks, Mobility & Mobile IP)
• Security

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

At 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)

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

At the end of CMPT 474, students will be able to ...

• explain/define the following key concepts:
• web/cloud-based systems
• IaaS, PaaS, SaaS, and serverless computing
• scalability, virtualization and resource elasticity
• dockers and containers
• web application architectures (monolithic, tiered (\(N\)-tier), service-based, service-oriented, micro-services, web-queue-worker, event-driven, 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

• apply/analyze/evalute web/cloud-based systems, including:
• identify the usage of a discussed architecture
• evaluate performance, scalability, availability, and consistency in a given architecture
• identify design trade-offs based on evaluation criteria
• identify vulnerabilities in a design

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

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

At 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)