CS2023

CS Core KA Core Non-core
Skills: E Explain A Apply Ev Evaluate D Develop
Computer Science (CS2023)
Software 4 KAs

Journeyman programmer. Prerequisite for Systems & Applications.

SDF – Software Development Fundamentals 43 CS 5 units
SDF-Fundamentals: Fundamental Programming Concepts and Practices 20h CS
CS Core 12
Basic concepts such as variables, primitive data types, expressions, and their evaluation D
How imperative programs work: state and state transitions on execution of statements, flow of control D
Basic constructs such as assignment statements, conditional and iterative statements, basic I/O D
Key modularity constructs such as functions (and methods and classes, if supported in the language) and related concepts like parameter passing, scope, abstraction, data encapsulation D
Input and output using files and APIs D
Structured data types available in the chosen programming language like sequences (e.g., arrays lists), associative containers (e.g., dictionaries, maps), others (e.g., sets, tuples) and when and how to use them D
Libraries and frameworks provided by the language (when/where applicable) D
Recursion A
Dealing with runtime errors in programs (e.g., exception handling). A
Basic concepts of programming errors, testing, and debugging (See also: SE-Construction, SEC- Coding) A
Documenting/commenting code at the program and module level. A
Develop a security mindset.
Illustrative Learning Outcomes 14
CS Core 14
Develop programs that use the fundamental programming constructs: assignment and expressions basic I/O, conditional and iterative statements.
Develop programs using functions with parameter passing.
Develop programs that effectively use the different structured data types provided in the language like arrays/lists, dictionaries, and sets.
Develop programs that use file I/O to provide data persistence across multiple executions.
Develop programs that use language-provided libraries and frameworks (where applicable).
Develop programs that use APIs to access or update data (e.g., from the web).
Develop programs that create simple classes and instantiate objects of those classes (if supported by the language).
Explain the concept of recursion and identify when and how to use it effectively.
Develop recursive functions.
Develop programs that can handle runtime errors.
Read a given program and explain what it does.
Write comments for a program or a module specifying what it does.
Trace the flow of control during the execution of a program.
Use appropriate terminology to identify elements of a program (e.g., identifier, operator, operand).
SDF-Data-Structures: Fundamental Data Structures 6+6(AL)h CS
CS Core 4
Standard abstract data types such as lists, stacks, queues, sets, and maps/dictionaries, including operations on them.
Selecting and using appropriate data structures.
Performance implications of choice of data structure(s).
Strings and string processing. Ev
Illustrative Learning Outcomes 4
CS Core 4
Write programs that use each of the key abstract data types provided in the language (e.g., arrays tuples/records/structs, lists, stacks, queues, and associative data types like sets dictionaries/maps).
Select the appropriate data structure for a given problem.
Explain how the performance of a program may change when using different data structures or operations.
Write programs that work with text by using string processing capabilities provided by the language.
SDF-Algorithms: Algorithms 3+3(AL)h CS
CS Core 3
Concept of algorithm and notion of algorithm efficiency
Some common algorithms (e.g., sorting, searching, tree traversal, graph traversal)
Impact of algorithms on time-space efficiency of programs
Illustrative Learning Outcomes 4
CS Core 4
Explain the role of algorithms for writing programs.
Demonstrate how a problem may be solved by different algorithms, each with different properties.
Explain some common algorithms (e.g., sorting, searching, tree traversal, graph traversal).
Explain the impact on space/time performance of some algorithms.
SDF-Practices: Software Development Practices 5h CS
CS Core 4
Basic testing, including test case design
Use of a general-purpose IDE, including its debugger
Programming style that improves readability A
Specifying functionality of a module in a natural language.
Illustrative Learning Outcomes 5
CS Core 5
Develop tests for modules and apply a variety of strategies to design test cases.
Explain some limitations of testing programs.
Build, execute, and debug programs using a modern IDE and associated tools such as visual debuggers.
Apply basic programming style guidelines to aid readability of programs such as comments indentation, proper naming of variables, etc.
Write specifications of a module as module comment describing its functionality.
SDF-SEP: Society, Ethics, and the Profession in SEP
CS Core 4
Intellectual property rights of programmers for programs they develop.
Plagiarism and academic integrity.
Responsibility and liability of programmers regarding code they develop for solutions. (See also: SEC-Foundations)
Basic professional work ethics of programmers.
Illustrative Learning Outcomes 20
CS Core 18
Explain/understand some of the intellectual property issues relating to programs.
Explain/understand when code developed by others can be used and proper ways of disclosing their use.
Explain/understand the responsibility of programmers when developing code for an overall solution (which may be developed by a team).
Explain/understand one or more codes of conduct applicable to programmers. forums, FAQs, discussions). Resolving issues is an important part of becoming proficient in programming. prototype solutions. This helps in learning about programming language features. how programs and data are stored in memory, etc. This will help build better mental models of the underlying execution system on which programs run. software development. Tools are commonly used while programming and new tools often emerge
SDF-Fundamentals (20 hours)
SDF-Data-Structures (12 hours)
SDF-Algorithms (6 hours)
SDF-Practices (5 hours)
SDF-SEP ● Design, code, test, and debug a modest sized program that effectively uses functional abstraction. ● Select and use the appropriate language-provided data structure for a given problem (like arrays, tuples/records/structs, lists, stacks, queues, and associative data types like sets dictionaries/maps.) ● Design, code, test, and debug a modest-sized object-oriented program using classes and objects. ● Design, code, test, and debug a modest-sized program that uses language provided librar
SE-Teamwork: Because of the nature of learning programming, most students in introductory SE have little or no exposure to the collaborative nature of SE. Practice (for instance in project work) may help, but lecture and discussion time spent on the value of clear, effective, and efficient communication and collaboration is essential for Software Engineering.
SE-Tools: Industry reliance on SE tools has exploded in the past generation, with version control becoming ubiquitous, testing frameworks growing in popularity, increased reliance on static and dynamic analysis in practice, and the near-ubiquitous use of continuous integration systems. Increasingly powerful IDEs provide code searching and indexing capabilities, as well as small scale refactoring tools and integration with other SE tools. An understanding of the nature of these tools is broadly v
SE-Requirements: Knowing how to build something is of little help if we do not know what to build. Product Requirements (aka Requirements Engineering, Product Design, Product Requirements solicitation, Product Requirements Documents, etc.) introduces students to the processes surrounding the specification of the broad requirements governing development of a new product or feature.
SE-Design: While Product Requirements focus on the user-facing functionality of a software system, Software Design focuses on the engineer-facing design of internal software components. This encompasses large design concerns such as software architecture, as well as small-scale design choices like API design.
SE-Construction: Software Construction focuses on practices that influence the direct production of software: use of tests, test driven development, coding style. More advanced topics extend into secure coding, dependency injection, work prioritization, etc.
SE-Validation: Software Verification and Validation focuses on how to improve the value of testing – understand the role of testing, failure modes, and differences between good tests and poor ones.
SE-Refactoring: Refactoring and Code Evolution focuses on refactoring and maintenance strategies, incorporating code health, use of tools, and backwards compatibility considerations.
SE-Reliability: Software Reliability aims to improve understanding of and attention to error cases failure modes, redundancy, and reasoning about fault tolerance.
SE-Formal: Formal Methods provides mathematically rigorous mechanisms to apply to software from specification to verification. (Prerequisites: Substantial dependence on core material from the Discrete Structures area, particularly knowledge units DS/Basic Logic and DS/Proof Techniques.) Knowledge Unit CS Core KA Core Teamwork 2 + 3 (SEP) 2 Tools and Environments 1 3 + 1 (SDF) Product Requirements 0 + 3 (SEP) 2 Software Design 1 4 + 2 (DM) Software Construction 1 + 3 (SDF) 3 + 1 (SDF) Software Ve
KA Core 2
Interfacing with stakeholders, as a team:
Management & other non-technical teams
Customers
Users
Risks associated with physical, distributed, hybrid, and virtual teams – including communication perception, structure, points of failure, mitigation, and recovery, etc.
Professional Dispositions 6
Self-Directed: Students must seek out solutions to issues on their own (e.g., using technical forums, FAQs, discussions). Resolving issues is an important part of becoming proficient in programming.
Experimental: Students must experiment with language features to understand them and to quickly prototype solutions. This helps in learning about programming language features.
Technical curiosity: Students must develop interest in understanding how programs are executed, how programs and data are stored in memory, etc. This will help build better mental models of the underlying execution system on which programs run.
Adaptable: Students must be willing to learn and use different tools and technologies that facilitate software development. Tools are commonly used while programming and new tools often emerge – using tools effectively and learning the use of new tools will help.
Persistent: Students must continue efforts until, for example, a bug is identified, a program is made robust and handles all situations, etc. This will help as programming requires effort and ability to persevere till a program works satisfactorily.
Meticulous: Students must pay attention to detail and use orderly processes while programming. The underlying machine is unforgiving and there is no room for even small errors in the programs as they can cause major failures. 233
Mathematics Requirements 1
As SDF focuses on the first year and is foundational, it assumes only basic mathematical knowledge that students acquire in school, in particular Sets, Relations, Functions, and Logic (MSF-Discrete).
AL – Algorithmic Foundations 32 CS 32 KA 5 units
AL-Foundational: Foundational Data Structures and Algorithms 11h CS 6h KA
CS Core 13
Abstract Data Type (ADT) and operations on an ADT Ev
Dictionary operations (insert, delete, find)
Arrays
Numeric vs non-numeric, character strings
Single (vector) vs multidimensional (matrix)
Records/Structs/Tuples and Objects A
Linked lists (for historical reasons)
Single vs Double and Linear vs Circular
Stacks
Queues and deques
Heap-based priority queue
Hash tables/maps A
Collision resolution and complexity (e.g., probing, chaining, rehash)
Graphs (e.g., [un]directed, [a]cyclic, [un]connected, and [un]weighted)
Graph representation: adjacency list vs matrix
Trees
Binary, n-ary, and search trees
Balanced (e.g., AVL, Red-Black, Heap)
Sets A
Search algorithms E
O(n) complexity (e.g., linear/sequential array/list search)
O(log₂ n) complexity (e.g., binary search)
O(logb n) complexity (e.g., uninformed depth/breadth-first tree search)
Sorting algorithms (e.g., stable, unstable) A
O(n²) complexity (e.g., insertion, selection)
O(n log n) complexity (e.g., quicksort, merge, timsort)
Graph algorithms A
Shortest path (e.g., Dijkstra’s, Floyd’s)
Minimal spanning tree (e.g., Prim’s, Kruskal’s)
KA Core 3
Sorting algorithms A
O(n log n) complexity heapsort
Pseudo O(n) complexity (e.g., bucket, counting, radix)
Graph algorithms A
Transitive closure (e.g., Warshall’s)
Topological sort
Matching
Efficient string matching (e.g., Boyer-Moore, Knuth-Morris-Pratt)
Longest common subsequence matching
Regular expression matching
Non-core 6
Cryptography algorithms (e.g., SHA-256) A
Parallel algorithms A
Consensus algorithms (e.g., Blockchain) A
Proof of work vs proof of stake
Quantum computing algorithms A
Oracle-based (e.g., Deutsch-Jozsa, Bernstein-Vazirani, Simon)
Superpolynomial speed-up via QFT (e.g., Shor’s)
Polynomial speed-up via amplitude amplification (e.g., Grover’s)
Fast-Fourier Transform (FFT) algorithm
Differential evolution algorithm
Illustrative Learning Outcomes 9
CS Core 7
For each ADT/Data-Structure in this unit
Explain its definition, properties, representation(s), and associated ADT operations.
Explain step-by-step how the ADT operations associated with the data structure transform it.
For each algorithm in this unit explain step-by-step how the algorithm operates.
For each algorithmic approach (e.g., sorting) in this unit apply a prototypical example of the approach (e.g., merge sort).
Given requirements for a problem, develop multiple solutions using various data structures and
Subsequently, evaluate the suitability, strengths, and weaknesses selecting an approach that best satisfies the requirements.
Explain how collision avoidance and collision resolution is handled in hash tables.
Explain factors beyond computational efficiency that influence the choice of algorithms, such as programming time, maintainability, and the use of application-specific patterns in the input data.
Explain the heap property and the use of heaps as an implementation of a priority queue.
KA Core 1
For each of the algorithms and algorithmic approaches in the KA Core topics:
Explain a prototypical example of the algorithm, and
Explain step-by-step how the algorithm operates.
Non-core 1
An appreciation of quantum computation and its application to certain problems.
AL-Strategies: Algorithmic Strategies 6h CS
CS Core 3
Paradigms
Brute-Force (e.g., linear search, selection sort, traveling salesperson, knapsack)
Decrease-and-Conquer
By a Constant (e.g., insertion sort, topological sort)
By a Constant Factor (e.g., binary search)
By a Variable Size (e.g., Euclid’s)
Divide-and-Conquer (e.g., binary search, quicksort, mergesort, Strassen’s)
Greedy (e.g., Dijkstra’s, Kruskal’s, Knapsack)
Transform-and-Conquer
Instance simplification (e.g., find duplicates via list presort)
Representation change (e.g., heapsort)
Problem reduction (e.g., least-common-multiple, linear programming)
Dynamic programming (e.g., Floyd’s, Warshall, Bellman-Ford)
Space vs time tradeoffs (e.g., hashing)
Handling exponential growth (e.g., heuristic A*, branch-and-bound, backtracking) E
Iteration vs recursion (e.g., factorial, tree search) E
KA Core 1
Paradigms
Approximation algorithms
Iterative improvement (e.g., Ford-Fulkerson, simplex)
Randomized/Stochastic algorithms (e.g., max-cut, balls and bins)
Non-core 1
Quantum computing
Illustrative Learning Outcomes 7
CS Core 7
For each of the paradigms in this unit
Explain its definitional characteristics
Explain an example that demonstrates the paradigm including how this example satisfies the paradigm’s characteristics.
For each of the algorithms in the AL-Foundational unit, explain the paradigm used by the algorithm and how it exemplifies this paradigm.
Given an algorithm, explain the paradigm used by the algorithm and how it exemplifies this paradigm.
Give a real-world problem, evaluate appropriate algorithmic paradigms and algorithms from these paradigms that address the problem including evaluating the tradeoffs among the paradigms and algorithms selected.
Give examples of iterative and recursive algorithms that solve the same problem, explain the benefits and disadvantages of each approach.
Evaluate whether a greedy approach leads to an optimal solution.
Explain various approaches for addressing computational problems whose algorithmic solutions are exponential.
AL-Complexity: Complexity 6h CS 3h KA
CS Core 5
Complexity Analysis Framework Ev
Best, average, and worst-case performance of an algorithm
Empirical and relative (Order of Growth) measurements
Input size and primitive operations
Time and space efficiency
Asymptotic complexity analysis (average and worst-case bounds) Ev
Big-O, Big-Omega, and Big-Theta formal notations
Foundational Complexity Classes and Representative Examples/Problems
O(1) Constant (e.g., array access)
O(log₂ n) Logarithmic (e.g., binary search)
O(n) Linear (e.g., linear search)
O(n log₂ n) Log Linear (e.g., mergesort)
O(n²) Quadratic (e.g., selection sort)
O(nc) Polynomial (e.g., O(n³) Gaussian elimination)
O(2n) Exponential (e.g., Knapsack, Satisfiability (SAT) Traveling Salesperson (TSP), all subsets)
O(n!) Factorial (e.g., Hamiltonian circuit, all permutations)
Empirical measurements of performance
Tractability and intractability E
P, NP, and NP-Complete Complexity Classes
NP-Complete Problems (e.g., SAT, Knapsack, TSP)
Reductions
Time and space tradeoffs in algorithms
KA Core 4
Little-o, Little-Omega, and Little Theta notations Ev
Formal recursive analysis
Amortized analysis
Turing Machine-based models of complexity
Time complexity
P, NP, NP-C, and EXP classes
Cook-Levin theorem
Space Complexity
NSpace and PSpace
Savitch’s theorem
Illustrative Learning Outcomes 20
CS Core 13
Prepare a presentation that explains to first year students the basic concepts of algorithmic complexity including best, average, and worst-case algorithm behavior, Big- O, Omega, and Theta notations, complexity classes, time and space tradeoffs, empirical measurement, and impact on practical problems.
Using examples, explain each of the foundational complexity classes in this unit.
For each foundational complexity class in this unit, explain an algorithm that demonstrates the associated runtime complexity.
For each algorithm in the AL-Foundational unit, explain its runtime complexity class and why it belongs to this class.
Informally evaluate the foundational complexity class of simple algorithms.
Given a problem to program for which there may be several algorithmic approaches, evaluate them and determine which are feasible, and select one that is optimal in implementation and run-time behavior.
Develop empirical studies to determine and validate hypotheses about the runtime complexity of various algorithms by running algorithms on input of various sizes and comparing actual performance to the theoretical analysis.
Explain examples that illustrate time-space tradeoffs of algorithms.
Explain how tree balance affects the efficiency of binary search tree operations.
Explain to a non-technical audience the significance of tractable versus intractable algorithms using an intuitive explanation of Big-O complexity.
Explain the significance of NP-Completeness.
Explain how NP-Hard is a lower bound and NP is an upper bound for NP-Completeness.
Explain examples of NP-complete problems.
KA Core 7
Use recurrence relations to evaluate the time complexity of recursively defined algorithms.
Apply elementary recurrence relations using a form of the Master Theorem.
Apply Big-O notation to give upper case bounds on time/space complexity of algorithms.
Explain the Cook-Levin Theorem and the NP-Completeness of SAT.
Explain the classes P and NP.
Prove that a problem is NP-Complete by reducing a classic known NP-C problem to it (e.g., 3SAT and Clique).
Explain the P-space class and its relation to the EXP class.
AL-Models: Computational Models and Formal Languages 9h CS 23h KA
CS Core 6
Formal automata E
Finite State
Pushdown
Linear Bounded
Turing Machine
Formal languages, grammars and Chomsky Hierarchy E
Regular (Type-3)
Regular Expressions
Context-Free (Type-2)
Context-Sensitive (Type-1)
Recursively Enumerable (Type-0)
Relations among formal automata, languages, and grammars E
Decidability, (un)computability, and halting E
The Church-Turing thesis E
Algorithmic correctness E
Invariants (e.g., in iteration, recursion, tree search)
KA Core 7
Deterministic and nondeterministic automata E
Pumping Lemma proofs
Proof of Finite State/Regular-Language limitation
Pushdown Automata/Context-Free-Language limitation
Decidability E
Arithmetization and diagonalization
Reducibility and reductions
Time complexity based on Turing Machine E
Space complexity (e.g., Pspace, Savitch’s Theorem)
Equivalent models of algorithmic computation E
Turing Machines and Variations (e.g., multi-tape, non-deterministic)
Lambda Calculus
Mu-Recursive Functions
Non-core 1
Quantum computation
Postulates of quantum mechanics
State space
State evolution
State composition
State measurement
Column vector representations of qubits
Matrix representations of quantum operations
Simple quantum gates (e.g., XNOT, CNOT)
Illustrative Learning Outcomes 21
CS Core 10
For each formal automaton in this unit:
Explain its definition comparing its characteristics with this unit’s other automata
Using an example, explain step-by-step how the automaton operates on input including whether it accepts the associated input
Explain an example of inputs that can and cannot be accepted by the automaton.
Given a problem, develop an appropriate automaton that addresses the problem.
Develop a regular expression for a given regular language expressed in natural language.
Explain the difference between regular expressions (Type-3 acceptors) and the regular expressions (Type-2 acceptors) used in programming languages.
For each formal model in this unit:
Explain its definition comparing its characteristics with the others in this unit
Explain example inputs that are and cannot be accepted by the language/grammar.
Explain a universal Turing Machine and its operation.
Present to an audience of co-workers and managers the impossibility of providing them a program that checks all other programs, including some seemingly simple ones, for infinite loops including an explanation of the Halting problem, why it has no algorithmic solution, and its significance for real-world algorithmic computation.
Explain examples of classic uncomputable problems.
Explain the Church-Turing Thesis and its significance for algorithmic computation.
Explain how (loop) invariants can be used to prove the correctness of an algorithm.
KA Core 9
For each formal automaton in this unit explain (compare/contrast) its deterministic and nondeterministic capabilities.
Apply pumping lemmas, or alternative means, to prove the limitations of Finite State and Pushdown automata.
Apply arithmetization and diagonalization to prove the Halting Problem for Turing Machines is Undecidability.
Given a known undecidable language, apply a mapping reduction or computational history to prove that another language is undecidable.
Convert among equivalently powerful notations for a language, including among DFAs, NFAs, and regular expressions, and between PDAs and CFGs.
Explain Rice’s theorem and its significance.
Explain an example proof of a problem that is uncomputable by reducing a classic known uncomputable problem to it.
Explain the Primitive and General Recursive functions (zero, successor, selection, primitive recursion, composition, and Mu), their significance, and Turing Machine implementations.
Explain how computation is performed in Lambda Calculus (e.g., Alpha conversion and Beta reduction)
Non-core 2
For a quantum system give examples that explain the following postulates.
State Space – system state represented as a unit vector in Hilbert space
State Evolution – the use of unitary operators to evolve system state
State Composition – the use of tensor product to compose systems states
State Measurement – the probabilistic output of measuring a system state.
Explain the operation of a quantum XNOT or CNOT gate on a quantum bit represented as a matrix and column vector, respectively.
AL-SEP: Society, Ethics, and the Profession in SEP
CS Core 7
Social, ethical, and secure algorithms E
Algorithmic fairness E
Anonymity (e.g., Differential Privacy) E
Accountability/Transparency E
Responsible algorithms E
Economic and other impacts of inefficient algorithms E
Sustainability E
KA Core 1
Context aware computing
Illustrative Learning Outcomes 11
CS Core 6
Develop algorithmic solutions to real-world societal problems, such as routing an ambulance to a hospital.
Explain the impact that an algorithm may have on the environment and society when used to solve a real-world problem while considering its sustainability and that it can affect different societal groups in different ways.
Prepare a presentation that justifies the selection of appropriate data structures and/or algorithms to solve a given real-world problem.
Explain an example that articulates how differential privacy protects knowledge of an individual’s data.
Explain the environmental impacts of design choices that relate to algorithm design.
Explain the tradeoffs involved in proof-of-work and proof-of-stake algorithms. ● Meticulous: As an algorithm is a formal solution to a computational problem, attention to detail is important when developing and combining algorithms. ● Persistent: As developing algorithmic solutions to computational problems can be challenging computer scientists must be resolute in pursuing such solutions. ● Inventive: As computer scientists develop algorithmic solutions to real-world problems, they must be inve
This update brings recent advances in memory caching and energy consumption. ● The newly created AR/Heterogeneous Architectures covers emerging topics in Computer Architecture: Processing In-Memory (PIM) and domain-specific architectures (e.g., neural network processors). ● The new AR/Quantum Architectures offers a "toolbox" covering introductory topics in quantum computing. ● Knowledge units have been merged to better deal with overlaps: ● AR/Multiprocessing and Alternative Architectures were m
KA Core 5
Combinational vs sequential logic/field programmable gate arrays (FPGAs) (See also: SF- Overview, SF-Foundations, SPD-Embedded)
Fundamental combinational
Sequential logic building block
Computer-aided design tools that process hardware and architectural representations
High-level synthesis
Register transfer notation
Hardware description language (e.g., Verilog/VHDL/Chisel)
System-on-chip (SoC) design flow
Physical constraints
Gate delays
Fan-in and fan-out
Energy/power
Speed of light
Professional Dispositions 3
Meticulous: As an algorithm is a formal solution to a computational problem, attention to detail is important when developing and combining algorithms.
Persistent: As developing algorithmic solutions to computational problems can be challenging, computer scientists must be resolute in pursuing such solutions.
Inventive: As computer scientists develop algorithmic solutions to real-world problems, they must be inventive in developing solutions to these problems.
Mathematics Requirements 1
Required 1
MSF-Discrete
FPL – Foundations of Programming Languages 21 CS 19 KA 22 units
FPL-OOP: Object-Oriented Programming 4+1(SDF)h CS 1h KA
CS Core 10
Imperative programming as a subset of object-oriented programming. D
Object-oriented design: D
Decomposition into objects carrying state and having behavior.
Class-hierarchy design for modeling.
Definition of classes: fields, methods, and constructors. D
Subclasses, inheritance (including multiple inheritance), and method overriding. D
Dynamic dispatch: definition of method-call. D
Exception handling. D
Object-oriented idioms for encapsulation: D
Privacy, data hiding, and visibility of class members.
Interfaces revealing only method signatures.
Abstract base classes, traits and mixins.
Dynamic vs static properties. D
Composition vs inheritance. D
Subtyping: D
Subtype polymorphism; implicit upcasts in typed languages.
Notion of behavioral replacement: subtypes acting like supertype.
Relationship between subtyping and inheritance.
KA Core 2
Collection classes, iterators, and other common library components. D
Metaprogramming and reflection. D
Illustrative Learning Outcomes 11
CS Core 10
Enumerate the differences between imperative and object-oriented programming paradigms.
Compose a class through design, implementation, and testing to meet behavioral requirements.
Build a simple class hierarchy utilizing subclassing that allows code to be reused for distinct subclasses.
Predict and validate control flow in a program using dynamic dispatch.
Compare and contrast how computational solutions to a problem differ in procedural, functional and object-oriented approaches.
Compare and contrast mechanisms to define and protect data elements within procedural functional, and object-oriented approaches.
Compare and contrast the benefits and costs/impact of using inheritance (subclasses) and composition (specifically, how to base composition on higher order functions).
Explain the relationship between object-oriented inheritance (code-sharing and overriding) and subtyping (the idea of a subtype being usable in a context that expects the supertype).
Use object-oriented encapsulation mechanisms such as interfaces and private members.
Define and use iterators and other operations on aggregates, including operations that take functions as arguments, in multiple programming languages, selecting the most natural idioms for each language.
KA Core 1
Use collection classes and iterators effectively to solve a problem.
FPL-Functional: Functional Programming 4h CS 3h KA
CS Core 4
Lambda expressions and evaluation:
Variable binding and scope rules.
Parameter-passing.
Nested lambda expressions and reduction order.
Effect-free programming: E
Function calls have no side effects, facilitating compositional reasoning.
Immutable variables and data copying vs reduction.
Use of recursion vs loops vs pipelining (map/reduce).
Processing structured data (e.g., trees) via functions with cases for each data variant: E
Functions defined over compound data in terms of functions applied to the constituent pieces.
Persistent data structures.
Using higher-order functions (taking, returning, and storing functions). E
KA Core 2
Metaprogramming and reflection. E
Function closures (functions using variables in the enclosing lexical environment). E
Basic meaning and definition – creating closures at run-time by capturing the environment.
Canonical idioms: call-backs, arguments to iterators, reusable code via function arguments.
Using a closure to encapsulate data in its environment.
Delayed versus eager evaluation.
Non-core 4
Graph reduction machine and call-by-need.
Implementing delayed evaluation.
Integration with logic programming paradigm using concepts such as equational logic, narrowing residuation and semantic unification. E
Integration with other programming paradigms such as imperative and object-oriented. E
FPL-Logic: Logic Programming 2+1(MSF)h KA
KA Core 8
Universal vs existential quantifiers. E
First order predicate logic vs higher order logic. E
Expressing complex relations using logical connectives and simpler relations. E
Definitions of Horn clause, facts, goals and subgoals. E
Unification and unification algorithm; unification vs assertion vs expression evaluation. E
Mixing relations with functions. E
Cuts, backtracking, and non-determinism. D
Closed-world vs open-world assumptions. D
Non-core 6
Memory overhead of variable copying in handling iterative programs.
Programming constructs to store partial computation and pruning search trees.
Mixing functional programming and logic programming using concepts such as equational logic narrowing, residuation, and semantic unification. E
Higher-order, constraint, and inductive logic programming.
Integration with other programming paradigms such as object-oriented programming.
Advance programming constructs such as difference-lists, creating user defined data structures, set of, etc.
FPL-Scripting: Shell Scripting 2h CS
CS Core 9
Error/exception handling
Piping
System commands
Interface with operating systems
Environment variables
File abstraction and operators
Data structures, such as arrays and lists. (See also: AL-Foundational, SDF-Fundamentals, SDF- Data-Structures)
Regular expressions
Programs and processes
Workflow
FPL-Event-Driven: Event-Driven and Reactive Programming 2h CS 2h KA
CS Core 4
Procedural programming vs reactive programming: advantages of reactive programming in capturing events. D
Components of reactive programming: event-source, event signals, listeners and dispatchers, event objects, adapters, event-handlers. (See also: GIT-Interaction, SPD-Web, SPD-Mobile, SPD-Robot SPD-Embedded, SPD-Game, SPD-Interactive) D
Stateless and state-transition models of event-based programming. D
Canonical uses such as GUIs, mobile devices, robots, servers. (See also: GIT-Interaction, GIT- Image, SPD-Web, SPD-Mobile, SPD-Robot, SPD-Embedded, SPD-Game, SPD-Interactive) D
KA Core 3
Using a reactive framework: D
Defining event handlers/listeners
Parameterization of event senders and event arguments
Externally generated events and program-generated events
Separation of model, view, and controller D
Event-driven and reactive programs as state-transition systems D
FPL-Parallel: Parallel and Distributed Computing 2+1(PDC)h CS 2h KA
CS Core 5
Safety and liveness
Race conditions
Dependencies/preconditions
Fault models
Termination
Programming models One or more of the following: E
Actor models
Procedural and reactive models
Synchronous/asynchronous programming models
Data parallelism
Properties E
Order-based properties
Commutativity
Independence
Consistency-based properties
Atomicity
Consensus
Execution control: E
Async await
Promises
Threads
Communication and coordination E
Mutexes
Message-passing
Shared memory
Cobegin-coend
Monitors
Channels
Threads
Guards
KA Core 8
Futures E
Language support for data parallelism such as forall, loop unrolling, map/reduce E
Effect of memory-consistency models on language semantics and correct code generation E
Representational State Transfer Application Programming Interfaces (REST APIs) E
Technologies and approaches: cloud computing, high performance computing, quantum computing ubiquitous computing E
Overheads of message-passing E
Granularity of program for efficient exploitation of concurrency E
Concurrency and other programming paradigms (e.g., functional) E
FPL-Aspect: Aspect-Oriented Programming
Non-core 6
Aspects
Join points
Advice
Before
After (as finally, returning or throwing)
Around
Point cuts
Designators
Weaving – static and dynamic
Alternatives including annotations and IDEs
FPL-Types: Type Systems 3h CS 3h KA
CS Core 6
A type as a set of values together with a set of operations D
Primitive types (e.g., numbers, Booleans)
Compound types built from other types (e.g., records/structs, unions, arrays, lists, functions references using set operations)
Association of types to variables, arguments, results, and fields D
Type safety as an aspect of program correctness D
Type safety and errors caused by using values inconsistently given their intended types D
Goals and limitations of static and dynamic typing: detecting and eliminating errors as early as possible. D
Generic types (parametric polymorphism) D
Definition and advantages of polymorphism: parametric, subtyping, overloading, and coercion
Comparison of monomorphic and polymorphic types
Comparison with ad-hoc polymorphism (overloading) and subtype polymorphism
Generic parameters and typing
Use of generic libraries such as collections
Comparison with ad hoc polymorphism (overloading) and subtype polymorphism
Prescriptive vs descriptive polymorphism
Implementation models of polymorphic types
Subtyping
KA Core 2
Type equivalence: structural vs name equivalence D
Complementary benefits of static and dynamic typing: D
Errors early vs errors late/avoided
Enforce invariants during code development and code maintenance vs postpone typing decisions while prototyping and conveniently allow flexible coding patterns such as heterogeneous collections.
Typing rules for function, product, and sum types
Avoiding misuse of code vs allowing more code reuse
Detect incomplete programs vs allow incomplete programs to run
Relationship to static analysis
Decidability
Non-core 8
Compositional type constructors, such as product types (for aggregates), sum types (for unions) function types, quantified types, and recursive types
Type checking
Subtyping:
Subtype polymorphism; implicit upcasts in typed languages
Notion of behavioral replacement: subtypes acting like supertype
Relationship between subtyping and inheritance
Type safety as preservation plus progress D
Type inference
Static overloading
Propositions as types (implication as a function, conjunction as a product, disjunction as a sum)
Dependent types (universal quantification as dependent function, existential quantification as dependent product).
FPL-Systems: Systems Execution and Memory Model 2+1(AR/OS)h CS
CS Core 7
Data structures for translation, execution, translation, and code mobility such as stack, heap aliasing (sharing using pointers), indexed sequence and string E
Direct, indirect, and indexed access to memory location E
Run-time representation of data abstractions such as variables, arrays, vectors, records, pointer- based data elements such as linked-lists and trees, and objects E
Abstract low-level machine with simple instruction, stack, and heap to explain translation and execution E
Run-time layout of memory: activation record (with various pointers), static data, call-stack, heap E
Translating selection and iterative constructs to control-flow diagrams
Translating control-flow diagrams to low level abstract code
Implementing loops, recursion, and tail calls
Translating function/procedure calls and return from calls, including different parameter-passing mechanisms using an abstract machine
Memory management: E
Low level allocation and accessing of high-level data structures such as basic data types, n- dimensional array, vector, record, and objects
Return from procedure as automatic deallocation mechanism for local data elements in the stack
Manual memory management: allocating, de-allocating, and reusing heap memory
Automated memory management: garbage collection as an automated technique using the notion of reachability
Green computing. E
FPL-Translation: Language Translation and Execution 2h CS 3h KA
CS Core 8
Execution models for JIT (Just-In-Time), compiler, interpreter
Use of intermediate code, e.g., bytecode E
Limitations and benefits of JIT, compiler, and interpreter E
Cross compilers/transpilers E
BNF and extended BNF representation of context-free grammar E
Parse tree using a simple sentence such as arithmetic expression or if-then-else statement E
Execution as native code or within a virtual machine E
Language translation pipeline: syntax analysis, parsing, optional type-checking, translation/code generation and optimization, linking, loading, execution E
KA Core 2
Run-time representation of core language constructs such as objects (method tables) and functions that can be passed as parameters to and returned from functions (closures) E
Secure compiler development E
FPL-Abstraction: Program Abstraction and Representation 3h KA
KA Core 9
BNF and regular expressions
Programs that take (other) programs as input such as interpreters, compilers, type-checkers documentation generators
Components of a language:
Definitions of alphabets, delimiters, sentences, syntax, and semantics
Syntax vs semantics
Program as a set of non-ambiguous meaningful sentences
Basic programming abstractions: constants, variables, declarations (including nested declarations) command, expression, assignment, selection, definite and indefinite iteration, iterators, function procedure, modules, exception handling
Mutable vs immutable variables: advantages and disadvantages of reusing existing memory location vs advantages of copying and keeping old values; storing partial computation vs recomputation
Types of variables: static, local, nonlocal, global; need and issues with nonlocal and global variables.
Scope rules: static vs dynamic; visibility of variables; side-effects.
Side-effects induced by nonlocal variables, global variables and aliased variables.
Non-core 8
L-values and R-values: mapping mutable variable-name to L-values; mapping immutable variable- names to R-values
Environment vs store and their properties
Data and control abstraction
Mechanisms for information exchange between program units such as procedures, functions, and modules: nonlocal variables, global variables, parameter-passing, import-export between modules
Data structures to represent code for execution, translation, or transmission.
Low level instruction representation such as virtual machine instructions, assembly language, and binary representation
Lambda calculus, variable binding, and variable renaming.
Types of semantics: operational, axiomatic, denotational, behavioral; define and use abstract syntax trees; contrast with concrete syntax.
FPL-Syntax: Syntax Analysis
Non-core 8
Regular grammars vs context-free grammars
Scanning and parsing based on language specifications
Lexical analysis using regular expressions
Tokens and their use
Parsing strategies including top-down (e.g., recursive descent, or LL) and bottom-up (e.g., LR or GLR) techniques
Lookahead tables and their application to parsing
Language theory:
Chomsky hierarchy
Left-most/right-most derivation and ambiguity
Grammar transformation
Parser error recovery mechanisms
Generating scanners and parsers from declarative specifications
FPL-Semantics: Compiler Semantic Analysis
Non-core 8
Abstract syntax trees; contrast with concrete syntax
Defining, traversing, and modifying high-level program representations
Scope and binding resolution
Static semantics
Type checking.
Define before use
Annotation and extended static checking frameworks.
L-values/R-values
Call semantics
Types of parameter-passing with simple illustrations and comparison: call by value, call by reference, call by value-result, call by name, call by need and their variations
Declarative specifications such as attribute grammars and their applications in handling limited context-base grammar
FPL-Analysis: Program Analysis and Analyzers
Non-core 9
Relevant program representations, such as basic blocks, control-flow graphs, def-use chains, and static single assignment
Undecidability and consequences for program analysis
Flow-insensitive analysis, such as type-checking and scalable pointer and alias analysis
Flow-sensitive analysis, such as forward and backward dataflow analyses
Path-sensitive analysis, such as software model checking and software verification
Tools and frameworks for implementing analyzers
Role of static analysis in program optimization and data dependency analysis during exploitation of concurrency
Role of program analysis in (partial) verification and bug-finding
Parallelization:
Analysis for auto-parallelization
Analysis for detecting concurrency bugs
FPL-Code: Code Generation
Non-core 10
Instruction sets
Control flow
Memory management
Procedure calls and method dispatching
Separate compilation; linking
Instruction selection
Instruction scheduling (e.g., pipelining)
Register allocation
Code optimization as a form of program analysis
Program generation through generative AI
FPL-Run-Time: Run-time Behavior and Systems
Non-core 13
Process models using stacks and heaps to allocate and deallocate activation records and recovering environments using frame pointers and return addresses during a procedure call including parameter-passing examples
Schematics of code lookup using hash tables for methods in implementations of object-oriented programs
Data layout for objects and activation records
Object allocation in heap
Implementing virtual entities and virtual methods; virtual method tables and their application
Run-time behavior of object-oriented programs
Compare and contrast allocation of memory during information exchange using parameter-passing and non-local variables (using chain of static links).
Dynamic memory management approaches and techniques: malloc/free, garbage collection (mark- sweep, copying, reference counting), regions (also known as arenas or zones)
Just-in-time compilation and dynamic recompilation
Interface to operating system (e.g., for program initialization)
Interoperability between programming languages including parameter-passing mechanisms and data representation
Big endian, little endian
Data layout of composite data types such as arrays
Other common features of virtual machines, such as class loading, threads, and security checking
Sandboxing
FPL-Constructs: Advanced Programming Constructs
Non-core 12
Encapsulation mechanisms
Delayed evaluation and infinite streams
Compare and contrast delayed evaluation vs eager evaluation
Unification vs assertion vs expression evaluation
Control abstractions: exception handling, continuations, monads.
Object-oriented abstractions: multiple inheritance, mixins, traits, multimethods
Metaprogramming: macros, generative programming, model-based development
String manipulation via pattern-matching (regular expressions)
Dynamic code evaluation ("eval")
Language support for checking assertions, invariants, and pre/post-conditions
Domain specific languages, such as database languages, data science languages, embedded computing languages, synchronous languages, hardware interface languages
Massive parallel high performance computing models and languages
FPL-Pragmatics: Language Pragmatics
Non-core 7
Effect of technology needs and software requirements on programming language development and evolution
Problem domains and programming paradigm
Criteria for good programming language design
Principles of language design such as orthogonality
Defining control and iteration constructs
Modularization of large software
Evaluation order, precedence, and associativity
Eager vs delayed evaluation
Defining control and iteration constructs
External calls and system libraries
FPL-Formalism: Formal Semantics
Non-core 7
Syntax vs semantics
Approaches to semantics: axiomatic, operational, denotational, type-based
Axiomatic semantics of abstract constructs such as assignment, selection, iteration using pre- condition, post-conditions, and loop invariant
Operational semantics analysis of abstract constructs and sequence of such as assignment expression evaluation, selection, iteration using environment and store
Symbolic execution
Constraint checkers
Denotational semantics
Lambda Calculus.
Proofs by induction over language semantics
Formal definitions and proofs for type systems
Propositions as types (implication as a function, conjunction as a product, disjunction as a sum)
Dependent types (universal quantification as dependent function, existential quantification as dependent product)
Parametricity
FPL-Methodologies: Formal Development Methodologies
Non-core 5
Use formal modeling techniques to develop and validate architectures.
Use proof assisted programming languages to develop fully specified and verified software artifacts.
Use verifier and specification support in programming languages to formally validate system properties.
Integrate symbolic validation tooling into a programming workflow.
Discuss when and how formal methods can be effectively used in the development process.
FPL-Design: Design Principles of Programming Languages
Non-core 6
Language design principles
Simplicity
Security
Fast translation
Efficient object code
Orthogonality
Readability
Completeness
Implementation strategies
Designing a language to fit a specific domain or problem
Interoperability between programming languages
Language portability
Formal description of a programming language
Green computing principles
Illustrative Learning Outcomes 1
Non-core 1
Understand what constitutes good language design and apply that knowledge to evaluate a real programming language.
FPL-SEP: Society, Ethics, and the Profession in SEP
CS Core 1
Uses of computer graphics and interactive techniques and their potential risks and
Non-core 5
Impact of English-centric programming languages
Enhancing accessibility and inclusivity for people with disabilities – Supporting assistive technologies
Human factors related to programming languages and usability
Impact of syntax on accessibility
Supporting cultural differences (e.g., currency, decimals, dates)
Neurodiversity
Etymology of terms such as “class,” “master,” and “slave” in programming languages
Increasing accessibility by supporting multiple languages within applications (UTF)
Professional Dispositions 5
Professional: Students must demonstrate and apply the highest standards when using programming languages and formal methods to build safe systems that are fit for their purpose.
Meticulous: Attention to detail is essential when using programming languages and applying formal methods.
Inventive: Programming and approaches to formal proofs is inherently a creative process, students must demonstrate innovative approaches to problem solving. Students are accountable for their choices regarding the way a problem is solved.
Proactive: Programmers are responsible for anticipating all forms of user input and system behavior and to design solutions that address each one.
Persistent: Students must demonstrate perseverance since the correct approach is not always self-evident and a process of refinement may be necessary to reach the solution.
Mathematics Requirements 3
Required 3
Discrete Mathematics – Boolean algebra, proof techniques, digital logic, sets and set operations, mapping, functions and relations, states and invariants, graphs and relations, trees counting, recurrence relations, finite state machine, regular grammar.
Logic – propositional logic (negations, conjunctions, disjunctions, conditionals, biconditionals) first-order logic, logical reasoning (induction, deduction, abduction).
Mathematics – Matrices, probability, statistics.
SE – Software Engineering 6 CS 21 KA 9 units
SE-Teamwork: Teamwork 2+3(SEP)h CS 2h KA
CS Core 6
Effective communication, including oral and written, as well as formal (email, docs, comments presentations) and informal (team chat, meetings). Ev
Common causes of team conflict, and approaches for conflict resolution. Ev
Cooperative programming: Ev
Pair programming or Swarming
Code review
Collaboration through version control
Roles and responsibilities in a software team: Ev
Advantages of teamwork
Risks and complexity of such collaboration
Team processes – responsibilities for tasks, effort estimation, meeting structure, work schedule Ev
Importance of team diversity and inclusivity. E
KA Core 2
Interfacing with stakeholders, as a team: E
Management & other non-technical teams
Customers
Users
Risks associated with physical, distributed, hybrid, and virtual teams – including communication perception, structure, points of failure, mitigation, and recovery, etc. E
Illustrative Learning Outcomes 10
CS Core 8
Follow effective team communication practices.
Articulate the sources of, hazards of, and potential benefits of team conflict – especially focusing on the value of disagreeing about ideas or proposals without insulting people.
Facilitate a conflict-resolution and problem-solving strategy in a team setting.
Collaborate effectively in cooperative development/programming.
Propose and delegate necessary roles and responsibilities in a software development team.
Compose and follow an agenda for a team meeting.
Facilitate through involvement in a team project, the central elements of team building, establishing healthy team culture, and team management including creating and executing a team work plan.
Promote the importance of and benefits that diversity and inclusivity brings to a software development team.
KA Core 2
Reference, as a team, the importance of, and strategies to interface with stakeholders outside the team on both technical and non-technical levels.
Enumerate the risks associated with physical, distributed, hybrid, and virtual teams and possible points of failure and how to mitigate against and recover/learn from failures.
SE-Tools: Tools and Environments 1h CS 3+1(SDF)h KA
CS Core 1
Software configuration management and version control: Ev
Configuration in version control, reproducible builds/configuration.
Version control branching strategies. Development branches vs release branches. Trunk-based development.
Merging/rebasing strategies, when relevant.
KA Core 6
Release management. Ev
Testing tools including static and dynamic analysis tools. Ev
Software process automation: D
Build systems – the value of fast, hermetic, reproducible builds, compare/contrast approaches to building a project.
Continuous Integration (CI) – the use of automation and automated tests to do preliminary validation that the current head/trunk revision builds and passes (basic) tests.
Dependency management – updating external/upstream dependencies, package management SemVer.
Design and communication tools (docs, diagrams, common forms of design diagrams like UML). D
Tool integration concepts and mechanisms. D
Use of modern IDE facilities – debugging, refactoring, searching/indexing, ML-powered code assistants, etc. D
Illustrative Learning Outcomes 7
CS Core 3
Describe the difference between centralized and distributed software configuration management.
Describe how version control can be used to help manage software release management.
Identify configuration items and use a source code control tool in a small team-based project.
KA Core 4
Describe how available static and dynamic test tools can be integrated into the software development environment.
Understand the use of CI systems as a ground-truth for the state of the team’s shared code (build and test success).
Describe the issues that are important in selecting a set of tools for the development of a specific software system, including tools for requirements tracking, design modeling, implementation, build automation, and testing.
Demonstrate the capability to use software tools in support of the development of a software product of medium size.
SE-Requirements: Product Requirements 0+3(SEP)h CS 2h KA
KA Core 6
Describe functional requirements using, for example, use cases or user stories. A
Using at least one method of documenting and structuring functional requirements.
Understanding how the method supports design and implementation.
Strengths and weaknesses of using a specific approach.
Properties of requirements including consistency, validity, completeness, and feasibility. A
Requirements elicitation. A
Sources of requirements, for example, users, administrators, or support personnel.
Methods of requirement gathering, for example, surveys, interviews, or behavioral analysis.
Non-functional requirements, for example, security, usability, or performance, also called as Quality A
Risk identification and management, including ethical considerations surrounding the proposed A
Communicating and/or formalizing requirement specifications. A
Non-core 3
Prototyping a tool for both eliciting and validating/confirming requirements. A
Product evolution: when requirements change, how to understand what effect that has and what changes need to be made. A
Effort estimation:
Learning techniques for better estimating the effort required to complete a task
Practicing estimation and comparing it to how long tasks take
Effort estimation is quite difficult, so students are likely to be way off in many cases, but seeing the process play out with their own work is valuable.
Illustrative Learning Outcomes 10
KA Core 6
Compare different methods of eliciting requirements along multiple axes.
Identify differences between two methods of describing functional requirements (e.g., customer interviews, user studies) and the situations where each would be preferred.
Identify which behaviors are required, allowed, or barred from a given set of requirements and a list of candidate behaviors.
Collect a set of requirements for a simple software system.
Identify areas of a software system that need to be changed, given a description of the system and a set of new requirements to be implemented.
Identify the functional and non-functional requirements in a set of requirements.
Non-core 4
Create a prototype of a software system to validate a set of requirements – building a mock-up MVP, etc.
Estimate the time to complete a set of tasks, then compare estimates to the actual time taken.
Determine an implementation sequence for a set of tasks, adhering to dependencies between them, with a goal to retire risk as early as possible.
Write a requirement specification for a simple software system.
SE-Design: Software Design 1h CS 4+2(DM)h KA
CS Core 4
System design principles. D
Levels of abstraction (e.g., architectural design and detailed design)
Separation of concerns
Information hiding
Coupling and cohesion
Software architecture. D
Design paradigms
Top-down functional decomposition/layered design
Data-oriented architecture
Object-oriented analysis and design
Event-driven design
Standard architectures (e.g., client-server and microservice architectures including REST discussions, n-layer, pipes-and-filters, Model View Controller)
Identifying component boundaries and dependencies
Programming in the large vs programming in the small. D
Code smells and other indications of code quality, distinct from correctness. (See also: SEC- Engineering) D
KA Core 9
API design principles D
Consistency
Consistent APIs are easier to learn and less error-prone
Consistency is both internal (between different portions of the API) and external (following common API patterns)
Composability
Documenting contracts
API operations should describe their effect on the system, but not generally their implementation
Preconditions, postconditions, and invariants
Expandability
Error reporting
Errors should be clear, predictable, and actionable
Input that does not match the contract should produce an error
Errors that can be reliably managed without reporting should be managed
Identifying and codifying data invariants and time invariants D
Structural and behavioral models of software designs D
Data design A
Data structures
Storage systems
Requirement traceability A
Understanding which requirements are satisfied by a design
Design modeling, for instance with class diagrams, entity relationship diagrams, or sequence diagrams A
Measurement and analysis of design quality A
Principles of secure design and coding D
Principle of least privilege
Principle of fail-safe defaults
Principle of psychological acceptability
Evaluating design tradeoffs (e.g., efficiency vs reliability, security vs usability) A
Illustrative Learning Outcomes 12
CS Core 4
Identify the standard software architecture of a given high-level design.
Select and use an appropriate design paradigm to design a simple software system and explain how system design principles have been applied in this design.
Adapt a flawed system design to better follow principles such as separation of concerns or information hiding.
Identify the dependencies among a set of software components in an architectural design.
KA Core 8
Design an API for a single component of a large software system, including identifying and documenting each operation’s invariants, contract, and error conditions.
Evaluate an API description in terms of consistency, composability, and expandability.
Expand an existing design to include a new piece of functionality.
Design a set of data structures to implement a provided API surface.
Identify which requirements are satisfied by a provided software design.
Translate a natural language software design into class diagrams.
Adapt a flawed system design to better follow the principles of least privilege and fail-safe defaults.
Contrast two software designs across different qualities, such as efficiency or usability.
SE-Construction: Software Construction 1+3(SDF)h CS 3+1(SDF)h KA
CS Core 2
Construction practices that influence direct production of working software
Coding standards and conventions tied to quality A
KA Core 2
Detailed construction techniques
Integration of construction with testing and review
SE-Validation: Software Verification and Validation 1h CS 3h KA
CS Core 5
Verification and validation concepts E
Verification: Are we building the thing right?
Validation: Did we build the right thing?
Why testing matters: Does the component remain functional as the code evolves? E
Testing objectives E
Usability
Reliability
Conformance to specification
Performance
Security
Test kinds E
Unit
Integration
Validation
System
Stylistic differences between tests and production code: DAMP vs DRY – more duplication is warranted in test code. E
KA Core 8
Test planning and generation E
Test case generation, from formal models, specifications, etc.
Test coverage
Test matrices
Code coverage – how much of the code is tested?
Environment coverage – how many hardware architectures, operating systems, browsers
are tested?
Test data and inputs
Test development E
Test-driven development
Object oriented testing, mocking, and dependency injection
Opaque-box (previously, black-box) and transparent-box (previously, white-box) testing techniques
Test tooling, including code coverage, static analysis, and fuzzing
Verification and validation in the development cycle E
Code reviews
Test automation, including automation of tooling
Pre-commit and post-commit testing
Tradeoffs between test coverage and throughput/latency of testing
Defect tracking and prioritization: reproducibility of reported defects
Domain specific verification and validation challenges E
Performance testing and benchmarking
Asynchrony, parallelism, and concurrency
Safety-critical
Numeric
Verification and validation tooling and automation E
Static analysis
Code coverage
Fuzzing
Dynamic analysis and fault containment (sanitizers, etc.)
Fault logging and fault tracking
Performance testing and benchmarking E
Throughput and latency
Degradation under load (stress testing, FIFO vs LIFO handling of requests)
Speedup and scaling
Amdahl’s law
Gustafson's law
Soft and weak scaling
Identifying and measuring figures of merits
Common performance bottlenecks
Compute-bound
Memory-bandwidth bound
Latency-bound
Statistical methods and best practices for benchmarking
Estimation of uncertainty
Confidence intervals
Analysis and presentation (graphs, etc.)
Timing techniques
Testing asynchronous, parallel, and concurrent systems E
Verification and validation of non-code artifacts (documentation, training materials) E
Illustrative Learning Outcomes 30
CS Core 4
Explain why testing is important.
Distinguish between program validation and verification.
Describe different objectives of testing.
Compare and contrast the different types and levels of testing (regression, unit, integration systems, and acceptance).
KA Core 26
Describe techniques for creating a test plan and generating test cases.
Create a test plan for a medium-size code segment which includes a test matrix and generation of test data and inputs.
Implement a test plan for a medium-size code segment.
Identify the fundamental principles of test-driven development methods and explain the role of automated testing in these methods.
Discuss issues involving the testing of object-oriented software.
Describe mocking and dependency injection and their application.
Undertake, as part of a team activity, a code review of a medium-size code segment.
Describe the role that tools can play in the validation of software.
Automate the testing in a small software project.
Explain the roles, pros, and cons of pre-commit and post-commit testing.
Discuss the tradeoffs between test coverage and test throughput/latency and how this can impact verification.
Use a defect tracking tool to manage software defects in a small software project.
Discuss the limitations of testing in certain domains.
Describe and compare different tools for verification and validation.
Automate the use of different tools in a small software project.
Explain how and when random numbers should be used in testing.
Describe approaches for fault estimation.
Estimate the number of faults in a small software application based on fault density and fault seeding.
Describe throughput and latency and provide examples of each.
Explain speedup and the different forms of scaling and how they are computed.
Describe common performance bottlenecks.
Describe statistical methods and best practices for benchmarking software.
Explain techniques for and challenges with measuring time when constructing a benchmark.
Identify the figures of merit, construct and run a benchmark, and statistically analyze and visualize the results for a small software project.
Describe techniques and issues with testing asynchronous, concurrent, and parallel software.
Describe techniques for the verification and validation of non-code artifacts.
SE-Refactoring: Refactoring and Code Evolution 2h KA
KA Core 5
Hyrum’s Law/The Law of Implicit Interfaces
Backward compatibility
Compatibility is not a property of a single entity, it’s a property of a relationship.
Backward compatibility needs to be evaluated in terms of provider + consumer(s) or with a well- specified model of what forms of compatibility a provider aspires to/promises.
Refactoring
Standard refactoring patterns (rename, inline, outline, etc.)
Use of refactoring tools in IDE
Application of static-analysis tools (to identify code in need of refactoring, generate changes etc.)
Value of refactoring as a remedy for technical debt
Versioning
Semantic Versioning (SemVer)
Trunk-based development
“Large Scale” Refactoring – techniques when a refactoring change is too large to commit safely (large projects), or when it is impossible to synchronize change between provider + all consumers (multiple repositories, consumers with private code).
Express both old and new APIs so that they can co-exist.
Minimize the size of behavior changes.
Why these techniques are required, (e.g., “API consumers I can see” vs “consumers I can’t see”).
Illustrative Learning Outcomes 6
Identify both explicit and implicit behavior of an interface and identify potential risks from Hyrum’s Law.
Consider inputs from static analysis tools and/or Software Design principles to identify code in need of refactoring.
Identify changes that can be broadly considered “backward compatible,” potentially with explicit statements about what usage is or is not supported.
Refactor the implementation of an interface to improve design, clarity, etc. with minimal/zero impact on existing users.
Evaluate whether a proposed change is sufficiently safe given the versioning methodology in use for a given project.
Plan a complex multi-step refactoring to change default behavior of an API safely.
SE-Reliability: Software Reliability 2h KA
KA Core 11
Concept of reliability as probability of failure or mean time between failures, and faults as cause of failures E
Identifying reliability requirements for different kinds of software E
Software failures caused by defects/bugs, and so for high reliability the goal is to have minimum defects – by injecting fewer defects (better training, education, planning), and by removing most of the injected defects (testing, code review, etc.) E
Software reliability, system reliability and failure behavior E
Defect injection and removal cycle, and different approaches for defect removal E
Compare the “error budget” approach to reliability with the “error-free” approach and identify domains where each is relevant. E
Software reliability models E
Software fault tolerance techniques and models E
Contextual differences in fault tolerance (e.g., crashing a flight critical system is strongly avoided, crashing a data processing system before corrupt data is written to storage is highly valuable)
Software reliability engineering practices – including reviews, testing, practical model checking E
Identification of dependent and independent failure domains, and their impact on system reliability E
Measurement-based analysis of software reliability – telemetry, monitoring and alerting dashboards, release qualification metrics, etc. E
Illustrative Learning Outcomes 7
KA Core 7
Describe how to determine the level of reliability required by a software system.
Explain the problems that exist in achieving very high levels of reliability.
Understand approaches to minimizing faults that can be applied at each stage of the software lifecycle.
Demonstrate the ability to apply multiple methods to develop reliability estimates for a software system.
Identify methods that will lead to the realization of a software architecture that achieves a specified level of reliability.
Identify ways to apply redundancy to achieve fault tolerance.
Identify single-point-of-failure (SPF) dependencies in a system design.
SE-Formal: Formal Methods
Non-core 4
Formal specification of interfaces
Specification of pre- and post-conditions
Formal languages for writing and analyzing pre- and post-conditions
Problem areas well served by formal methods
Lock-free programming, data races
Asynchronous and distributed systems, deadlock, livelock, etc.
Comparison to other tools and techniques for defect detection
Testing
Fuzzing
Formal approaches to software modeling and analysis
Model checkers
Model finders
Illustrative Learning Outcomes 3
Describe the role formal specification and analysis techniques can play in the development of complex software and compare their use as validation and verification techniques with testing.
Apply formal specification and analysis techniques to software designs and programs with low complexity.
Explain the potential benefits and drawbacks of using formal specification languages.
Professional Dispositions 5
Collaborative: Software engineering is increasingly described as a “team sport” – successful software engineers are able to work with others effectively. Humility, respect, and trust underpin the collaborative relationships that are essential to success in this field. 251
Professional: Software engineering produces technology that has the chance to influence literally billions of people. Awareness of our role in society, strong ethical behavior, and commitment to respectful day-to-day behavior outside of one’s team are essential.
Communicative: No single software engineer on a project is likely to know all the project details. Successful software projects depend on engineers communicating clearly and regularly to coordinate effectively.
Meticulous: Software engineering requires attention to detail and consistent behavior from everyone on the team. Success in this field is clearly influenced by a meticulous approach - comprehensive understanding, proper procedures, and a solid avoidance of cutting corners.
Responsible: The collaborative aspects of software engineering also highlight the value of being responsible. Failing to take responsibility, failing to follow through, and failing to keep others informed are all classic causes of team friction and bad project outcomes.
Mathematics Requirements 1
Desirable 1
Introductory statistics (performance comparisons, evaluating experiments, interpreting survey results, etc.). (See also CS-Core requirements for MSF-Statistics)
Systems 7 KAs

Essential services and non-functional requirements.

SF – Systems Fundamentals 18 CS 8 KA 9 units
SF-Overview: Overview of Computer Systems 3h CS
CS Core 6
Basic building blocks and components of a computer (gates, flip-flops, registers, interconnections datapath + control + memory)
Hardware as a computational paradigm: Fundamental logic building blocks; Logic expressions minimization, sum of product forms E
Programming abstractions, interfaces, use of libraries E
Distinction and interaction between application and OS services, remote procedure call (See also: OS-Purpose) E
Basic concept of pipelining, overlapped processing stages E
Basic concept of scaling: performance vs problem size E
Illustrative Learning Outcomes 8
CS Core 8
Describe the basic building blocks of computers and their role in the historical development of computer architecture.
Design a simple logic circuit using the fundamental building blocks of logic design to solve a simple problem (e.g., adder).
Describe how computing systems are constructed of layers upon layers, based on separation of concerns, with well-defined interfaces, hiding details of low layers from the higher layers.
Describe that hardware, OS, VM, and application are additional layers of interpretation/processing.
Describe the mechanisms of how errors are detected, signaled back, and handled through the layers.
Construct a simple program (e.g., a TCP client/server) using methods of layering, error detection and recovery, and reflection of error status across layers.
Identify bugs in a layered program by using tools for program tracing, single stepping, and debugging.
Understand the concept of strong vs weak scaling, i.e., how performance is affected by the scale of the problem vs the scale of resources to solve the problem. This can be motivated by simple, real- world examples.
SF-Foundations: Basic Concepts 4h CS
CS Core 10
Digital vs Analog/Discrete vs Continuous Systems
Simple logic gates, logical expressions, Boolean logic simplification A
Clocks, State, Sequencing A
State and state transition (e.g., starting state, final state, life cycle of states) A
Finite state machines (e.g., NFA, DFA) A
Combinational Logic, Sequential Logic, Registers, Memories A
Computers and Network Protocols as examples of State Machines A
Sequential vs parallel processing. A
Application-level sequential processing: single thread A
Simple application-level parallel processing: request level (web services/client-server/distributed) single thread per server, multiple threads with multiple servers, pipelining (See also: PDC- Programs, OS-Concurrency) A
Illustrative Learning Outcomes 10
CS Core 10
Describe the differences between digital and analog systems, and between discrete and continuous
Can give real-world examples of these systems.
Describe computations as a system characterized by a known set of configurations with transitions from one unique configuration (state) to another (state).
Describe the distinction between systems whose output is only a function of their input (stateless) and those with memory/history (stateful).
Develop state machine descriptions for simple problem statement solutions (e.g., traffic light sequencing, pattern recognizers).
Describe a computer as a state machine that interprets machine instructions.
Explain how a program or network protocol can also be expressed as a state machine and that alternative representations for the same computation can exist.
Derive the time-series behavior of a state machine from its state machine representation (e.g., TCP connection management state machine).
Write a simple sequential problem and a simple parallel version of the same program.
Evaluate the performance of simple sequential and parallel versions of a program with different problem sizes and be able to describe the speed-ups achieved.
Describe on an execution timeline how parallelism events and operations can take place simultaneously (i.e., at the same time). Explain how work can be performed in less elapsed time if this can be exploited.
SF-Resource: Resource Management 1h CS 1h KA
CS Core 2
Different types of resources (e.g., processor share, memory, disk, net bandwidth) (See also: OS- Scheduling, OS-Memory, OS-Files, NC-Fundamentals)
Common resource allocation/scheduling algorithms (e.g., first-come-first-serve, priority-based scheduling, fair scheduling, and preemptive scheduling) E
KA Core 1
Advantages and disadvantages of common scheduling algorithms A
Illustrative Learning Outcomes 4
CS Core 3
Define how finite computer resources (e.g., processor share, memory, storage, and network bandwidth) are managed by their careful allocation to existing entities.
Describe how common resource allocation/scheduling algorithms work.
Develop common scheduling algorithms and evaluate their performances.
KA Core 1
Describe the pros and cons of common scheduling algorithms.
SF-Performance: System Performance 2h CS 2h KA
CS Core 4
Latencies in computer systems
Speed of light and computers (one foot per nanosecond vs one GHz clocks) (See also: AR- Organization)
Memory vs disk latencies vs across-the-network memory (See also: AR-Memory, AR- Performance-Energy)
Caches and the effects of spatial and temporal locality on performance in processors and systems A
Caches and cache coherency in databases, operating systems, distributed systems, and computer architecture A
Introduction to the processor memory hierarchy A
KA Core 4
The formula for average memory access time A
Rationale of virtualization and isolation: protection and predictable performance (See also: OS- Virtualization) A
Levels of indirection, illustrated by virtual memory for managing physical memory resources (See also: OS-Virtualization) A
Methods for implementing virtual memory and virtual machines Ev
Illustrative Learning Outcomes 6
CS Core 3
Describe the breakdown of the latency of computer systems in terms of memory, disk, and network.
Explain the importance of locality in determining system performance.
Calculate average memory access time and describe the tradeoffs in memory hierarchy performance in terms of capacity, miss/hit rate, and access time.
KA Core 3
Explain why it is important to isolate and protect the execution of individual programs and environments that share common underlying resources.
Describe how the concept of indirection can create the illusion of a dedicated machine and its resources even when physically shared among multiple programs and environments.
Evaluate the performance of two application instances running on separate virtual machines and determine the effect of performance isolation.
SF-Evaluation: Performance Evaluation 2h CS 2h KA
CS Core 7
Performance figures of merit
Workloads and representative benchmarks, and methods of collecting and analyzing performance figures of merit Ev
CPI (Cycles per Instruction) equation as a tool for understanding tradeoffs in the design of instruction sets, processor pipelines, and memory system organizations (See also: AR- Performance-Energy, PDC-Evaluation) Ev
Amdahl’s Law: the part of the computation that cannot be sped up limits the effect of the parts that can Ev
Order of magnitude analysis (Big O notation) Ev
Analysis of slow and fast paths of a system Ev
Events on their effect on performance (e.g., instruction stalls, cache misses, page faults) (See also: OS-Memory, AR-Organization) Ev
KA Core 3
Analytical tools to guide quantitative evaluation Ev
Understanding layered systems, workloads, and platforms, their implications for performance, and the challenges they represent for evaluation Ev
Microbenchmark pitfalls Ev
Illustrative Learning Outcomes 8
CS Core 6
Explain how the components of system architecture contribute to improving its performance.
Explain the circumstances in which a given figure of a system performance metric is useful.
Explain the usage and inadequacies of benchmarks as a measure of system performance.
Describe Amdahl’s law and discuss its limitations.
Apply limit studies or simple calculations to produce order-of-magnitude estimates for a given performance metric in a given context.
Apply software tools to profile and measure program performance.
KA Core 2
Design and conduct a performance-oriented experiment of a common system (e.g., an OS and Spark).
Design a performance experiment on a layered system to determine the effect of a system parameter on system performance.
SF-Reliability: System Reliability 2h CS 1h KA
CS Core 3
Distinction between bugs, faults, and failures
Reliability vs availability Ev
Reliability through redundancy Ev
check and retry
redundant encoding (error correction codes, CRC, FEC, RAID) (See also: AR-Memory, NC- Reliability, DM-Distributed)
duplication/mirroring/replicas
KA Core 1
Other approaches to reliability (e.g., journaling) Ev
Illustrative Learning Outcomes 5
CS Core 4
Explain the distinction between program errors, system errors, and hardware faults (e.g., corrupted memory) and exceptions (e.g., attempt to divide by zero).
Articulate the distinction between detecting, handling, and recovering from faults and the methods for their implementation.
Describe the role of error correction codes in providing error checking and correction techniques in memories, storage, and networks.
Apply simple algorithms for exploiting redundant information for the purposes of data correction.
KA Core 1
Compare different error detection and correction methods for their data overhead, implementation complexity, and relative execution time for encoding, detecting, and correcting errors.
SF-Design: System Design 2h CS 1h KA
CS Core 1
Common criteria of system design (e.g., liveness, safety, robustness, scalability, and security) (See also: PDC-Evaluation) D
KA Core 1
Designs of representative systems (e.g., Apache web server, Spark, and Linux) D
Illustrative Learning Outcomes 3
CS Core 2
Describe common criteria of system design.
Given the functionality requirements of a system and its key design criteria, provide a high-level design of this system.
KA Core 1
Describe the design of some representative systems.
SF-Security: System Security 2h CS 1h KA
CS Core 2
Common system security issues (e.g., viruses, denial-of-service attacks, and eavesdropping) (See also: OS-Protection, NC-Security, SEC-Foundations, SEC-Engineering) Ev
Countermeasures Ev
Cryptography
Security architecture
KA Core 1
Representative countermeasure systems Ev
Intrusion detection systems, firewalls
Antivirus systems
Illustrative Learning Outcomes 3
CS Core 2
Describe some common system security issues and give examples
Describe some countermeasures against system security issues
KA Core 1
Describe representative countermeasure systems
SF-SEP: Society, Ethics, and the Profession in SEP
KA Core 3
Intellectual property rights of computer systems
Common software licenses
Computer crimes
Illustrative Learning Outcomes 13
CS Core 5
Overview of development platforms (i.e., web, mobile, game, robotics, embedded, and interactive).
Input/sensors/control devices/haptic devices
Resource constraints
Computational
Data storage
Memory
Communication
Requirements – security, uptime availability, fault tolerance (See also: SE-Reliability, SEC- Engineering)
Output/actuators/haptic devices
Programming via platform-specific Application Programming Interface (API) vs traditional application construction
Overview of platform Languages (e.g., Python, Swift, Lua, Kotlin)
Programming under platform constraints and requirements (e.g., available development tools development, security considerations)
Techniques for learning and mastering a platform-specific programming language
KA Core 3
Describe the intellectual property rights of computer systems.
List representative software licenses and compare their differences.
List representative computer crimes. and evaluating systems. different requirements, constraints and working scenarios. As such, they require different designs. Students must be able to make appropriate design decisions correspondingly. ● Discrete Mathematics o Sets and relations o Basic graph theory o Basic logic ● Linear Algebra o Basic matrix operations ● Probability and Statistics o Random variable o Bayes theorem o Expectation and Variation o Cumulative distribution function and probability
Non-core 5
Analyzing requirements for web applications
Computing services
Cloud Hosting
Scalability (e.g., Autoscaling, Clusters)
Cost estimation for services
Data management
Data residency: where the data is located and what paths can be taken to access it
Data integrity: guaranteeing data is accessible and that data is deleted when required
Architecture
Monoliths vs Microservices
Micro-frontends
Event-Driven vs RESTful architectures: advantages and disadvantages
Serverless, cloud computing on demand
Storage solutions
Relational Databases
NoSQL databases
Professional Dispositions 2
Meticulous: Students must pay attention to details of different perspectives when learning about and evaluating systems.
Adaptive: Students must be flexible and adaptive when designing systems. Different systems have different requirements, constraints and working scenarios. As such, they require different designs. Students must be able to make appropriate design decisions correspondingly.
Mathematics Requirements 5
Required 3
Discrete Mathematics
Sets and relations
Basic graph theory
Basic logic
Linear Algebra
Basic matrix operations
Probability and Statistics
Random variable
Bayes theorem
Expectation and Variation
Cumulative distribution function and probability density function
Desirable 2
Basic queueing theory
Basic stochastic process
AR – Architecture and Organization 9 CS 16 KA 11 units
AR-Logic: Digital Logic and Digital Systems 2+1(SF)h KA
KA Core 5
Combinational vs sequential logic/field programmable gate arrays (FPGAs) (See also: SF- Overview, SF-Foundations, SPD-Embedded)
Fundamental combinational
Sequential logic building block
Computer-aided design tools that process hardware and architectural representations
High-level synthesis A
Register transfer notation
Hardware description language (e.g., Verilog/VHDL/Chisel)
System-on-chip (SoC) design flow A
Physical constraints A
Gate delays
Fan-in and fan-out
Energy/power
Speed of light
Illustrative Learning Outcomes 6
KA Core 6
Discuss the progression of computer technology components from vacuum tubes to VLSI, from mainframe computer architectures to the organization of warehouse-scale computers.
Describe parallelism and data dependencies between and within components in a modern heterogeneous computer architecture.
Explain the relationship between parallelism and power consumption.
Construct the design of basic building blocks for a computer: arithmetic-logic unit (gate-level) registers (gate-level), central processing unit (register transfer-level), and memory (register transfer- level).
Evaluate simple building blocks (e.g., arithmetic-logic unit, registers, movement between registers) of a simple computer design.
Analyze the timing behavior of a pipelined processor, identifying data dependency issues.
AR-Representation: Machine-Level Data Representation 1h CS
CS Core 6
Overview and history of computer architecture
Bits, bytes, and words
Unsigned, signed and two’s complement representations
Numeric data representation and number bases
Fixed-point
Floating-point
Representation of non-numeric data
Representation of records, arrays and UTF data types
Illustrative Learning Outcomes 7
CS Core 7
Discuss why everything in computers are data, including instructions.
Explain how fixed-length number representations can affect accuracy and precision.
Describe how negative integers are stored in sign-magnitude and two’s-complement representations.
Discuss how different formats can represent numerical data.
Explain the bit-level representation of non-numeric data, such as characters, strings, records, and arrays.
Translate numerical data from one format to another.
Describe how a single adder (without overflow detection) can handle both signed (two’s complement) and unsigned (binary) input without “knowing” which format a given input is using.
AR-Assembly: Assembly Level Machine Organization 1h CS 1+1(PDC)h KA
CS Core 4
von Neumann machine architecture E
Control unit: instruction fetch, decode, and execution E
Introduction to SIMD vs MIMD and the Flynn taxonomy (See also: PDC-Programs, OS-Scheduling OS-Process) E
Shared memory multiprocessors/multicore organization D
KA Core 4
Instruction set architecture (ISA) (e.g., x86, ARM and RISC-V) D
Fixed vs variable-width instruction sets
Instruction formats
Data manipulation, control, I/O
Addressing modes
Machine language programming
Assembly language programming
Subroutine call and return mechanisms D
I/O and interrupts E
Heap, static, stack, and code segments E
Illustrative Learning Outcomes 9
CS Core 3
Discuss how the classical von Neumann functional units are implemented in embedded systems particularly on-chip and off-chip memory.
Describe how instructions are executed in a classical von Neumann machine, with extensions for threads, multiprocessor synchronization, and SIMD execution.
Assess an example diagram with instruction-level parallelism and hazards to describe how they are managed in typical processor pipelines.
KA Core 6
Discuss how instructions are represented at the machine level and in the context of a symbolic assembler.
Map an example of high-level language patterns into assembly/machine language notations.
Contrast different instruction formats considering aspects such as addresses per instruction and variable-length vs fixed-length formats.
Analyze a subroutine diagram to comment on how subroutine calls are handled at the assembly level.
Describe basic concepts of interrupts and I/O operations.
Write a simple assembly language program for string/array processing and manipulation.
AR-Memory: Memory Hierarchy 4+2(OS)h CS
CS Core 9
Memory hierarchy: the importance of temporal and spatial locality (See also: SF-Performance, OS- Memory)
Main memory organization and operations
Persistent memory (e.g., SSD, standard disks)
Latency, cycle time, bandwidth, and interleaving
Cache memories Ev
Address mapping
Block size
Replacement and store policy
Prefetching
Multiprocessor cache coherence E
Virtual memory (hardware support)
Fault handling and reliability
Reliability
Error coding
Data compression
Data integrity
KA Core 1
Processing In-Memory (PIM) Ev
Illustrative Learning Outcomes 4
CS Core 4
Using a memory system diagram, identify the main types of memory technology (e.g., SRAM DRAM) and their relative cost and performance.
Measure the effect of memory latency on running time.
Enumerate the functions of a system with virtual memory management.
Compute average memory access time under various cache and memory configurations and mixes of instruction and data references.
AR-IO: Interfacing and Communication 1h CS
CS Core 5
I/O fundamentals D
Handshaking and buffering
Programmed I/O
Interrupt-driven I/O
Interrupt structures: vectored and prioritized, interrupt acknowledgment
I/O devices (e.g., mouse, keyboard, display, camera, sensors, actuators) (See also: GIT- Fundamentals, GIT-Interaction, OS-Advanced-Files, PDC-Programs) D
External storage, physical organization, and drives D
Buses fundamentals D
Bus protocols
Arbitration
Direct-memory access (DMA)
Illustrative Learning Outcomes 7
CS Core 3
Analyze an interrupt control diagram to comment on how interrupts are used to implement I/O control and data transfers.
Enumerate various types of buses in a computer system.
List the advantages of magnetic disks and contrast them with those of solid-state disks.
KA Core 4
Implementation of simple datapaths, including instruction pipelining, hazard detection, and resolution (e.g., stalls, forwarding)
Control unit
Hardwired implementation
Microprogrammed realization
Instruction pipelining
Introduction to instruction-level parallelism (ILP)
AR-Organization: Functional Organization 2h KA
KA Core 4
Implementation of simple datapaths, including instruction pipelining, hazard detection, and resolution (e.g., stalls, forwarding) E
Control unit
Hardwired implementation
Microprogrammed realization
Instruction pipelining E
Introduction to instruction-level parallelism (ILP) E
Illustrative Learning Outcomes 5
KA Core 5
Compare alternative implementation of datapaths in modern computer architectures.
Produce a set of control signals for adding two integers using hardwired and microprogrammed implementations.
Discuss instruction-level parallelism using pipelining and significant hazards that may occur.
Design a complete processor, including datapath and control.
Compute the average cycles per instruction for a given processor and memory system implementation.
AR-Performance-Energy: Performance and Energy Efficiency 3h KA
KA Core 8
Performance-energy evaluation (introduction): performance, power consumption, memory, and communication costs
Branch prediction, speculative execution, out-of-order execution, Tomasulo's algorithm E
Enhancements for vector processors and GPUs E
Hardware support for multithreading E
Race conditions
Lock implementations
Point-to-point synchronization
Barrier implementation
Scalability E
Alternative architectures including VLIW/EPIC, accelerators, and other special purpose processors E
Dynamic voltage and frequency scaling (DVFS) E
Dark Silicon E
Illustrative Learning Outcomes 7
KA Core 7
Discuss performance and energy efficiency evaluation metrics.
Analyze a speculative execution diagram and write about the decisions that can be made.
Create a GPU performance-watt benchmarking diagram.
Write a multithreaded program that adds (in parallel) elements of two integer vectors.
Recommend a set of design choices for alternative computer architectures.
Enumerate key concepts associated with dynamic voltage and frequency scaling.
Measure energy savings improvement for an 8-bit integer quantization compared to a 32-bit quantization.
AR-Heterogeneity: Heterogeneous Architectures 2h KA
KA Core 5
SIMD and MIMD architectures (e.g., General-Purpose GPUs, TPUs, and NPUs) (See also: PDC- Programs, SPD-Embedded, GIT-Shading, SPD-Game)
Heterogeneous memory systems
Shared memory versus distributed memory
Volatile vs non-volatile memory
Coherence protocols
Domain-Specific Architectures (DSAs)
Machine Learning Accelerator
In-networking computing
Embedded systems for emerging applications
Neuromorphic computing
Edge computing devices
Packaging and integration solutions such as 3DIC and chiplets
Machine learning in architecture design
AI algorithms for workload analysis
Optimization of architecture configurations for performance and power efficiency
Illustrative Learning Outcomes 6
Analyze a system diagram with alternative parallel architectures, e.g., SIMD and MIMD, and identify the key differences.
Discuss what memory-management issues are found in multiprocessors that are not present in uniprocessors and how these issues might be resolved.
Indicate the differences between memory backplane, processor memory interconnect, and remote memory via networks, their implications for access latency, and their impact on program performance.
Discuss how you would determine when to use a domain-specific accelerator instead of a general- purpose CPU.
Enumerate key differences in architectural design principles between a vector and scalar-based processing unit.
List the advantages and disadvantages of a PIM architecture.
AR-Security: Secure Processor Architectures 2h KA
KA Core 6
Principles of Secure Hardware E
Security Risk Analysis, Asset Protection, and Threat Model
Cryptographic Acceleration with Hardware
Support for virtualization (e.g., OS isolation)
Roots of trust in hardware, Physically Unclonable Functions (PUF) E
Hardware Random Number Generators E
Memory protection extensions E
Runtime pointer bounds checking (e.g., buffer overflow)
Protection at the microarchitectural level
Protection at the ISA level
Trusted Execution Environment (TEE) E
Trusted Computer Base Protections
Protecting virtual machines
Protecting containers
Trusted software modules (Enclaves)
Homomorphic encryption for privacy-preserving data processing
Illustrative Learning Outcomes 5
KA Core 5
Discuss principles of secure hardware, exploring a framework for risk analysis and asset protection.
Summarize how Physically Unclonable Functions (PUF) can be a unique device identifier in security applications.
Distinguish a random number generator with dedicated hardware support from generators without hardware dedicated to generating entropy.
List the advantages and disadvantages of memory protection at the ISA level.
Describe key design issues of a trusted execution environment (TEE).
AR-Quantum: Quantum Architectures 2h KA
KA Core 8
Principles E
The wave-particle duality principle
The uncertainty principle in the double-slit experiment
What is a Qubit? Superposition, interference, and measurement. Photons as qubits
Systems of two qubits, Entanglement, Bell states, The No-Signaling theorem
Axioms of QM: superposition principle, measurement axiom, unitary evolution E
Single qubit gates for the circuit model of quantum computation: X, Z, H E
Two qubit gates and tensor products, working with matrices E
The No-Cloning Theorem. The Quantum Teleportation protocol E
Algorithms E
Simple quantum algorithms: Bernstein-Vazirani, Simon’s algorithm
Implementing Deutsch-Josza with Mach-Zehnder Interferometers
Quantum factoring (Shor’s Algorithm)
Quantum search (Grover’s Algorithm)
Implementation aspects E
The physical implementation of qubits
Classical control of a Quantum Processing Unit (QPU)
Error mitigation and control, NISQ and beyond
Measurement approaches
Emerging Applications E
Post-quantum encryption
The Quantum Internet
Adiabatic quantum computation (AQC) and quantum annealing
Illustrative Learning Outcomes 8
KA Core 8
Discuss how a quantum object produced as a particle propagates like a wave and is detected as a particle with a probability distribution corresponding to the wave.
Discuss the quantum-level nature that is inherently probabilistic.
Express your view on entanglement that can be used to create non-classical correlations, but there is no way to use quantum entanglement to send messages faster than the speed of light.
Describe quantum parallelism and the role of constructive vs destructive interference in quantum algorithms given the probabilistic nature of measurement(s).
Analyze a code snippet providing the role of quantum Fourier transform (QFT) in Shor’s algorithm.
Write a program to implement Shor’s algorithm in a simulator, highlighting the classical components and aspects of Shor’s algorithm.
Enumerate the specifics of each qubit modality (e.g., trapped ion, superconducting, silicon spin photonic, quantum dot, neutral atom, topological, color center, electron-on-helium).
Contrast AQC with the gate model of quantum computation and the problems each is better suited to solve.
AR-SEP: Sustainability Issues in SEP
Non-core 1
Environmental impacts of implementation decisions
Sustainability goals, resource consumption, and economic viability
Carbon footprint, hardware electronic waste
The energy footprint of data centers at various workloads (e.g., AI model training and use)
Guidelines for sustainable design standards
Illustrative Learning Outcomes 3
CS Core 1
The Data Life Cycle: Creation-Processing-Review/Reporting-Retention/Retrieval-Destruction (See also: SEP-Context, SEP-Ethical-Analysis, SEP-Professional-Ethics, SEP-Privacy, SEP-Security SEC-Foundations)
KA Core 1
Systems supporting structured and/or stream content
Non-core 1
Assess the environmental impacts of a given project’s deployment (e.g., the energy consumption of CPUs and GPUs, contribution to e-waste, and effect of hardware virtualization in data centers). ● Self-directed: Students should increasingly become self-motivated to acquire complementary knowledge. ● Proactive: Students should exercise control and anticipate issues related to the underlying computer system. ● MSF-Discrete, MSF-Linear, MSF-Statistics, MSF-Calculus, MSF-Probability ● SEP-History (2
Professional Dispositions 2
Self-directed: Students should increasingly become self-motivated to acquire complementary knowledge.
Proactive: Students should exercise control and anticipate issues related to the underlying computer system. 109
Mathematics Requirements 1
MSF-Discrete, MSF-Linear, MSF-Statistics, MSF-Calculus, MSF-Probability
OS – Operating Systems 8 CS 13 KA 14 units
OS-Purpose: Role and Purpose of Operating Systems 2h CS
CS Core 7
Operating systems mediate between general purpose hardware and application-specific software. E
Universal operating system functions (e.g., process, user and device interfaces, persistence of data) D
Extended and/or specialized operating system functions (e.g., embedded systems, server types such as file, web, multimedia, boot loaders and boot security) D
Design issues (e.g., efficiency, robustness, flexibility, portability, security, compatibility, power safety, tradeoffs between error checking and performance, flexibility and performance, and security and performance) D
Influences of security, networking, multimedia, parallel and distributed computing D
Overarching concern of security/protection: Neglecting to consider security at every layer creates an opportunity to inappropriately access resources. Example concepts: D
Unauthorized access to files on an unencrypted drive can be achieved by moving the media to another computer.
Operating systems enforced security can be defeated by infiltrating the boot layer before the operating system is loaded.
Process isolation can be subverted by inadequate authorization checking at API boundaries.
Vulnerabilities in system firmware can provide attack vectors that bypass the operating system entirely.
Improper isolation of virtual machine memory, computing, and hardware can expose the host system to attacks from guest systems.
The operating system may need to mitigate exploitation of hardware and firmware vulnerabilities, leading to potential performance reductions (e.g., Spectre and Meltdown mitigations).
Exposure of operating systems functions in shells and systems programming. (See also: FPL- Scripting) D
Illustrative Learning Outcomes 4
CS Core 4
Understand the objectives and functions of modern operating systems.
Evaluate the design issues in different usage scenarios (e.g., real time OS, mobile, server).
Understand the functions of a contemporary operating system with respect to convenience efficiency, and the ability to evolve.
Understand how evolution and stability are desirable and mutually antagonistic in operating systems function.
OS-Principles: Principles of Operating System 2h CS
CS Core 9
Operating system software design and approaches (e.g., monolithic, layered, modular, micro- kernel, unikernel) E
Abstractions, processes, and resources E
Concept of system calls and links to application program interfaces (e.g., Win32, Java, Posix). (See also: AR-Assembly) E
The evolution of the link between hardware architecture and the operating system functions E
Protection of resources means protecting some machine instructions/functions (See also: AR- Assembly) Example concepts: E
Applications cannot arbitrarily access memory locations or file storage device addresses.
Protection of coprocessors and network devices
Leveraging interrupts from hardware level: service routines and implementations. (See also: AR- Assembly) Example concepts: E
Timer interrupts for implementing time slices
I/O interrupts for putting blocking threads to sleep without polling
Concept of user/system state and protection, transition to kernel mode using system calls (See also: AR-Assembly) E
Mechanism for invoking system calls, the corresponding mode and context switch and return from interrupt E
Performance costs of context switches and associated cache flushes when performing process switches in Spectre-mitigated environments. E
Illustrative Learning Outcomes 8
CS Core 8
Understand how the application of software design approaches to operating systems design/implementation (e.g., layered, modular, etc.) affects the robustness and maintainability of an operating system.
Categorize system calls by purpose.
Understand dynamics of invoking a system call (e.g., passing parameters, mode change).
Evaluate whether a function can be implemented in the application layer or can only be accomplished by system calls.
Apply OS techniques for isolation, protection, and throughput across OS functions (e.g., starvation similarities in process scheduling, disk request scheduling, semaphores, etc.) and beyond.
Understand how the separation into kernel and user mode affects safety and performance.
Understand the advantages and disadvantages of using interrupt processing in enabling multiprogramming.
Analyze potential vectors of attack via the operating systems and the security features designed to guard against them.
OS-Concurrency: Concurrency 2h CS 1h KA
CS Core 5
Thread abstraction relative to concurrency A
Race conditions, critical regions (role of interrupts, if needed) A
Deadlocks and starvation A
Multiprocessor issues (spin-locks, reentrancy). A
Multiprocess concurrency vs multithreading A
KA Core 6
Thread creation, states, structures A
Thread APIs A
Deadlocks and starvation (necessary conditions/mitigations) A
Implementing thread safe code (semaphores, mutex locks, condition variables). (See also: AR- Performance-Energy, SF-Evaluation, PDC-Evaluation) A
Race conditions in shared memory A
Managing atomic access to OS objects (e.g., big kernel lock vs many small locks vs lockless data structures like lists)
Illustrative Learning Outcomes 6
CS Core 3
Understand the advantages and disadvantages of concurrency as inseparable functions within the operating system framework.
Understand how architecture level implementation results in concurrency problems including race conditions.
Understand concurrency issues in multiprocessor systems.
KA Core 3
Understand the range of mechanisms that can be employed at the operating system level to realize concurrent systems and describe the benefits of each.
Understand techniques for achieving synchronization in an operating system (e.g., describe how a semaphore can be implemented using OS primitives) including intra-concurrency control and use of hardware atomics.
Accurately analyze code to identify race conditions and appropriate solutions for addressing race conditions.
OS-Scheduling: Scheduling 2h KA
KA Core 7
Preemptive and non-preemptive scheduling
Schedulers and policies (e.g., first come, first serve, shortest job first, priority, round robin multilevel)
Concepts of Symmetric Multi-Processor (SMP) scheduling and cache coherence (See also: AR- Memory)
Timers (e.g., building many timers out of finite hardware timers)
Fairness and starvation
Subtopics of operating systems such as energy-aware scheduling and real-time scheduling (See also: AR-Performance-Energy, SPD-Embedded, SPD-Mobile)
Cooperative scheduling, such as Linux futexes and userland scheduling.
Illustrative Learning Outcomes 6
KA Core 6
Compare and contrast the common algorithms used for both preemptive and non-preemptive scheduling of tasks in operating systems, such as priority, performance comparison, and fair-share schemes.
Explain the relationships between scheduling algorithms and application domains.
Explain the distinctions among types of processor scheduler such as short-term, medium-term long-term, and I/O.
Evaluate a problem or solution to determine appropriateness for asymmetric and/or symmetric multiprocessing.
List some contexts benefitting from preemption and deadline scheduling.
Explain the ways that the logic embodied in scheduling algorithms are applicable to other operating systems mechanisms, such as first come first serve or priority to disk I/O, network scheduling project scheduling, and problems beyond computing.
OS-Process: Process Model 2h KA
KA Core 5
Processes and threads relative to virtualization protected memory, process state, memory isolation, etc. E
Memory footprint/segmentation (e.g., stack, heap, etc.) E
Creating and loading executables, shared libraries, and dynamic linking E
Dispatching and context switching E
Interprocess communication (e.g., shared memory, message passing, signals, environment variables) E
Illustrative Learning Outcomes 5
KA Core 5
Understand how processes and threads use concurrency features to virtualize control.
Understand reasons for using interrupts, dispatching, and context switching to support concurrency and virtualization in an operating system.
Understand the different states that a task may pass through, and the data structures needed to support the management of many tasks.
Understand the different ways of allocating memory to tasks, citing the relative merits of each.
Apply the appropriate interprocess communication mechanism for a specific purpose in a programmed software artifact.
OS-Memory: Memory Management 0.5+1.5(AR)h KA
KA Core 8
Review of physical memory, address translation and memory management hardware (See also: AR-Memory, MSF-Discrete) E
Impact of memory hierarchy including cache concept, cache lookup, and per-CPU caching on operating system mechanisms and policy E
Logical and physical addressing, address space virtualization (See also: AR-Memory, MSF- Discrete) E
Concepts of paging, page replacement, thrashing and allocation of pages and frames E
Allocation/deallocation/storage techniques (algorithms and data structure) performance and flexibility Example concept: Arenas, slab allocators, free lists, size classes, heterogeneously sized pages (huge pages) E
Memory caching and cache coherence and the effect of flushing the cache to avoid speculative execution vulnerabilities E
Security mechanisms and concepts in memory management including sandboxing, protection isolation, and relevant vectors of attack E
Virtual memory: leveraging virtual memory hardware for OS services and efficiency
Illustrative Learning Outcomes 6
KA Core 6
Explain memory hierarchy and cost-performance tradeoffs.
Summarize the principles of virtual memory as applied to caching and paging.
Evaluate the tradeoffs in terms of memory size (main memory, cache memory, auxiliary memory) and processor speed.
Describe the reason for and use of cache memory (performance and proximity, how caches complicate isolation and virtual machine abstraction).
Code/Develop efficient programs that consider the effects of page replacement and frame allocation on the performance of a process and the system in which it executes.
Explain how hardware is utilized for efficient virtualization
OS-Devices: Device management 0.5+0.5(AR)h KA
KA Core 6
Buffering strategies E
Direct Memory Access (DMA) and polled I/O, Memory-mapped I/O Example concept: DMA communication protocols (e.g., ring buffers etc.) E
Historical and contextual - Persistent storage device management (e.g., magnetic, Solid State Device (SSD)) E
Device interface abstractions, hardware abstraction layer
Device driver purpose, abstraction, implementation, and testing challenges
High-level fault tolerance in device communication
Illustrative Learning Outcomes 6
KA Core 6
Explain architecture level device control implementation and link relevant operating system mechanisms and policy (e.g., buffering strategies, direct memory access).
Explain OS device management layers and the architecture (e.g., device controller, device driver device abstraction).
Explain the relationship between the physical hardware and the virtual devices maintained by the operating system.
Explain I/O data buffering and describe strategies for implementing it.
Describe the advantages and disadvantages of direct memory access and discuss the circumstances in which its use is warranted.
Describe the complexity and best practices for the creation of device drivers.
OS-Files: File Systems API and Implementation 2h KA
KA Core 9
Concept of a file including data, metadata, operations, and access-mode E
File system mounting E
File access control E
File sharing E
Basic file allocation methods, including linked allocation table E
File system structures comprising file allocation including various directory structures and methods for uniquely identifying files (e.g., name, identified or metadata storage location) E
Allocation/deallocation/storage techniques (algorithms and data structure) impact on performance and flexibility (i.e., internal and external fragmentation and compaction) E
Free space management such as using bit tables vs linking E
Implementation of directories to segment and track file location E
Illustrative Learning Outcomes 3
KA Core 3
Explain the choices to be made in designing file systems.
Evaluate different approaches to file organization, recognizing the strengths and weaknesses of each.
Apply software constructs appropriately given knowledge of the file system implementation.
OS-Advanced-Files: Advanced File systems 1h KA
KA Core 9
File systems: partitioning, mount/unmount, virtual file systems E
In-depth implementation techniques E
Memory-mapped files E
Special-purpose file systems E
Naming, searching, access, backups E
Journaling and log-structured file systems E
Distributed file systems E
Encrypted file systems E
Fault tolerance
Illustrative Learning Outcomes 8
KA Core 8
Explain how hardware developments have led to changes in the priorities for the design and the management of file systems.
Map file abstractions to a list of relevant devices and interfaces.
Identify and categorize different mount types.
Explain specific file systems requirements and the specialized file systems features that meet those requirements.
Explain the use of journaling and how log-structured file systems enhance fault tolerance.
Explain purpose and complexity of distributed file systems.
List examples of distributed file systems protocols.
Explain mechanisms in file systems to improve fault tolerance.
OS-Virtualization: Virtualization 1h KA
KA Core 5
Using virtualization and isolation to achieve protection and predictable performance. (See also: SF- Performance)
Advanced paging and virtual memory.
Virtual file systems and virtual devices.
Containers and their comparison to virtual machines.
Thrashing (e.g., Popek and Goldberg requirements for recursively virtualizable systems).
Non-core 5
Types of virtualizations (including hardware/software, OS, server, service, network). (See also: SF- Performance)
Portable virtualization; emulation vs isolation.
Cost of virtualization.
Virtual machines and container escapes, dangers from a security perspective. (See also: SEC- Engineering)
Hypervisors- hardware virtual machine extensions, hosts with kernel support, QEMU KVM
Illustrative Learning Outcomes 4
KA Core 4
Explain how hardware architecture provides support and efficiencies for virtualization.
Explain the difference between emulation and isolation.
Evaluate virtualization tradeoffs.
Explain hypervisors and the need for them in conjunction with different types of hypervisors.
OS-Faults: Fault tolerance 1h KA
KA Core 9
Reliable and available systems. E
Software and hardware approaches to address tolerance (RAID). E
Spatial and temporal redundancy.
Methods used to implement fault tolerance.
Error identification and correction mechanisms, checksums of volatile memory in RAM. (See also: AR-Memory)
File system consistency check and recovery.
Journaling and log-structured file systems. E
Use-cases for fault-tolerance (databases, safety-critical).
Examples of OS mechanisms for detection, recovery, restart to implement fault tolerance, use of these techniques for the OS’s own services.
Illustrative Learning Outcomes 5
KA Core 5
Explain how operating systems can facilitate fault tolerance, reliability, and availability.
Explain the range of methods for implementing fault tolerance in an operating system.
Explain how an operating system can continue functioning after a fault occurs.
Explain the performance and flexibility tradeoffs that impact using fault tolerance.
Describe operating systems fault tolerance issues and mechanisms in detail.
OS-Protection: Protection and Safety 2h CS 1h KA
CS Core 4
Overview of operating system security mechanisms A
Attacks and antagonism (scheduling, etc.) A
Review of major vulnerabilities in real operating systems A
Operating systems mitigation strategies such as backups A
KA Core 3
Policy/mechanism separation A
Security methods and devices Example concepts: E
Rings of protection (history from Multics to virtualized x86)
x86_64 rings -1 and -2 (hypervisor and ME/PSP)
Protection, access control, and authentication E
Illustrative Learning Outcomes 4
CS Core 3
Understand the requirement for protection and security mechanisms in operating systems.
List and describe the attack vectors that leverage OS vulnerabilities.
Understand the mechanisms available in an OS to control access to resources.
KA Core 1
Summarize the features and limitations of an operating system that impact protection and security.
OS-Real-time: Real-time and Embedded Systems 1h KA
KA Core 6
Process and task scheduling. E
Deadlines and real-time issues. E
Low-latency vs ”soft real-time" vs "hard real time." E
Memory/disk management requirements in a real-time environment.
Failures, risks, and recovery.
Special concerns in real-time systems (safety).
Illustrative Learning Outcomes 4
KA Core 4
Explain what makes a system a real-time system.
Explain latency and its sources in software systems and its characteristics.
Explain special concerns that real-time systems present, including risk, and how these concerns are addressed.
Explain specific real time operating systems features and mechanisms.
OS-SEP: Society, Ethics, and the Profession in SEP
KA Core 2
Open source in operating systems. Example concepts: E
Identification of vulnerabilities in open-source kernels
Open-source guest operating systems
Open-source host operating systems, and
Changes in monetization (paid vs free upgrades).
End-of-life issues with sunsetting operating systems. Example concept: Privacy implications of using proprietary operating systems/operating environments, including telemetry, automated scanning of personal data, built-in advertising, and automatic cloud integration. E
Illustrative Learning Outcomes 8
CS Core 4
Parallelism
Declarative parallelism: Determining which actions may, or must not, be performed in parallel, at the level of instructions, functions, closures, composite actions, sessions, tasks and services is the main idea underlying PDC algorithms; failing to do so is the main source of errors.
Defining order: for example, using happens-before relations or series/parallel directed acyclic graphs representing programs.
Independence: determining when ordering does not matter, in terms of commutativity dependencies, preconditions.
Ensuring ordering among otherwise parallel actions when necessary, including locking, safe publication; and imposing communication – sending a message happens before receiving it conversely relaxing when unnecessary.
Distribution
Defining places, as devices executing actions, including hardware components, remote hosts, may also include external, uncontrolled devices, hosts, and users.
One device may time-slice or otherwise emulate multiple parallel actions by fewer processors by scheduling and virtualization.
Naming or identifying places (e.g., device IDs) and actions as parties (e.g., thread IDs).
Activities across places may communicate across media.
Starting activities
Options that enable actions to be performed (eventually) at places range from hardwiring to configuration scripts; also establishing communication and resource management; these are expressed differently across languages and contexts, usually relying on automated provisioning and management by platforms
Procedural: Enabling multiple actions to start at a given program point; for example, starting new threads, possibly scoping, or otherwise organizing them in hierarchical groups
Reactive: Enabling upon an event by installing an event handler, with less control of when actions begin or end, and may apply even on uniprocessors
Dependent: Enabling upon completion of others; for example, sequencing sets of parallel actions
Granularity: Execution cost of action bodies should outweigh the overhead of arranging them
Execution Properties
Nondeterministic execution of unordered actions
Consistency: Ensuring agreement among parties about values and predicates when necessary to avoid races, maintain safety and atomicity, or arrive at consensus
Fault tolerance: Handling failures in parties or communication, including (Byzantine) misbehavior due to untrusted parties and protocols, when necessary to maintain progress or availability
Tradeoffs are one focus of evaluation
KA Core 4
Explain advantages and disadvantages of finding and addressing bugs in open-source kernels.
Contextualize history and positive and negative impact of Linux as an open-source product.
List complications with reliance on operating systems past end-of-life.
Understand differences in finding and addressing bugs for various operating systems payment models. systems components are used. any project. ● OS-Purpose (3 hours) ● OS-Principles (3 hours) ● OS-Concurrency (7 hours) ● OS-Scheduling (3 hours) ● OS-Process (3 hours) ● OS-Memory (4 hours) ● OS-Protection (4 hours) ● OS-Devices (2 hours) ● OS-Files (2 hours) ● OS-Virtualization (3 hours) ● OS-Advanced-Files (2 hours) ● OS-Real-time (1 hour) ● OS-Faults (1 hour) ● OS-SEP (4 hours) ● AR-Assembly ● A
Professional Dispositions 2
Proactive: Students must anticipate the security and performance implications of how operating systems components are used.
Meticulous: Students must carefully analyze the implications of operating system mechanisms on any project.
Mathematics Requirements 1
Required 1
MSF-Discrete
PDC – Parallel and Distributed Computing 9 CS 26 KA 5 units
PDC-Programs: Programs 2h CS 2h KA
CS Core 4
Parallelism
Declarative parallelism: Determining which actions may, or must not, be performed in parallel, at the level of instructions, functions, closures, composite actions, sessions, tasks and services is the main idea underlying PDC algorithms; failing to do so is the main source of errors.
Defining order: for example, using happens-before relations or series/parallel directed acyclic graphs representing programs.
Independence: determining when ordering does not matter, in terms of commutativity dependencies, preconditions.
Ensuring ordering among otherwise parallel actions when necessary, including locking, safe publication; and imposing communication – sending a message happens before receiving it conversely relaxing when unnecessary.
Distribution E
Defining places, as devices executing actions, including hardware components, remote hosts, may also include external, uncontrolled devices, hosts, and users.
One device may time-slice or otherwise emulate multiple parallel actions by fewer processors by scheduling and virtualization.
Naming or identifying places (e.g., device IDs) and actions as parties (e.g., thread IDs).
Activities across places may communicate across media.
Starting activities E
Options that enable actions to be performed (eventually) at places range from hardwiring to configuration scripts; also establishing communication and resource management; these are expressed differently across languages and contexts, usually relying on automated provisioning and management by platforms
Procedural: Enabling multiple actions to start at a given program point; for example, starting new threads, possibly scoping, or otherwise organizing them in hierarchical groups
Reactive: Enabling upon an event by installing an event handler, with less control of when actions begin or end, and may apply even on uniprocessors
Dependent: Enabling upon completion of others; for example, sequencing sets of parallel actions
Granularity: Execution cost of action bodies should outweigh the overhead of arranging them
Execution Properties E
Nondeterministic execution of unordered actions
Consistency: Ensuring agreement among parties about values and predicates when necessary to avoid races, maintain safety and atomicity, or arrive at consensus
Fault tolerance: Handling failures in parties or communication, including (Byzantine) misbehavior due to untrusted parties and protocols, when necessary to maintain progress or availability
Tradeoffs are one focus of evaluation
KA Core 1
One or more of the following mappings and mechanisms across layered systems: D
CPU data- and instruction-level-parallelism
SIMD and heterogeneous data parallelism
Multicore scheduled concurrency, tasks, actors
Clusters, clouds; elastic provisioning.
Networked distributed systems
Emerging technologies such as quantum computing and molecular computing
Illustrative Learning Outcomes 5
CS Core 2
Graphically show (as a Directed Acyclic Graph (DAG)) how to parallelize a compound numerical expression; for example, a = (b + c) * (d + e).
Explain why the concepts of consistency and fault tolerance do not arise in purely sequential programs.
KA Core 3
Write a function that efficiently counts events such as networking packet receptions.
Write a filter/map/reduce program in multiple styles.
Write a service that creates a thread (or other procedural form of activation) to return a requested web page to each new client.
PDC-Communication: Communication 2h CS 6h KA
CS Core 4
Media
Varieties: channels (message passing or I/O), shared memory, heterogeneous, data stores
Reliance on the availability and nature of underlying hardware, connectivity, and protocols language support, emulation
Channels E
Explicit (usually named) party-to-party communication media
APIs: Sockets, architectural, language-based, and toolkit constructs, such as Message Passing Interface (MPI), and layered constructs such as Remote Procedure Call (RPC) (See also: NC-Fundamentals)
I/O channel APIs
Memory E
Shared memory architectures in which parties directly communicate only with memory at given addresses, with extensions to heterogeneous memory supporting multiple memory stores with explicit data transfer across them; for example, GPU local and shared memory Direct Memory Access (DMA)
Memory hierarchies: Multiple layers of sharing domains, scopes, and caches; locality: latency, false-sharing
Consistency properties: Bitwise atomicity limits, coherence, local ordering
Data Stores E
Cooperatively maintained data structures implementing maps and related ADTs
Varieties: Owned, shared, sharded, replicated, immutable, versioned
KA Core 1
One or more of the following properties and extensions D
Topologies: Unicast, Multicast, Mailboxes, Switches; Routing via hardware and software interconnection networks
Media concurrency properties: Ordering, consistency, idempotency, overlapping communication with computation
Media performance: Latency, bandwidth (throughput) contention (congestion) responsiveness (liveness), reliability (error and drop rates), protocol-based progress (acks timeouts, mediation)
Media security properties: integrity, privacy, authentication, authorization (See also: SEC- Secure Coding)
Data formats: Marshaling, validation, encryption, compression
Channel policies: Endpoints, sessions, buffering, saturation response (waiting vs dropping) rate control
Multiplexing and demultiplexing many relatively slow I/O devices or parties; completion- based and scheduler-based techniques; async-await, select and polling APIs
Formalization and analysis of channel communication; for example, CSP
Applications of queuing theory to model and predict performance.
Memory models: sequential and release/acquire consistency
Memory management; including reclamation of shared data; reference counts and alternatives
Bulk data placement and transfer; reducing message traffic and improving locality overlapping data transfer and computation; impact of data layout such as array-of-structs vs struct-of-arrays
Emulating shared memory: distributed shared memory, Remote Direct Memory Access (RDMA)
Data store consistency: Atomicity, linearizability, transactionality, coherence, causal ordering, conflict resolution, eventual consistency, blockchains
Faults, partitioning, and partial failures; voting; protocols such as Paxos and Raft.
Design tradeoffs among consistency, availability, partition (fault) tolerance; impossibility of meeting all at once
Security and trust: Byzantine failures, proof of work and alternatives
Illustrative Learning Outcomes 13
CS Core 1
Explain the similarities and differences among: (1) Party A sends a message on channel X with contents 1 received by party B (2) A sets shared variable X to 1, read by B (3) A sets “X=1’ in a distributed shared map accessed by B.
KA Core 12
Write a program that distributes different segments of a data set to multiple workers, and collects results (for the simplest example, summing segments of an array).
Write a parallel program that requests data from multiple sites and summarizes them using some form of reduction.
Compare the performance of buffered versus unbuffered versions of a producer-consumer program.
Determine whether a given communication scheme provides sufficient security properties for a given usage.
Give an example of an ordering of accesses among concurrent activities (e.g., program with a data race) that is not sequentially consistent.
Give an example of a scenario in which blocking message sends can deadlock.
Describe at least one design technique for avoiding liveness failures in programs using multiple locks.
Write a program that illustrates memory-access or message reordering.
Describe the relative merits of optimistic versus conservative concurrency control under different rates of contention among updates.
Give an example of a scenario in which an attempted optimistic update may never complete.
Modify a concurrent system to use a more scalable, reliable, or available data store.
Using an existing platform supporting replicated data stores, write a program that maintains a key- value mapping even when one or more hosts fail.
PDC-Coordination: Coordination 2h CS 6h KA
CS Core 3
Dependencies
Initiation or progress of one activity may be dependent on other activities, so as to avoid race conditions, ensure termination, or meet other requirements
Ensuring progress by avoiding dependency cycles, using monotonic conditions, removing inessential dependencies
Control constructs and design patterns E
Completion-based: Barriers, joins, including termination control
Data-enabled: Queues, producer-consumer designs
Condition-based: Polling, retrying, backoffs, helping, suspension, signaling, timeouts
Reactive: Enabling and triggering continuations
Atomicity E
Atomic instructions, enforced local access orderings
Locks and mutual exclusion; lock granularity
Using locks in a specific language; maintaining liveness without introducing races
Deadlock avoidance: Ordering, coarsening, randomized retries; backoffs, encapsulation via lock managers
Common errors: Failing to lock or unlock when necessary, holding locks while invoking unknown operations
Avoiding locks: replication, read-only, ownership, and non-blocking constructions
KA Core 1
One or more of the following properties and extensions D
Progress properties including lock-free, wait-free, fairness, priority scheduling, interactions with consistency, reliability
Performance with respect to contention, granularity, convoying, scaling
Non-blocking data structures and algorithms
Ownership and resource control
Lock variants and alternatives: sequence locks, read-write locks; Read-Copy-Update (RCU) reentrancy; tickets; controlling spinning versus blocking
Transaction-based control: Optimistic and conservative
Distributed locking: reliability
Alternatives to barriers: Clocks; counters, virtual clocks; dataflow and continuations; futures and RPC; consensus-based, gathering results with reducers and collectors
Speculation, selection, cancellation; observability and security consequences
Resource control using semaphores and condition variables
Control flow: Scheduling computations, series-parallel loops with (possibly elected) leaders pipelines and streams, nested parallelism
Exceptions and failures. Handlers, detection, timeouts, fault tolerance, voting
Illustrative Learning Outcomes 9
CS Core 2
Show how to avoid or repair a race error in a given program.
Show how to ensure that a program correctly terminates when all of a set of concurrent tasks have completed.
KA Core 7
Write a function that efficiently counts events such as sensor inputs or networking packet receptions.
Write a filter/map/reduce program in multiple styles.
Write a program in which the termination of one set of parallel actions is followed by another.
Write a program that speculatively searches for a solution by multiple activities, terminating others when one is found.
Write a program in which a numerical exception (such as divide by zero) in one activity causes termination of others.
Write a program for multiple parties to agree upon the current time of day; discuss its limitations compared to protocols such as network transfer protocol (NTP).
Write a service that creates a thread (or other procedural form of activation) to return a requested web page to each new client.
PDC-Algorithms: Algorithms 2h CS 9h KA
CS Core 2
Expressing and implementing algorithms in given languages and frameworks, to initiate activities (for example threads), use shared memory constructs, and channel, socket, and/or remote procedure call APIs. .
Data parallel examples including map/reduce.
Using channel, socket, and/or RPC APIs in a given language, with program control for sending (usually procedural) vs receiving. (usually reactive or RPC-based).
Using locks, barriers, and/or synchronizers to maintain liveness without introducing races.
Survey of common application domains across multicore, reactive, data parallel, cluster, cloud open distributed systems, and frameworks (with reference to the following table). Category Typical Typical Typical Typical Execution agents Communication Algorithmic Engineering mechanisms domains goals Multicore Threads Shared memory, Resource Throughput Atomics, locks management, latency data processing energy Reactive Handlers, threads I/O Channels Services, real- Latency time Data parallel GPU, SIM D
KA Core 1
One of more of the following algorithmic domains. : Ev
Linear algebra: Vector and matrix operations, numerical precision/stability, applications in data analytics and machine learning.
Data processing: sorting, searching and retrieval, concurrent data structures.
Graphs, search, and combinatorics: Marking, edge-parallelization, bounding, speculation network-based analytics.
Modeling and simulation: differential equations; randomization, N-body problems, genetic algorithms.
Computational logic: satisfiability (SAT), concurrent logic programming.
Graphics and computational geometry: Transforms, rendering, ray-tracing.
Resource management: Allocating, placing, recycling and scheduling processors, memory channels, and hosts; exclusive vs shared resources; static, dynamic and elastic algorithms Real-time constraints; Batching, prioritization, partitioning; decentralization via work-stealing and related techniques.
Services: Implementing web APIs, electronic currency, transaction systems, multiplayer games.
Illustrative Learning Outcomes 20
CS Core 6
Implement a parallel/distributed component based on a known algorithm.
Write a data-parallel program that for example computes the average of an array of numbers.
Write a producer-consumer program in which one component generates numbers, and another computes their average. Measure speedups when the numbers are small scalars versus large multi-precision values.
Extend an event-driven sequential program by establishing a new activity in an event handler (for example a new thread in a GUI action handler).
Improve the performance of a sequential component by introducing parallelism and/or distribution.
Choose among different parallel/distributed designs for components of a given system.
KA Core 14
Design, implement, analyze, and evaluate a component or application for X operating in a given context, where X is in one of the listed domains, for example, a genetic algorithm for factory floor design.
Critique the design and implementation of an existing component or application, or one developed by classmates.
Compare the performance and energy efficiency of multiple implementations of a similar design, for example, multicore versus clustered versus GPU. correctness conditions. evident.
Programs: KA Core on threads, tasks, instruction-level parallelism.
Communication: KA Core on multicore architectures, memory, concurrent data stores.
Coordination: KA Core on blocking and non-blocking synchronization, speculation, cancellation futures, and divide-and-conquer data parallelism.
Evaluation: KA Core on performance analysis.
Algorithms: project-based KA Core coverage of data processing and resource management. ● Sherif Aly, American University of Cairo, Cairo, Egypt ● Michael Oudshoorn, High Point University, High Point, NC, USA ● Qiao Xiang, Xiamen University, Xiamen, China ● Dan Grossman, University of Washington, Seattle, WA, USA ● Sebastian Burckhardt, Microsoft Research, Redmond WA, USA ● Vivek Sarkar, Georgia Tech, Atlanta, GA, USA ● Maurice Herlihy, Brown University, Providence, RI, USA ● Sheikh Ghafoor, Tenn
Prasad, S. K., Estrada, T., Ghafoor, S., Gupta, A., Kant, K., Stunkel, C., Sussman, A. Vaidyanathan, R., Weems, C., Agrawal, K., Barnas, M., Brown, D. W., Bryant, R., Bunde, D. P. Busch, C., Deb, D., Freudenthal, E., Jaja, J., Parashar, M., Phillips, C., Robey, B., Rosenberg, A. Saule, E., Shen, C. 2020. NSF/IEEE-TCPP Curriculum Initiative on Parallel and Distributed Computing - Core Topics for Undergraduates, Version II-beta Online: http://tcpp.cs.gsu.edu/curriculum/, 53 pages. Accessed March 2
SDF-Fundamentals: Fundamental Programming Concepts and Practices – This knowledge unit aims to develop an understanding of basic concepts, and the ability to fluently use basic language constructs as well as modularity constructs. It also aims to familiarize students with the concept of common libraries and frameworks, including those to facilitate API-based access to resources.
SDF-Data-Structures: Fundamental Data Structures – This knowledge unit aims to develop core concepts relating to Data Structures and associated operations. Students should understand the important data structures available in the programming language or as libraries, and how to use them effectively, including choosing appropriate data structures while designing solutions for a given problem.
SDF-Algorithms: Algorithms – This knowledge unit aims to develop the foundations of algorithms and their analysis. The KU should also empower students in selecting suitable algorithms for building modest-complexity applications.
SDF-Practices: Software Development Practices – This knowledge unit develops the core concepts relating to modern software development practices. It aims to develop student understanding and basic competencies in program testing, enhancing the readability of programs and using modern methods and tools including some general-purpose IDE.
SDF-SEP: Society, Ethics, and the Profession – This knowledge unit aims to develop an initial understanding of some of the ethical issues related to programming, professional values programmers need to have, and the responsibility to society that programmers have. This knowledge unit is a part of the SEP Knowledge Area. Knowledge Unit CS Core KA Core Fundamental Programming Concepts 20 and Practices Fundamental Data Structures 6 + 6 (AL) Algorithms 3 + 3 (AL) Software Development Practices 5 Soc
PDC-Evaluation: Evaluation 1h CS 3h KA
CS Core 5
Safety and liveness requirements in terms of temporal logic constructs to express “always” and “eventually”
Identifying, testing for, and repairing violations, including common forms of errors such as failure to ensure necessary ordering (race errors), atomicity (including check-then-act errors), and termination (livelock) Ev
Performance requirements metrics for throughput, responsiveness, latency, availability, energy consumption, scalability, resource usage, communication costs, waiting and rate control, fairness service level agreements Ev
Performance impact of design and implementation choices, including granularity, overhead consensus costs, and energy consumption Ev
Estimating scalability limitations, for example using Amdahl’s Law or Universal Scalability Law (See also: SF-Evaluation) E
KA Core 1
One or more of the following methods and tools: Ev
Extensions to formal sequential requirements such as linearizability
Protocol, session, and transactional specifications
Use of tools such as Unified Modelling Language (UML), Temporal Logic of Actions (TLA) program logics
Security analysis: safety and liveness in the presence of hostile or buggy behaviors by other parties; required properties of communication mechanisms (for example lack of cross-layer leakage), input screening, rate limiting
Static analysis applied to correctness, throughput, latency, resources, energy (See also: SEP-Sustainability)
Directed Acyclic Graph (DAG) model analysis of algorithmic efficiency (work, span, critical paths)
Testing and debugging; tools such as race detectors, fuzzers, lock dependency checkers unit/stress/torture tests, visualizations, continuous integration, continuous deployment, and test generators
Measuring and comparing throughput, overhead, waiting, contention, communication, data movement, locality, resource usage, behavior in the presence of excessive numbers of events, clients, or threads
Application domain specific analyses and evaluation techniques
Illustrative Learning Outcomes 12
CS Core 6
Revise a specification to enable parallelism and distribution without violating other essential properties or features.
Explain how concurrent notions of safety and liveness extend their sequential counterparts.
Specify a set of invariants that must hold at each bulk-parallel step of a computation.
Write a test program that can reveal a data race error; for example, missing an update when two activities both try to increment a variable.
In a given context, explain the extent to which introducing parallelism in an otherwise sequential program would be expected to improve throughput and/or reduce latency, and how it may impact energy efficiency.
Show how scaling and efficiency change for sample problems without and with the assumption of problem size changing with the number of processors; further explain whether and how scalability would change under relaxations of sequential dependencies.
KA Core 6
Specify and measure behavior when a service is requested by unexpectedly many clients.
Identify and repair a performance problem due to sequential bottlenecks.
Empirically compare throughput of two implementations of a common design (perhaps using an existing test harness framework).
Identify and repair a performance problem due to communication or data latency.
Identify and repair a performance problem due to resource management overhead.
Identify and repair a reliability or availability problem.
Professional Dispositions 2
Meticulous: Students’ attention to detail is essential when applying constructs with non-obvious correctness conditions.
Persistent: Students must be prepared to try alternative approaches when solutions are not self- evident.
Mathematics Requirements 3
Required 1
MSF-Discrete – Logic, discrete structures including directed graphs.
Desired 2
MSF-Linear
MSF-Calculus – Differential equations
NC – Networking and Communication 7 CS 24 KA 8 units
NC-Fundamentals: Fundamentals 2.5+0.25(SEP)+0.25(SF)h CS
CS Core 7
Importance of networking in contemporary computing, and associated challenges. (See also: SEP- Context, SEP-Privacy)
Organization of the internet (e.g., users, Internet Service Providers, autonomous systems, content providers, content delivery networks) E
Switching techniques (e.g., circuit and packet) Ev
Layers and their roles (application, transport, network, datalink, and physical) E
Layering principles (e.g., encapsulation and hourglass model) E
Network elements (e.g., routers, switches, hubs, access points, and hosts) E
Basic queueing concepts (e.g., relationship with latency, congestion, service levels, etc.) E
Illustrative Learning Outcomes 4
CS Core 4
Articulate the organization of the internet.
List and define the appropriate network terminology.
Describe the layered structure of a typical networked architecture.
Identify the different types of complexity in a network (edges, core, etc.).
NC-Applications: Networked Applications 3.5+0.25(SEP)+0.25(PDC)h CS
CS Core 5
Naming and address schemes (e.g., DNS, and Uniform Resource Identifiers)
Distributed application paradigms (e.g., client/server, peer-to-peer, cloud, edge, and fog) (See also: PDC-Communication, PDC-Coordination) Ev
Diversity of networked application demands (e.g., latency, bandwidth, and loss tolerance) (See also: PDC-Communication, SEP-Sustainability, SEP-Context) E
Coverage of application-layer protocols (e.g., HTTP)
Interactions with TCP, UDP, and Socket APIs E
Illustrative Learning Outcomes 4
CS Core 4
Define the principles of naming, addressing, resource location.
Analyze the needs of specific networked application demands.
Describe the details of one application layer protocol.
Implement a simple client-server socket-based application.
NC-Reliability: Reliability Support 5.75+0.25(SF)h KA
KA Core 6
Unreliable delivery (e.g., UDP) E
Principles of reliability (e.g., delivery without loss, duplication, or out of order) (See also: SF- Reliability) D
Error control (e.g., retransmission, error correction) Ev
Flow control (e.g., stop and wait, window based) D
Congestion control (e.g., implicit and explicit congestion notification) E
TCP and performance issues (e.g., Tahoe, Reno, Vegas, Cubic) Ev
Illustrative Learning Outcomes 4
KA Core 4
Describe the operation of reliable delivery protocols.
List the factors that affect the performance of reliable delivery protocols.
Describe some TCP reliability design issues.
Design and implement a simple reliable protocol.
NC-Routing: Routing and Forwarding 4h KA
KA Core 3
Routing paradigms and hierarchy (e.g., intra/inter domain, centralized and decentralized, source routing, virtual circuits, QoS) Ev
Forwarding methods (e.g., forwarding tables and matching algorithms) A
IP and Scalability issues (e.g., NAT, CIDR, BGP, different versions of IP) E
Illustrative Learning Outcomes 3
KA Core 3
Describe various routing paradigms and hierarchies.
Describe how packets are forwarded in an IP network.
Describe how the Internet tackles scalability challenges. .
NC-SingleHop: Single Hop Communication 3h KA
KA Core 6
Introduction to modulation, bandwidth, and communication media Ev
Encoding and Framing Ev
Medium Access Control (MAC) (e.g., random access and scheduled access) Ev
Ethernet and WiFi A
Switching (e.g., spanning trees, VLANS). E
Local Area Network Topologies (e.g., data center, campus networks). E
Illustrative Learning Outcomes 6
KA Core 6
Describe some basic aspects of modulation, bandwidth, and communication media.
Describe in detail a MAC protocol.
Demonstrate understanding of encoding and framing solution tradeoffs.
Describe details of the implementation of Ethernet.
Describe how switching works.
Describe one kind of a LAN topology.
NC-Security: Network Security 2.25+0.5(SEC)+0.25(SEP)h KA
KA Core 3
General intro about security (Threats, vulnerabilities, and countermeasures) (See also: SEP- Security, SEC-Foundations, SEC-Engineering) E
Network specific threats and attack types (e.g., denial of service, spoofing, sniffing and traffic redirection, attacker-in-the-middle, message integrity attacks, routing attacks, ransomware, and traffic analysis) E
Countermeasures (: SEC-Foundations, SEC-Crypto, SEC-Engineering)
Cryptography (e.g. SSL, TLS, symmetric/asymmetric)
Architectures for secure networks (e.g., secure channels, secure routing protocols, secure DNS, VPNs, DMZ, Zero Trust Network Access, hyper network security, anonymous communication protocols, isolation)
Network monitoring, intrusion detection, firewalls, spoofing and DoS protection, honeypots tracebacks, BGP Sec, RPKI
Illustrative Learning Outcomes 3
KA Core 3
Describe some of the threat models of network security.
Describe specific network-based countermeasures.
Analyze various aspects of network security from a case study.
NC-Mobility: Mobility 4h KA
KA Core 4
Principles of cellular communication (e.g., 4G, 5G) E
Principles of Wireless LANs (mainly 802.11) E
Device to device communication (e.g., IoT communication) E
Multi-hop wireless networks (e.g., ad hoc networks, opportunistic, delay tolerant) E
Illustrative Learning Outcomes 4
KA Core 4
Describe some aspects of cellular communication such as registration
Describe how 802.11 supports mobile users
Describe practical uses of device-to-device communication, as well as multihop
Describe one type of mobile network such as ad hoc
NC-Emerging: Emerging Topics 4h KA
KA Core 4
Middleboxes (e.g., advances in usage of AI, intent-based networking, filtering, deep packet inspection, load balancing, NAT, CDN) E
Network Virtualization (e.g., SDN, Data Center Networks) E
Quantum Networking (e.g., Intro to the domain, teleportation, security, Quantum Internet) E
Satellite, mmWave, Visible Light
Illustrative Learning Outcomes 10
CS Core 7
Operating systems mediate between general purpose hardware and application-specific software.
Universal operating system functions (e.g., process, user and device interfaces, persistence of data)
Extended and/or specialized operating system functions (e.g., embedded systems, server types such as file, web, multimedia, boot loaders and boot security)
Design issues (e.g., efficiency, robustness, flexibility, portability, security, compatibility, power safety, tradeoffs between error checking and performance, flexibility and performance, and security and performance)
Influences of security, networking, multimedia, parallel and distributed computing
Overarching concern of security/protection: Neglecting to consider security at every layer creates an opportunity to inappropriately access resources. Example concepts:
Unauthorized access to files on an unencrypted drive can be achieved by moving the media to another computer.
Operating systems enforced security can be defeated by infiltrating the boot layer before the operating system is loaded.
Process isolation can be subverted by inadequate authorization checking at API boundaries.
Vulnerabilities in system firmware can provide attack vectors that bypass the operating system entirely.
Improper isolation of virtual machine memory, computing, and hardware can expose the host system to attacks from guest systems.
The operating system may need to mitigate exploitation of hardware and firmware vulnerabilities, leading to potential performance reductions (e.g., Spectre and Meltdown mitigations).
Exposure of operating systems functions in shells and systems programming. (See also: FPL- Scripting)
KA Core 3
Describe the value of advances in middleboxes in networks.
Describe the importance of Software Defined Networks.
Describe some of the added value achieved by using Quantum Networking. networking protocols. and to respond to failures and threats. avoiding reactive modes of operation only. a networked environment, and the demands of regulatory bodies. changing user requirements. ● NC-Fundamentals (8 hours) ● NC-Applications (12 hours) ● NC-Reliability (6 hours) ● NC-Routing (4 hours) ● NC-SingleHop (3 hours) ● NC-Mobility (3 hours) ● NC-Security (3 hours) ● SEP-Context (1 hour) ● NC-Emerging (2 hours) ● NC-F
Professional Dispositions 6
Meticulous: Students must be particular about the specifics of understanding and creating networking protocols.
Collaborative: Students must work together to develop multiple components that interact together and to respond to failures and threats.
Proactive: Students must be able to predict failures, threats, and how to deal with them while avoiding reactive modes of operation only.
Professional: Students must comply with the needs of the community and their expectations from a networked environment, and the demands of regulatory bodies. 201
Responsive: Students must act swiftly to changes in requirements in network configurations and changing user requirements.
Adaptive: Students need to reconfigure systems under varying modes of operation.
Mathematics Requirements 4
Required 4
MSF-Probability.
MSF-Statistics.
MSF-Discrete.
MSF-Linear Simple queuing theory concepts.
SEC – Security 6 CS 35 KA 7 units
SEC-Foundations: Foundational Security 1+7(shared)h CS 7h KA
CS Core 7
Developing 3a security mindset incorporating crosscutting concepts: confidentiality, integrity availability, Srisk assessment, systems thinking, adversarial thinking, human-centered thinking D
Basic concepts E of authentication and authorization/access control C D
Vulnerabilities, threats, attack surfaces, and attack vectors . D
Denial of Service ( (DoS) and Distributed Denial of Service (DDoS) D
Principles and O practices of protection, e.g., least privilege, open design, fail-safe defaults, defense in depth, and t zero trust; and how they can be implemented (See also: OS-Principles, OS- h Protection, SE-Construction, SEP-Security) e r k 257 n o w l D
Optimization considerations between security, privacy, performance, and other design goals (See also: SDF-Practices, SE-Validation, HCI-Design) D
Impact of AI on security and privacy: using AI to bolster defenses as well as address increased adversarial capabilities due to AI D
KA Core 9
Access control models (e.g., discretionary, mandatory, role-based, and attribute-based) D
Security controls D
Concepts of trust and trustworthiness D
Applications of a security mindset: web, cloud, and mobile devices (See also: SF-System Design SPD-Common) D
Protecting embedded and cyber-physical systems D
Principles of usable security and human-centered computing D
Security and trust in AI/machine learning systems, e.g., fit for purpose, ethical operating boundaries, authoritative knowledge sources, verified training data, repeatable system evaluation tests, system attestation, independent validation/certification; unintended consequences from: adverse effect D
Security risks in building and operating AI/machine learning systems (e.g., algorithm bias knowledge corpus bias, training corpus bias, copyright violation) (See also: AI-Introduction, AI-ML AI-SEP) D
Hardware considerations in security, e.g., principles of secure hardware, secure processor architectures, cryptographic acceleration, compartmentalization, software-hardware interaction (See also: AR-Assembly, AR-Representation, OS-Purpose) D
Illustrative Learning Outcomes 8
CS Core 2
Evaluate a system for possible attacks that can be launched by an adversary.
Design and develop approaches to protect a system from a set of identified threats.
KA Core 6
Describe how harm to user privacy can be avoided.
Develop a system that incorporates various principles of security and privacy.
Compare the different access control models in terms of functionality and performance.
Show how an adversary could use machine learning algorithms to reduce the security of a system.
Show how a developer could improve the security of a system using machine learning algorithms.
Describe hardware (especially CPU) vulnerabilities that can impact software.
SEC-Coding: Secure Coding 2+6(shared)h CS 5h KA
CS Core 7
Common vulnerabilities and weaknesses D
SQL injection and other injection attacks D
Cross-site scripting techniques and mitigations D
Input validation and data sanitization D
Type safety and type-safe languages (See also: FPL-Types, FPL-Systems, OS-Protection, SDF- Fundamentals, SE-Validation) D
Buffer overflows, stack smashing, and integer overflows (See also: AR-Assembly, FPL-Systems OS-Protection) D
Security issues due to race conditions D
KA Core 10
Principles of noninterference and nondeducibility D
Preventing information flow attacks D
Offensive security techniques as a defense D
AI-assisted malware detection techniques D
Ransomware: creation, prevention, and mitigation D
Secure use of third-party components D
Malware: varieties, creation, reverse engineering, and defense against them (See also: FPL- Systems, FPL-Translation) D
Assurance: testing (including fuzzing and penetration testing), verification, and validation (See also: OS-Protection, SDF-Fundamentals, SE-Construction, SE-Validation) D
Static and dynamic analyses (See also: FPL-Analysis, MSF-Protection, PDC-Evaluation, SE- Validation) D
Secure compilers and secure code generation D
Illustrative Learning Outcomes 16
CS Core 8
Identify underlying problems in given examples of an enumeration of common weaknesses and explain how they can be circumvented.
Apply input validation and data sanitization techniques to enhance security of a program.
Describe how the selection of a programming language can impact the security of the system being constructed.
Rewrite a program in a type-safe language (e.g., Java or Rust) originally written in an unsafe programming language (e.g., C/C++).
Evaluate a program for possible buffer overflow attacks and rewrite to prevent such attacks.
Evaluate a set of related programs for possible race conditions and prevent an adversary from exploiting them.
Evaluate and prevent SQL injections attacks on a database application.
Evaluate and prevent cross-site scripting attacks against a website.
KA Core 8
Describe different kinds of malicious software.
Construct a program that tests for all input handling errors.
Explain the risks of misusing interfaces with third-party code and how to correctly use third-party code.
Discuss the need to update software to fix security vulnerabilities and the lifecycle management of the fix.
Construct a system that is protected from unauthorized information flows.
Apply static and dynamic tools to identify programming faults.
Evaluate a system for the existence of malware and remove it.
Implement preventive techniques to reduce the occurrence of ransomware.
SEC-Crypto: Cryptography 1+8(MSF)h CS 4h KA
CS Core 7
Differences between algorithmic, applied, and mathematical views of cryptography Ev
Mathematical preliminaries: modular arithmetic, Euclidean algorithm, probabilistic independence linear algebra basics, number theory, finite fields, complexity, asymptotic analysis (See also: MSF- Discrete, MSF-Linear) Ev
Basic cryptography: symmetric key and public key cryptography (See also: AL-Foundational, MSF- Discrete) Ev
Basic cryptographic building blocks, including symmetric encryption, asymmetric encryption hashing, and message authentication Ev
Classical cryptosystems, such as shift, substitution, transposition ciphers, code books, and machines Ev
Kerckhoff’s principle and use of vetted libraries Ev
Usage of cryptography in real-world applications, e.g., electronic cash, secure channels between clients and servers, secure electronic mail, entity authentication, device pairing, steganography, and voting systems Ev
KA Core 8
Additional mathematics: primality, factoring, and elliptic curve cryptography (See also: MSF- Discrete) D
Private-key cryptosystems: substitution-permutation networks, linear cryptanalysis, differential cryptanalysis, DES, and AES D
Public-key cryptosystems: Diffie-Hellman and RSA D
Data integrity and authentication: hashing, and digital signatures (See also: MSF-Discrete, DM- Security) D
Cryptographic protocols: challenge-response authentication, zero-knowledge protocols commitment, oblivious transfer, secure two- or multi-party computation, hash functions, secret sharing, and applications D
Attacker capabilities: chosen-message attack (for signatures), birthday attacks, side channel attacks, and fault injection attacks D
Quantum cryptography; Post Quantum/Quantum resistant cryptography (See also: AL- Foundational, MSF-Discrete) D
Blockchain and cryptocurrencies D
Illustrative Learning Outcomes 12
CS Core 4
Explain the role of cryptography in supporting security and privacy.
Discuss the risks of inventing one’s own cryptographic methods.
Discuss the importance of prime numbers in cryptography and explain their use in cryptographic algorithms.
Implement and cryptanalyze classical ciphers.
KA Core 8
Describe how crypto keys can be managed securely.
Compare the space and time performance of a given set of cryptographic methods.
Discuss how modern private-key cryptosystems work and ways to cryptanalyze them.
Discuss how modern public-key cryptosystems work and ways to cryptanalyze them.
Compare different cryptographic algorithms in terms of security.
Explain key exchange protocols and show approaches to reduce their failure.
Describe real-world applications of cryptographic primitives and protocols.
Discuss how quantum cryptography works and the impact of quantum computing on cryptographic algorithms.
SEC-Engineering: Security Analysis, Design, and Engineering 1+4(shared)h CS 8h KA
CS Core 4
Security engineering goals: building systems that remain dependable despite errors, accidents, or malicious adversaries D
Privacy engineering goals: building systems that design, implement, and deploy privacy features and controls D
Problem analysis and situational analysis to address system security D
Engineering tradeoff analysis based on time, cost, risk tolerance, risk acceptance, return on investment, and so on D
KA Core 7
Security design and engineering, including functional requirements, security subsystems information protection, security testing, security assessment, and evaluation (See also: PDC- Evaluation, SE-Requirements, SE-Validation) D
Security analysis, covering security requirements analysis; security controls analysis; threat analysis; and vulnerability analysis D
Security attack domains and attack surfaces, e.g., communications and networking, hardware physical, social engineering, software, and supply chain D
Security attack modes, techniques, and tactics, e.g., authentication abuse; brute force; buffer manipulation; code injection; content insertion; denial of service; eavesdropping; function bypass impersonation; integrity attack; interception; phishing; protocol analysis; privilege abuse; spoofing and traffic injection D
Attestation of software products with respect to their specification and adaptiveness (See also: SE- Requirements, SE-Validation) D
Design and development of cyber-physical systems D
Considerations for trustworthy computing, e.g., tamper resistant packaging, trusted boot, trusted kernel, hardware root of trust, software signing and verification, hardware-based cryptography virtualization, and containers D
Illustrative Learning Outcomes 7
CS Core 3
Create a threat model for a system or system design.
Apply situational analysis to develop secure solutions under a specified scenario.
Evaluate a given scenario for tradeoff analysis for system performance, risk assessment, and costs.
KA Core 4
Design a set of technical security controls, countermeasures, and information protections to meet the security requirements and security objectives for a system.
Evaluate the effectiveness of security functions, technical controls, and componentry for a system.
Identify and mitigate security vulnerabilities and weaknesses in a system.
Evaluate and predict emergent behavior in areas such as Data Science, AI, and Machine Learning.
SEC-Forensics: Digital Forensics 6h KA
KA Core 7
Basic principles and methodologies for digital forensics D
System design for forensics D
Forensics in different situations: operating systems, file systems, application forensics, web forensics, network forensics, mobile device forensics, use of database auditing (See also: NC- Security) D
Attacks on forensics and preventing such attacks D
Incident handling processes D
Rules of evidence – general concepts and differences between jurisdictions (See also: SEP- Security) D
Legal issues: digital evidence protection and management, chains of custody, reporting, serving as an expert witness D
Illustrative Learning Outcomes 12
KA Core 12
Explain what a digital investigation is and how it can be implemented
Design and implement software to support forensics.
Describe legal requirements for using seized data and its usage.
Describe and implement an end-to-end chain of custody from initial digital evidence seizure to evidence disposal.
Extract data from a hard drive to comply with the law
Discuss a person’s professional responsibilities and liabilities when testifying as a forensics expert
Recover data based on a given search term from an imaged system
Reconstruct data and events from an application history, or a web artifact, or a cloud database, or a mobile device.
Capture and analyze network traffic.
Develop approaches to address the challenges associated with mobile device forensics.
Apply forensics tools to investigate security breaches.
Identify and mitigate anti-forensic methods.
SEC-Governance: Security Governance 3h KA
KA Core 6
Protecting critical assets from threats
Security governance: organizational objectives and general risk assessment E
Security management: achieve and maintain appropriate levels of confidentiality, integrity availability, accountability, authenticity, and reliability E
Security policy: organizational policies, issue-specific policies, system-specific policies E
Approaches to identifying and mitigating risks to computing infrastructure E
Data lifecycle management policies: data collection, backups, and retention; cloud storage and services; breach disclosure E
Illustrative Learning Outcomes 8
KA Core 8
Describe critical assets and how they can be protected.
Differentiate between security governance, management, and controls, giving examples of each.
Describe a technical control and implement it to mitigate specific threats.
Identify and assess risk of programs and database applications causing breaches.
Design and implement appropriate backup strategies conforming to a given policy.
Discuss a breach disclosure policy based on legal requirements and implement the policy.
Identify the risks and benefits of outsourcing to the cloud. software systems. in which adversaries might launch attacks. will be needed to prevent attacks, protect systems and data during attacks, and plan for the future after the immediate attack has been mitigated. maintaining secure systems, as their enterprise and society is constantly at risk. system or data breach were to occur, which should strengthen their resolve to prevent such breaches from occurring in the first place. ● Vijay Anand
Joint Task Force on Cybersecurity Education. 2017. Cybersecurity Curricula 2017. ACM, IEEE-CS AIS SIGSEC, and IFIP WG 11.8. https://doi.org/10.1145/3184594 Society, Ethics, and the Profession (SEP) Undergraduates also need to understand the basic cultural, social, legal, and ethical issues inherent in the discipline of computing. They should understand where the discipline has been where it is, and where it is heading. They should also understand their individual roles in this process, as well a
Future practitioners must understand the responsibility that they will bear, and the possible consequences of failure. They must understand their own limitations as well as the limitations of their tools. All practitioners must make a long-term commitment to remaining current in their chosen specialties and in the discipline of computing as a whole.
SEC-SEP: Society, Ethics, and the Profession 1+4(SEP)h CS 2h KA
CS Core 8
Principles and practices of privacy D
Societal impacts on breakdowns in security and privacy (See also: SEP-Context, SEP-Privacy SEP-Security) D
Applicability of laws and regulations on security and privacy D
Professional ethical considerations when designing secure systems and maintaining privacy; ethical hacking D
Security by design D
Privacy by design and privacy engineering D
Security and privacy implications of malicious AI/machine learning actors, e.g., identifying deep fakes D
Societal impacts of Internet of Things (IoT) devices and other emerging technologies on security and privacy D
Illustrative Learning Outcomes 5
CS Core 3
Calculate the impact of a breakdown in security of a given system.
Construct a system that conforms to security laws.
Apply a set of privacy regulations to design a system that protects privacy.
KA Core 2
Evaluate the legal ramifications of a system not corresponding to applicable laws and regulations.
Construct a system that is designed to avoid harm to user privacy.
Professional Dispositions 5
Meticulous: students need to pay careful attention to details to ensure the protection of real-world software systems. 263
Self-directed: students must be ready to deal with the many novel and easily unforeseeable ways in which adversaries might launch attacks.
Collaborative: students must be ready to collaborate with others, as collective knowledge and skills will be needed to prevent attacks, protect systems and data during attacks, and plan for the future after the immediate attack has been mitigated.
Responsible: students need to show responsibility when designing, developing, deploying, and maintaining secure systems, as their enterprise and society is constantly at risk.
Accountable: students need to know that as future professionals they will be held accountable if a system or data breach were to occur, which should strengthen their resolve to prevent such breaches from occurring in the first place.
Mathematics Requirements 4
Required 3
MSF-Discrete
MSF-Probability
MSF-Statistics
Desired 1
MSF-Linear
DM – Data Management 10 CS 26 KA 13 units
DM-Data: The Role of Data and the Data Life Cycle 2h CS
CS Core 1
The Data Life Cycle: Creation-Processing-Review/Reporting-Retention/Retrieval-Destruction (See also: SEP-Context, SEP-Ethical-Analysis, SEP-Professional-Ethics, SEP-Privacy, SEP-Security SEC-Foundations) Ev
Illustrative Learning Outcomes 1
CS Core 1
Identify the five stages of the Data Life Cycle.
DM-Core: Core Database System Concepts 2h CS 1h KA
CS Core 11
Purpose and advantages of database systems D
Components of database systems D
Design of core DBMS functions (e.g., query mechanisms, transaction management, buffer management, access methods) D
Database architecture, data independence, and data abstraction D
Transaction management D
Normalization D
Approaches for managing large volumes of data (e.g., NoSQL database systems, use of MapReduce) D
How to support CRUD-only applications D
Distributed databases/cloud-based systems D
Structured, semi-structured, and unstructured data D
Use of a declarative query language E
KA Core 1
Systems supporting structured and/or stream content D
Illustrative Learning Outcomes 9
CS Core 9
Identify at least four advantages that using a database system provides.
Enumerate the components of a (relational) database system.
Follow a query as it is processed by the components of a (relational) database system.
Defend the value of data independence.
Compose a simple select-project-join query in SQL.
Enumerate the four properties of a correct transaction manager.
Describe the advantages for eliminating duplicate repeated data.
Outline how MapReduce uses parallelism to process data efficiently.
Evaluate the differences between structured and semi/unstructured databases.
DM-Modeling: Data Modeling 2h CS 3h KA
CS Core 2
Data modeling
Relational data model E
KA Core 2
Conceptual models (e.g., entity-relationship, UML diagrams) E
Semi-structured data models (expressed using DTD, XML, or JSON Schema, for example) E
Non-core 4
Spreadsheet models
Object-oriented models
GraphQL
New features in SQL
Specialized Data Modeling topics
Time series data (aggregation, join)
Graph data (link traversal)
Techniques for avoiding inefficient raw data access (e.g., “avg daily price”): materialized views and special data structures (e.g., Hyperloglog, bitmap)
Geo-Spatial data (e.g., GIS databases)
Illustrative Learning Outcomes 5
CS Core 2
Describe the components of the relational data model.
Model 1:1, 1:n, and n:m relationships using the relational data model.
KA Core 3
Describe the components of the E-R (or some other non-relational) data model.
Model a given environment using a conceptual data model.
Model a given environment using the document-based or key-value store-based data model.
DM-Relational: Relational Databases 1h CS 3h KA
CS Core 2
Entity and referential integrity: Candidate key, superkeys
Relational database design D
KA Core 4
Mapping conceptual schema to a relational schema D
Physical database design: file and storage structures D
Introduction to Functional dependency theory D
Normalization Theory D
Decomposition of a schema; lossless-join, and dependency-preservation properties of a decomposition
Normal forms (BCNF)
Denormalization (for efficiency)
Non-core 2
Functional dependency theory D
Closure of a set of attributes
Canonical Cover
Normalization theory D
Multi-valued dependency (4NF)
Join dependency (PJNF, 5NF)
Representation theory
Illustrative Learning Outcomes 9
CS Core 3
Describe the defining characteristics behind the relational data model.
Comment on the difference between a foreign key and a superkey.
Enumerate the different types of integrity constraints.
KA Core 6
Compose a relational schema from a conceptual schema which contains 1:1, 1:n, and n:m relationships.
Map appropriate file structure to relations and indices.
Describe how functional dependency theory generalizes the notion of key.
Defend a given decomposition as lossless and or dependency preserving.
Detect which normal form a given decomposition yields.
Comment on reasons for denormalizing a relation.
DM-Querying: Query Construction 2h CS 4h KA
CS Core 1
SQL Query Formation
Interactive SQL execution
Programmatic execution of an SQL query
KA Core 2
Relational Algebra D
SQL
Data definition including integrity and other constraint specifications
Update sublanguage
Non-core 5
Relational Calculus D
QBE and 4th-generation environments
Different ways to invoke non-procedural queries in conventional languages
Introduction to other major query languages (e.g., XPATH, SPARQL)
Stored procedures
Illustrative Learning Outcomes 5
CS Core 3
Compose SQL queries that incorporate select, project, join, union, intersection, set difference, and set division.
Determine when a nested SQL query is correlated or not.
Iterate over data retrieved programmatically from a database via an SQL query.
KA Core 2
Define, in SQL, a relation schema, including all integrity constraints and delete/update triggers.
Compose an SQL query to update a tuple in a relation.
DM-Processing: Query Processing 4h KA
KA Core 8
Page structures D
Index structures D
B+ trees
Hash indices: static and dynamic
Index creation in SQL
File structures D
Heap files
Hash files
Algorithms for query operators D
External Sorting
Selection
Projection; with and without duplicate elimination
Natural Joins: Nested loop, Sort-merge, Hash join
Analysis of algorithm efficiency
Query transformations D
Query optimization D
Access paths
Query plan construction
Selectivity estimation
Index-only plans
Parallel Query Processing (e.g., parallel scan, parallel join, parallel aggregation) (See also: PDC- Algorithms) D
Database tuning/performance D
Index selection
Impact of indices on query performance
Denormalization
Illustrative Learning Outcomes 9
KA Core 9
Describe the purpose and organization of both B+ tree and hash index structures.
Compose an SQL command to create an index (any kind).
Specify the steps for the various query operator algorithms: external sorting, projection with duplicate elimination, sort-merge join, hash-join, block nested-loop join.
Derive the run-time (in I/O requests) for each of the above algorithms.
Transform a query in relational algebra to its equivalent appropriate for a left-deep, pipelined execution.
Compute selectivity estimates for a given selection and/or join operation.
Describe how to modify an index structure to facilitate an index-only operation for a given relation.
For a given scenario decide on which indices to support for the efficient execution of a set of queries.
Describe how DBMSs leverage parallelism to speed up query processing by dividing the work across multiple processors or nodes.
DM-Internals: DBMS Internals 4h KA
KA Core 4
DB Buffer Management
Transaction Management
Isolation Levels
ACID
Serializability
Distributed Transactions
Concurrency Control:
2-Phase Locking
Deadlocks handling strategies
Quorum-based consistency models
Recovery Manager
Relation with Buffer Manager
Non-core 2
Concurrency Control:
Optimistic concurrency control
Timestamp concurrency control
Recovery Manager
Write-Ahead logging
ARIES recovery system (Analysis, REDO, UNDO)
Illustrative Learning Outcomes 3
KA Core 3
Describe how a DBMS manages its Buffer Pool.
Describe the four properties for a correct transaction manager.
Outline the principle of serializability.
DM-NoSQL: NoSQL Systems 2h KA
KA Core 2
Why NoSQL? (e.g., Impedance mismatch between Application [CRUD] and RDBMS) E
Key-Value and Document data model E
Non-core 6
Storage systems (e.g., Key-Value systems, Data Lakes) E
Distribution Models (Sharding and Replication)
Graph Databases
Consistency Models (Update and Read, Quorum consistency, CAP theorem) (See also: PDC- Communication)
Processing model (e.g., Map-Reduce, multi-stage map-reduce, incremental map-reduce) (See also: PDC-Communication)
Case Studies: Cloud storage system (e.g., S3); Graph databases; “When not to use NoSQL” (See also: SPD-Web)
Illustrative Learning Outcomes 2
KA Core 2
Develop a use case for the use of NoSQL over RDBMS.
Describe the defining characteristics behind Key-Value and Document-based data models.
DM-Security: Data Security and Privacy 1h CS 2h KA
CS Core 4
Differences between data security and data privacy E
Protecting data and database systems from attacks, including injection attacks such as SQL injection E
Personally identifying information (PII) and its protection (See also: SEC-Foundations, SEP- Security, SEP-Privacy) E
Ethical considerations in ensuring the security and privacy of data (See also: SEC-SEP, SEP- Ethical-Analysis, SEP-Security, SEP-Privacy) E
KA Core 4
Need for, and different approaches to securing data at rest, in transit, and during processing (See also: SEC-Foundations, SEC-Crypto) E
Database auditing and its role in digital forensics E
Data inferencing and preventing attacks E
Laws and regulations governing data security and data privacy (See also: SEP-Security, SEP- Privacy, SEC-Foundations, SEC-Governance) E
Non-core 2
Typical risk factors and prevention measures for ensuring data integrity (See also: SEC- Governance) E
Ransomware and prevention of data loss and destruction E
Illustrative Learning Outcomes 5
CS Core 3
Describe the differences in the goals for data security and data privacy.
Identify and mitigate risks associated with different approaches to protecting data.
Describe legal and ethical considerations of end-to-end data security and privacy.
KA Core 2
Develop a database auditing system given risk considerations.
Apply several data exploration approaches to understanding unfamiliar datasets.
DM-Analytics: Data Analytics 3h KA
KA Core 8
Exploratory data techniques (motivation, representation, descriptive statistics, visualizations)
Data science lifecycle: business understanding, data understanding, data preparation, modeling evaluation, deployment, and user acceptance
Data mining and machine learning algorithms: e.g., classification, clustering, association, regression
Data acquisition and governance
Data security and privacy considerations
Data fairness and bias
Data visualization techniques and their use in data analytics
Entity Resolution
Illustrative Learning Outcomes 6
KA Core 6
Describe several data exploration approaches, including visualization, to understanding unfamiliar datasets.
Apply several data exploration approaches to understanding unfamiliar datasets.
Describe basic machine learning/data mining algorithms and when they are appropriate for use.
Apply several machine learning/data mining algorithms.
Describe legal and ethical considerations in acquiring, using, and modifying datasets.
Describe issues of fairness and bias in data collection and usage.
DM-Distributed: Distributed Databases/Cloud Computing
Non-core 2
Distributed DBMS
Distributed data storage
Distributed query processing
Distributed transaction model
Homogeneous and heterogeneous solutions
Client-server distributed databases
Parallel DBMS
Parallel DBMS architectures: shared memory, shared disk, shared nothing
Speedup and scale-up, e.g., use of the MapReduce processing model (See also: PDC- Programs, SF-Foundations)
Data replication and weak consistency models
DM-Unstructured: Semi-structured and Unstructured Databases
Non-core 2
Vectorized unstructured data (text, video, audio, etc.) and vector storage
TF-IDF Vectorizer with ngram
Word2Vec
Array database or array data type handling
Semi-structured databases (e.g., JSON)
Storage
Encoding and compression of nested data types
Indexing
Btree, skip index, Bloom filter
Inverted index and bitmap compression
Space filling curve indexing for semi-structured geo-data
Query processing for OLTP and OLAP use cases
Insert, Select, update/delete tradeoffs
Case studies on Postgres/JSON, MongoDB, and Snowflake/JSON
DM-SEP: Society, Ethics, and the Profession in SEP
CS Core 5
Issues related to scale E
Data privacy overall E
Privacy compliance by design
Data anonymity E
Data ownership/custodianship E
Intended and unintended applications of stored data (See also: SEP-Professional-Ethics, SEC- Foundations) E
KA Core 3
Reliability of data E
Provenance, data lineage, and metadata management E
Data security E
Illustrative Learning Outcomes 7
CS Core 4
Enumerate three social and three legal issues related to large data collections.
Describe the value of data privacy.
Identify the competing stakeholders with respect to data ownership.
Enumerate three negative unintended consequences from a given (well known) data-centric application (e.g., Facebook, LastPass, Ashley Madison).
KA Core 3
Describe the meaning of data provenance and lineage.
Identify how a database might contribute to data security as well as how it may introduce insecurities. ● Meticulous: Those who either access or store data collections must be meticulous in fulfilling data ownership responsibilities. ● Responsible: In conjunction with the professional management of (personal) data, it is equally important that data are managed responsibly. Protection from unauthorized access as well as prevention of irresponsible, though legal, use of data is paramount. Furtherm
The 2022 Undergraduate Database Course in Computer Science: What to Teach?. Michael Goldweber, Min Wei, Sherif Aly, Rajendra K. Raj, and Mohamed Mokbel. ACM Inroads, 13, 3, 2022. Foundations of Programming Languages (FPL) ● Object-Oriented Programming -4 CS Core hours ● Functional Programming -2 CS Core hours ● Event-Driven and Reactive Programming +1 CS Core hour ● Parallel and Distributed Computing +3 CS Core hours ● Type Systems -1 CS Core hour ● Program Representation -1 CS Core hour ● Stati
To support this, additional coverage of topics related to formal methods has been included, but all these topics are identified as Non-core. ● When introducing these topics, it is also important that an instructor provides context for this material including why we have an interest in programming languages and what they do for us in terms of providing a human readable version of instructions for a computer to execute. Knowledge Unit CS Core KA Core Object-Oriented Programming 4 + 1 (SDF) 1 Funct
Professional Dispositions 4
Meticulous: Those who either access or store data collections must be meticulous in fulfilling data ownership responsibilities.
Responsible: In conjunction with the professional management of (personal) data, it is equally important that data are managed responsibly. Protection from unauthorized access as well as prevention of irresponsible, though legal, use of data is paramount. Furthermore, data custodians need to protect data not only from outside attack, but from crashes and other foreseeable dangers. 123
Collaborative: Data managers and data users must behave in a collaborative fashion to ensure that the correct data are accessed and are used only in an appropriate manner.
Responsive: The data that get stored and are accessed are always in response to an institutional need/request.
Mathematics Requirements 5
Required 1
Discrete Mathematics: Set theory (union, intersection, difference, cross-product) (See also: MSF-Discrete)
Desired 1
Probability and Statistics for those studying DM-Analytics. (See also: MSF-Probability, MSF- Statistics)
Desirable Data Structures 3
Hash functions and tables
Balanced (binary) trees (e.g., AVL, 2-3-4, Red-Black)
B and B+-trees
Applications 4 KAs

Problem- or solution-specific knowledge.

GIT – Graphics and Interactive Techniques 4 CS 70 KA 12 units
GIT-Fundamentals: Fundamental Concepts 4h CS 3h KA
CS Core 9
Uses of computer graphics and interactive techniques and their potential risks and abuses. D
Entertainment, business, and scientific applications: e.g., visual effects, generative imagery computer vision, machine learning, user interfaces, video editing, games and game engines computer-aided design and manufacturing, data visualization, and virtual/augmented/mixed reality
Intellectual property, deep fakes, facial recognition, privacy (See also: SEP-DEIA, SEP-Privacy SEP-IP, SEP-Professional-Ethics)
Graphic output D
Displays (e.g., LCD)
Printers
Analog film
Concepts
Resolution (e.g., pixels, dots)
Aspect ratio
Frame rate
Human vision system D
Tristimulus reception (RGB)
Eye as a camera (projection)
Persistence of vision (frame rate, motion blur)
Contrast (detection, Mach banding, dithering/aliasing)
Non-linear response (dynamic range, tone mapping)
Binocular vision (stereo)
Accessibility (color deficiency, strobing, monocular vision, etc.)
Standard image formats D
Raster
Lossless (e.g., TIF)
Lossy (e.g., JPG, GIF, etc.)
Vector (e.g., SVG, Adobe Illustrator)
Digitization of analog data D
Rasterization
Resolution
Sampling and quantization
Color models: additive (RGB), subtractive (CMYK), and color perception (HSV) D
Tradeoffs between storing image data and re-computing image data D
Spatialization: coordinate systems, absolute and relative positioning D
Animation as a sequence of still images D
KA Core 2
Applied interactive graphics (e.g., processing, python) D
Display characteristics (protocols and ports) E
Illustrative Learning Outcomes 14
CS Core 12
Identify common uses of digital presentation to humans (e.g., computer graphics, sound).
Describe how analog signals can be reasonably represented by discrete samples, for example, how images can be represented by pixels.
Compute the memory requirement for storing a color image given its resolution.
Create a graphic depicting how the limits of human perception affect choices about the digital representation of analog signals.
Indicate when and why you should use each of the following common file formats: JPG, PNG, MP3 MP4, and GIF.
Describe color models and their use in graphics display devices.
Compute the memory requirements for a multi-second movie (lasting n seconds) displaying at a specific framerate (f frames per second) at a specified resolution (r pixels per frame)
Compare and contrast digital video to analog video.
Describe the basic process of producing continuous motion from a sequence of discrete frames (sometimes called “flicker fusion”).
Describe a possible visual misrepresentation that could result from digitally sampling an analog world.
Compute memory space requirements based on resolution and color coding.
Compute time requirements based on refresh rates and rasterization techniques.
KA Core 2
Design a user interface and an alternative for persons with color perception deficiency.
Construct a simple graphical user interface using a graphics library.
GIT-Visualization: Visualization 6h KA
KA Core 7
Scientific Data Visualization and Information Visualization E
Visualization techniques E
Statistical visualization (e.g., scatterplots, bar graphs, histograms, line graphs, pie charts, trees and graphs)
Text visualization
Geospatial visualization
2D/3D scalar fields
Vector fields
Direct volume rendering
Visualization pipeline E
Structuring data
Mapping data to visual representations (e.g., scales, grammar of graphics)
View transformations (e.g., pan, zoom, filter, select)
Common data formats (e.g., HDF, netCDF, geotiff, GeoJSON, shape files, raw binary, JSON, CSV plain text) E
High-dimensional data handling techniques
Statistical (e.g., averaging, clustering, filtering)
Perceptual (e.g., multi-dimensional vis, parallel coordinates, trellis plots)
Perceptual and cognitive foundations that drive visual abstractions. E
Human optical system
Color theory
Gestalt theories
Design and evaluation of visualizations E
Purpose (e.g., analysis, communication, aesthetics)
Accessibility
Appropriateness of encodings
Misleading visualizations
Illustrative Learning Outcomes 7
KA Core 7
Compare and contrast data visualization and information visualization.
Deploy basic algorithms for visualization.
Compare the tradeoffs of visualization algorithms in terms of accuracy and performance.
Design a suitable visualization for a particular combination of data characteristics, application tasks and audience.
Analyze the effectiveness of a given visualization for a particular task.
Design a process to evaluate the utility of a visualization algorithm or system.
Identify a variety of applications of visualization including representations of scientific, medical, and mathematical data; flow visualization; and spatial analysis.
GIT-Rendering: Applied Rendering and Techniques 15h KA
KA Core 4
Object and scene modeling E
Object representations: polygonal, parametric, etc.
Modeling transformations: affine and coordinate-system transformations
Scene representations: scene graphs
Camera and projection modeling E
Pinhole cameras, similar triangles, and projection model
Camera models
Projective geometry
Radiometry and light models E
Radiometry
Rendering equation
Rendering in nature – emission and scattering, etc.
Rendering E
Simple triangle rasterization
Rendering with a shader-based API
Visibility and occlusion, including solutions to this problem (e.g., depth buffering, Painter’s algorithm, and ray tracing)
Texture mapping, including minification and magnification (e.g., trilinear MIP mapping)
Application of spatial data structures to rendering.
Ray tracing
Sampling and anti-aliasing
Illustrative Learning Outcomes 14
KA Core 14
Describe and illustrate the light transport problem (i.e., light is emitted, scatters around the scene and is measured by the eye).
Describe the basic rendering pipeline.
Compare and contrast how forward and backwards rendering factor into the graphics pipeline.
Create a program to display 2D shapes in a window.
Create a program to display 3D models.
Produce linear perspective from similar triangles by converting points (x, y, z) to points (x/z, y/z, 1).
Compute two-dimensional and 3-dimensional points by applying affine transformations.
Indicate the changes required to extend 2D transformation operations to handle transformations in 3D.
Define texture mapping, sampling, and anti-aliasing, and describe examples of each.
Compare ray tracing and rasterization for the visibility problem.
Construct a program that performs transformation and clipping operations on simple two- dimensional shapes.
Implement a simple real-time renderer using a rasterization API (e.g., OpenGL, webGL) using vertex buffers and shaders.
Compare and contrast the different rendering techniques.
Compare and contrast the difference in transforming the camera vs the models.
GIT-Shading: Shading and Advanced Rendering 6h KA
KA Core 13
Solutions and approximations to the rendering equation, for example E
Distribution ray tracing and path tracing
Photon mapping
Bidirectional path tracing
Metropolis light transport
Time (motion blur), lens position (focus), and continuous frequency (color) and their impact on rendering E
Shadow mapping E
Occlusion culling E
Bidirectional Scattering Distribution function (BSDF) theory and microfacets E
Subsurface scattering E
Area light sources E
Hierarchical depth buffering E
Image-based rendering E
Non-photorealistic rendering E
Realtime rendering E
GPU architecture E
Human visual systems including adaptation to light, sensitivity to noise, and flicker fusion (See also: HCI-Accessibility, SEP-DEIA) E
Illustrative Learning Outcomes 8
KA Core 8
Describe how an algorithm estimates a solution to the rendering equation.
Discuss the properties of a rendering algorithm (e.g., complete, consistent, and unbiased).
Analyze the bandwidth and computation demands of a simple shading algorithm.
Implement a non-trivial shading algorithm (e.g., toon shading, cascaded shadow maps) under a rasterization API.
State how a particular artistic technique might be implemented in a renderer.
Describe how one might recognize the shading techniques used to create a particular image.
Write a program that implements any of the specified graphics techniques using a primitive graphics system at the individual pixel level.
Write a ray tracer for scenes using a simple (e.g., Phong’s) Bidirectional Reflection Distribution Function (BRDF) plus reflection and refraction.
GIT-Modeling: Geometric Modeling 6h KA
KA Core 6
Basic geometric operations such as intersection calculation and proximity tests on 2D objects
Surface representation/model E
Tessellation
Mesh representation, mesh fairing, and mesh generation techniques such as Delaunay triangulation, and marching cubes/tetrahedrons
Parametric polynomial curves and surfaces
Implicit representation of curves and surfaces
Spatial subdivision techniques
Volumetric representation/model E
Volumes, voxels, and point-based representations.
Signed Distance Fields
Sparse Volumes, i.e., VDB
Constructive Solid Geometry (CSG) representation
Procedural representation/model E
Fractals
L-Systems
Multi-resolution modeling E
Reconstruction, e.g., 3D scanning, photogrammetry E
Illustrative Learning Outcomes 7
KA Core 7
Contrast representing curves and surfaces in both implicit and parametric forms.
Create simple polyhedral models by surface tessellation.
Create a mesh representation from an implicit surface.
Create a fractal model or terrain using a procedural method.
Create a mesh from data points acquired with a laser scanner.
Create CSG models from simple primitives, such as cubes and quadric surfaces.
Contrast modeling approaches with respect to space and time complexity and quality of image.
GIT-Animation: Computer Animation 6h KA
KA Core 6
Principles of Animation: Squash and Stretch, Timing, Anticipation, Staging, Follow Through and Overlapping Action, Straight Ahead Action, and Pose-to-Pose Action, Slow In and Out, Arcs Exaggeration, and Appeal E
Types of animation E
2- and 3-dimensional animation
Motion graphics
Motion capture
Motion graphics
Stop animation
Key-frame animation E
Keyframe Interpolation Methods: Lerp/Slerp/Spline
Forward and inverse kinematics E
Skinning algorithms E
Capturing
Linear blend, dual quaternion
Rigging
Blend shapes
Pose space deformation
Motion capture E
Set up and fundamentals
Blending motion capture clips
Blending motion capture and keyframe animation
Ethical considerations
Avoidance of “default” captures - there is no typical human walk cycle.
Accessibility
Illustrative Learning Outcomes 6
KA Core 6
Using a simple open-source character model and rig, describe visually why each of the principles of animation is fundamental to realistic animation.
Compute the location and orientation of model parts using a forward kinematic approach.
Compute the orientation of articulated parts of a model from a location and orientation using an inverse kinematic approach.
Compare the tradeoffs in different representations of rotations.
Write a script that implements the spline interpolation method for producing in-between positions and orientations.
Deploy off-the-shelf animation software to construct, rig, and animate simple organic forms.
GIT-Simulation: Simulation 6h KA
KA Core 6
Collision detection and response
Signed Distance Fields
Sphere/sphere
Triangle/point
Edge/edge
Procedural animation using noise E
Particle systems E
Integration methods (e.g., forward Euler, midpoint, leapfrog)
Mass/spring networks
Position-based dynamics
Rules (e.g., boids, crowds)
Rigid bodies
Grid-based fluids E
Semi-Lagrangian advection
Pressure projection
Heightfields E
Terrain: transport, erosion
Water: ripple, shallow water.
Rule-based systems (e.g., L-systems, space-colonizing systems, Game of Life) E
Illustrative Learning Outcomes 3
KA Core 3
Implement algorithms for physical modeling of particle dynamics using simple Newtonian mechanics (e.g., Witkin & Kass, snakes and worms, symplectic Euler, Stormer/Verlet, or midpoint Euler methods)
Contrast the basic ideas behind fluid simulation methods for modeling ballistic trajectories (e.g., for splashes, dust, fire, or smoke).
Implement a smoke solver with user interaction.
GIT-Immersion: Immersion 6h KA
KA Core 11
Immersion levels (i.e., Virtual Reality (VR), Augmented Reality (AR), and Mixed Reality (MR))
Definitions of and distinctions between immersion and presence A
360 Video
Stereoscopic display A
Head-mounted displays
Stereo glasses
Viewer tracking A
Inside-out and outside-in
Head/Body/Hand/tracking
Time-critical rendering to achieve optimal Motion To Photon (MTP) latency A
Multiple Levels Of Details (LOD)
Image-based VR
Branching movies
Distributed VR, collaboration over computer network A
Presence and factors that impact level of immersion A
3D interaction
Applications in medicine, simulation, training, and visualization A
Safety in immersive applications A
Motion sickness
VR obscures the real world, which increases the potential for falls and physical accidents
Illustrative Learning Outcomes 8
KA Core 8
Create a stereoscopic image.
Design and write an AR or VR application.
Summarize the pros and cons of different types of viewer tracking.
Compare and contrast the differences between geometry- and image-based virtual reality.
Analyze the design issues of user action synchronization and data consistency in a networked environment.
Create the specifications for an augmented reality application to be used by surgeons in the operating room.
Assess an immersive application’s accessibility
Identify the most important technical characteristics of a VR system/application that should be controlled to avoid motion sickness and explain why.
GIT-Interaction: Interaction 6h KA
KA Core 3
Event Driven Programming
Mouse or touch events
Keyboard events
Voice input
Sensors
Message passing communication
Network events
Graphical User Interface (Single Channel)
Window
Icons
Menus
Pointing Devices
Accessibility
Non-core 5
Gestural Interfaces
Touch screen gestures
Hand and body gestures
Haptic Interfaces
External actuators
Gloves
Exoskeletons
Multimodal Interfaces
Head-worn Interfaces
Brain-computer interfaces, e.g., Electroencephalography (EEG) electrodes and Multi-Electrode Arrays (MEAs)
Headsets with embedded eye tracking
AR glasses
Natural Language Interfaces
Illustrative Learning Outcomes 6
KA Core 6
Create a simple game that responds to single channel mouse and keyboard events.
Create a mobile app that responds to touch events.
Design and create an application that responds to different event triggers.
Assess the consistency or lack of consistency in cross-platform touch screen gestures.
Design and create an application that provides haptic feedback.
Write a program that is controlled by gestures.
GIT-Image: Image Processing 6h KA
KA Core 6
Morphological operations E
Connected components
Dilation
Erosion
Computing region properties (area, perimeter, centroid, etc.)
Color histograms E
Representation
Contrast enhancement through normalization
Image enhancement E
Convolution
Blur (e.g., Gaussian)
Sharpen (e.g., Laplacian)
Frequency filtering (e.g., low-pass, high-pass)
Image restoration E
Noise, degradation
Inpainting and other completion algorithms
Wiener filter
Image coding E
Redundancy
Compression (e.g., Huffman coding)
Discrete Cosine Transform (DCT), wavelet transform, Fourier transforms (See also: SPD- Interactive)
Nyquist Theorem
Watermarks
Connections to deep learning (e.g., Convolutional Neural Networks) E
Illustrative Learning Outcomes 5
KA Core 5
Write a program that uses dilation and erosion to smooth the edges of a binary image.
Manipulating the hue of an image.
Write a program that applies a high-pass filter to an image. (The advanced variation would be to filter an image using a high-pass filter in the frequency domain.)
Write a program that restores missing parts of an image using an in-paint algorithm (e.g., Poisson image editing)
Assess the results of selectively filtering an image in the frequency domain.
GIT-Physical: Tangible/Physical Computing 6h KA
KA Core 3
Interaction with the physical world
Acquisition of data from sensors
Driving external actuators
Connection to physical artifacts
Computer-Aided Design (CAD)
Computer-Aided Manufacturing (CAM)
Fabrication
Prototyping
Additive (3D printing)
Subtractive (Computer Numerical Control (CNC) milling)
Forming (vacuum forming)
Internet of Things
Network connectivity
Wireless communication
Illustrative Learning Outcomes 8
KA Core 8
Construct a simple virtual switch or application button and use it to turn on an LED.
Construct a simple system to move a servo in response to sensor data.
Create a circuit and accompanying microcontroller code that uses a light sensor to vary a property of something else (e.g., color or brightness of an LED or graphic, position of an external actuator).
Create a circuit with a variable resistor and write a microcontroller program that reads and responds to the resistor’s changing values.
Create a 3D form in a CAD package.
Show how affine transformations are achieved in the CAD program.
Show an example of instances of an object.
Create a fabrication plan. Provide a cost estimate for materials and time. How will you fabricate it?
Fabricate it. How closely did your actual fabrication process match your plan? Where did it differ?
Write the G- and M-Code to construct a 3D maze and use a CAD/CAM package to check your work.
Decide and defend your decision to use Ethernet, WiFi, Bluetooth, RFID/NFC, or something else for internet connectivity when designing an IoT pill dispenser. Create an IoT pill dispenser.
Distinguish between the different types of fabrication and describe when you would use each.
GIT-SEP: Society, Ethics, and the Profession in SEP
KA Core 4
Accessibility in immersive, interactive, and physical computing applications Ev
Accessible to people with mobility impairments
Accessible to people with vision and/or hearing impairments
Ethics/privacy in graphics applications. (See also: SEP-Privacy, SEP-Professional-Ethics, and SEP-Security) Ev
Acquisition of private data (room scans, body proportions, active cameras, etc.)
Can’t look away from immersive applications easily
Danger to self/surroundings while immersed
Ethical pitfalls of facial recognition
Misleading visualizations
Due to incorrect data because of exaggeration, hole filling, smoothing, data cleanup, etc.
Even correct data can mislead (e.g., aliasing can cause back moving or stopped fan blades)
Privacy regarding health and other personal information
Bias in image processing
Deep fakes
Applications that misidentify people based on skin color or hairstyle
Intellectual Property law as it relates to computer graphics and interactive techniques (See also: SEP-IP) Ev
images used to train generative AI
images produced by generative AI
Current and past contributors to the field Ev
Illustrative Learning Outcomes 17
CS Core 1
User-centered design and evaluation methods. (See also: SEP-Context, SEP-Ethical-Analysis SEP-Professional-Ethics)
“You are not the users”
User needs-finding
Formative studies
Interviews
Surveys
Usability tests
KA Core 15
Discuss the security issues inherent in location tags.
Describe the ethical pitfalls of facial recognition. Can facial recognition be used ethically? If so how?
Discuss the copyright issues of using watermarked images to train a neural network. importance of being a life-long learner. disparate subject matter expertise. Students should understand the value of being a good team member, and their teamwork skills should be cultivated and evaluated with constructive feedback. written, and in code—should be practiced and evaluated.
Coordinate geometry
Trigonometry
MSF-Linear*
Points (coordinate systems & homogeneous coordinates), vectors, and matrices
Vector operations: addition, scaling, dot and cross products
Matrix operations: addition, multiplication, determinants
Affine transformations
MSF-Calculus*
Continuity
MSF-Linear
Eigenvectors and Eigen decomposition
Gaussian elimination and lower upper factorization
Singular value decomposition
MSF-Calculus
Quaternions
Differentiation
Vector calculus
Tensors
Differential geometry
MSF-Probability
MSF-Statistics
MSF-Discrete
Numerical methods for simulation
Data Structures necessary for this knowledge area (See also: AL-Foundational, SDF-Algorithms SDF-Data-Structures)
Directed Acyclic Graphs
Tuples (points / vectors / matrices of fixed dimension)
Dense 1D, 2D, 3D arrays.
Data Structures desirable for this knowledge area (See also: AL-Foundational, SDF-Algorithms SDF-Data-Structures, SDF-Practices)
Array Structures and Structure of Arrays
Trees (e.g., K-trees, quadtrees, Huffman Trees) ● Erik Brunvand, University of Utah, Salt Lake City, UT, USA ● Kel Elkins, NASA/GSFC Scientific Visualization Studio, Greenbelt, MD, USA ● Jeff Lait, SideFX, Toronto, Canada ● Amruth Kumar, Ramapo College, Mahwah, NJ, USA ● Paul Mihail, Valdosta State University, Valdosta, GA, USA ● Tabitha Peck, Davidson College, Davidson, NC, USA ● Ken Schmidt, NOAA NCEI, Asheville, NC, USA ● Dave Shreiner, UnityTechnologies & Sonoma State University, San Francis
Jon Quast, Clay Bruning, and Sanmeet Deo. "Markets: This Opportunity for Investors Is Bigger Than Movies and Music Combined." https://www.nasdaq.com/articles/this-opportunity-for-investors- is-bigger-than-movies-and-music-combined-2021-10-03. Accessed March 2024. Human-Computer Interaction (HCI) future technological development. user. reduced emphasis on specific modalities in favor of a more timely and empathetic approach. implications of a computational system on its users, including issues in
Non-core 1
Multi-user systems
Professional Dispositions 4
Self-directed: Graphics hardware and software evolves rapidly. Students need to understand the importance of being a life-long learner.
Collaborative: Graphics developers typically work in diverse teams composed of people with disparate subject matter expertise. Students should understand the value of being a good team member, and their teamwork skills should be cultivated and evaluated with constructive feedback.
Effective communicator: Communication is critical. Students’ technical communication—verbal, written, and in code—should be practiced and evaluated.
Creative: Creative problem-solving lies at the core of computer graphics.
Mathematics Requirements 11
Required 4
Coordinate geometry
Trigonometry
MSF-Linear*
Points (coordinate systems & homogeneous coordinates), vectors, and matrices
Vector operations: addition, scaling, dot and cross products
Matrix operations: addition, multiplication, determinants
Affine transformations
MSF-Calculus*
Continuity
Desirable 7
MSF-Linear
Eigenvectors and Eigen decomposition
Gaussian elimination and lower upper factorization
Singular value decomposition
MSF-Calculus
Quaternions
Differentiation
Vector calculus
Tensors
Differential geometry
MSF-Probability
MSF-Statistics
MSF-Discrete
Numerical methods for simulation
Data Structures necessary for this knowledge area (See also: AL-Foundational, SDF-Algorithms SDF-Data-Structures)
Directed Acyclic Graphs
Tuples (points / vectors / matrices of fixed dimension)
Dense 1D, 2D, 3D arrays.
Data Structures desirable for this knowledge area (See also: AL-Foundational, SDF-Algorithms SDF-Data-Structures, SDF-Practices)
Array Structures and Structure of Arrays
Trees (e.g., K-trees, quadtrees, Huffman Trees)
AI – Artificial Intelligence 12 CS 18 KA 12 units
AI-Introduction: Fundamental Issues 2h CS 1h KA
CS Core 6
Overview of AI problems, Examples of successful recent AI applications
Definitions of agents with examples (e.g., reactive, deliberative) Ev
What is intelligent behavior? Ev
The Turing test and its flaws
Multimodal input and output
Simulation of intelligent behavior
Rational versus non-rational reasoning
Problem characteristics Ev
Fully versus partially observable
Single versus multi-agent
Deterministic versus stochastic
Static versus dynamic
Discrete versus continuous
Nature of agents Ev
Autonomous, semi-autonomous, mixed-initiative autonomy
Reflexive, goal-based, and utility-based
Decision making under uncertainty and with incomplete information
The importance of perception and environmental interactions
Learning-based agents
Embodied agents
sensors, dynamics, effectors
Overview of AI Applications, growth, and impact (economic, societal, ethics) Ev
KA Core 3
Practice identifying problem characteristics in example environments Ev
Additional depth on nature of agents with examples Ev
Additional depth on AI Applications, Growth, and Impact (economic, societal, ethics, security) Ev
Non-core 2
Philosophical issues
History of AI
Illustrative Learning Outcomes 4
Describe the Turing test and the “Chinese Room” thought experiment.
Differentiate between optimal reasoning/behavior and human-like reasoning/behavior.
Differentiate the terms: AI, machine learning, and deep learning.
Enumerate the characteristics of a specific problem.
AI-Search: Search 2+3(AL)h CS 6h KA
CS Core 4
State space representation of a problem E
Specifying states, goals, and operators
Factoring states into representations (hypothesis spaces)
Problem solving by graph search
e.g., Graphs as a space, and tree traversals as exploration of that space
Dynamic construction of the graph (not given upfront)
Uninformed graph search for problem solving A
Breadth-first search
Depth-first search
With iterative deepening
Uniform cost search
Heuristic graph search for problem solving A
Heuristic construction and admissibility
Hill-climbing
Local minima and the search landscape
Local vs global solutions
Greedy best-first search
A* search
Space and time complexities of graph search algorithms A
KA Core 5
Bidirectional search A
Beam search A
Two-player adversarial games A
Minimax search
Alpha-beta pruning
Ply cutoff
Implementation of A* search A
Constraint satisfaction A
Non-core 8
Understanding the search space A
Constructing search trees
Dynamic search spaces
Combinatorial explosion of search space
Search space topology (e.g., ridges, saddle points, local minima)
Local search A
Tabu search A
Variations on A* (IDA*, SMA*, RBFS)
Two-player adversarial games A
The horizon effect
Opening playbooks/endgame solutions
What it means to “solve” a game (e.g., checkers)
Implementation of minimax search, beam search A
Expectimax search (MDP-solving) and chance nodes A
Stochastic search A
Simulated annealing
Genetic algorithms
Monte-Carlo tree search
Illustrative Learning Outcomes 12
Design the state space representation for a puzzle (e.g., N-queens or 3-jug problem)
Select and implement an appropriate uninformed search algorithm for a problem (e.g., tic-tac-toe) and characterize its time and space complexities.
Select and implement an appropriate informed search algorithm for a problem after designing a helpful heuristic function (e.g., a robot navigating a 2D gridworld).
Evaluate whether a heuristic for a given problem is admissible/can guarantee an optimal solution.
Apply minimax search in a two-player adversarial game (e.g., connect four), using heuristic evaluation at a particular depth to compute the scores to back up. [KA Core]
Design and implement a genetic algorithm solution to a problem.
Design and implement a simulated annealing schedule to avoid local minima in a problem.
Design and implement A*/beam search to solve a problem, and compare it against other search algorithms in terms of the solution cost, number of nodes expanded, etc.
Apply minimax search with alpha-beta pruning to prune search space in a two-player adversarial game (e.g., connect four).
Compare and contrast genetic algorithms with classic search techniques, explaining when it is most appropriate to use a genetic algorithm to learn a model versus other forms of optimization (e.g. gradient descent).
Compare and contrast various heuristic searches vis-a-vis applicability to a given problem.
Model a logic or Sudoku puzzle as a constraint satisfaction problem, solve it with backtrack search and determine how much arc consistency can reduce the search space.
AI-KRR: Fundamental Knowledge Representation and Reasoning 1+1(MSF)h CS 2h KA
CS Core 3
Types of representations E
Symbolic, logical
Creating a representation from a natural language problem statement
Learned subsymbolic representations
Graphical models (e.g., naive Bayes, Bayesian network)
Review of probabilistic reasoning, Bayes theorem A
Bayesian reasoning A
Bayesian inference
KA Core 5
Random variables and probability distributions A
Axioms of probability
Probabilistic inference
Bayes’ Rule (derivation)
Bayesian inference (more complex examples)
Independence A
Conditional Independence A
Markov chains and Markov models A
Utility and decision making A
Illustrative Learning Outcomes 52
CS Core 9
Definition and examples of a broad variety of machine learning tasks
Supervised learning
Classification
Regression
Reinforcement learning
Unsupervised learning
Clustering
Fundamental ideas:
No free lunch theorem: no one learner can solve all problems; representational design decisions have consequences.
Sources of error and undecidability in machine learning
A simple statistical-based supervised learning such as linear regression or decision trees
Focus on how they work without going into mathematical or optimization details; enough to understand and use existing implementations correctly
The overfitting problem/controlling solution complexity (regularization, pruning – intuition only)
The bias (underfitting) – variance (overfitting) tradeoff
Working with Data
Data preprocessing
Importance and pitfalls of preprocessing choices
Handling missing values (imputing, flag-as-missing)
Implications of imputing vs flag-as-missing
Encoding categorical variables, encoding real-valued data
Normalization/standardization
Emphasis on real data, not textbook examples
Representations
Hypothesis spaces and complexity
Simple basis feature expansion, such as squaring univariate features
Learned feature representations
Machine learning evaluation
Separation of train, validation, and test sets
Performance metrics for classifiers
Estimation of test performance on held-out data
Tuning the parameters of a machine learning model with a validation set
Importance of understanding what a model is doing, where its pitfalls/shortcomings are, and the implications of its decisions
Basic neural networks
Fundamentals of understanding how neural networks work and their training process, without details of the calculations
Basic introduction to generative neural networks (e.g., large language models)
Ethics for Machine Learning
Focus on real data, real scenarios, and case studies
Dataset/algorithmic/evaluation bias and unintended consequences
KA Core 7
Formulation of simple machine learning as an optimization problem, such as least squares linear regression or logistic regression
Objective function
Gradient descent
Regularization to avoid overfitting (mathematical formulation)
Ensembles of models
Simple weighted majority combination
Deep learning
Deep feed-forward networks (intuition only, no mathematics)
Convolutional neural networks (intuition only, no mathematics)
Visualization of learned feature representations from deep nets
Other architectures (generative NN, recurrent NN, transformers, etc.)
Performance evaluation
Other metrics for classification (e.g., error, precision, recall)
Performance metrics for regressors
Confusion matrix
Cross-validation
Parameter tuning (grid/random search, via cross-validation)
Overview of reinforcement learning methods
Two or more applications of machine learning algorithms
E.g., medicine and health, economics, vision, natural language, robotics, game play
Ethics for Machine Learning
Continued focus on real data, real scenarios, and case studies
Privacy
Fairness
Intellectual property
Explainability
Non-core 36
General statistical-based learning, parameter estimation (maximum likelihood)
Supervised learning
Decision trees
Nearest-neighbor classification and regression
Learning simple neural networks / multi-layer perceptrons
Linear regression
Logistic regression
Support vector machines (SVMs) and kernels
Gaussian Processes
Overfitting
The curse of dimensionality
Regularization (mathematical computations, L2 and L1 regularization)
Experimental design
Data preparation (e.g., standardization, representation, one-hot encoding)
Hypothesis space
Biases (e.g., algorithmic, search)
Partitioning data: stratification, training set, validation set, test set
Parameter tuning (grid/random search, via cross-validation)
Performance evaluation
Cross-validation
Metric: error, precision, recall, confusion matrix
Receiver operating characteristic (ROC) curve and area under ROC curve
Bayesian learning (Cross-Reference AI/Reasoning Under Uncertainty)
Naive Bayes and its relationship to linear models
Bayesian networks
Prior/posterior
Generative models
Deep learning
Deep feed-forward networks
Neural tangent kernel and understanding neural network training
Convolutional neural networks
Autoencoders
Recurrent networks
Representations and knowledge transfer
Adversarial training and generative adversarial networks
Attention mechanisms
Representations
Manually crafted representations
Basis expansion
Learned representations (e.g., deep neural networks)
Unsupervised learning and clustering
K-means
Gaussian mixture models
Expectation maximization (EM)
Self-organizing maps
Graph analysis (e.g., PageRank)
Semi-supervised learning
Graphical models
Ensembles
Weighted majority
Boosting/bagging
Random forest
Gated ensemble
Learning theory
General overview of learning theory / why learning works
VC dimension
Generalization bounds
Reinforcement learning
Exploration vs exploitation tradeoff
Markov decision processes
Value and policy iteration
Policy gradient methods
Deep reinforcement learning
Learning from demonstration and inverse RL
Explainable / interpretable machine learning
Understanding feature importance (e.g., LIME, Shapley values)
Interpretable models and representations
Recommender systems
Hardware for machine learning
GPUs / TPUs
Application of machine learning algorithms to:
Medicine and health
Economics
Education
Vision
Natural language
Robotics
Game play
Data mining (Cross-reference DM/Data Analytics)
Ethics for Machine Learning
Continued focus on real data, real scenarios, and case studies
In depth exploration of dataset/algorithmic/evaluation bias, data privacy, and fairness (See also: SEP-Privacy, SEP-Context)
Trust / explainability
Describe the differences among the three main styles of learning (supervised, reinforcement, and unsupervised) and determine which is appropriate to a particular problem domain.
Differentiate the terms of AI, machine learning, and deep learning.
Frame an application as a classification problem, including the available input features and output to be predicted (e.g., identifying alphabetic characters from pixel grid input).
Apply two or more simple statistical learning algorithms to a classification task and measure the classifiers’ accuracy.
Identify overfitting in the context of a problem and learning curves and describe solutions to overfitting.
Explain how machine learning works as an optimization/search process.
Implement a statistical learning algorithm and the corresponding optimization process to train the classifier and obtain a prediction on new data.
Describe the neural network training process and resulting learned representations.
Explain proper ML evaluation procedures, including the differences between training and testing performance, and what can go wrong with the evaluation process leading to inaccurate reporting of ML performance.
Compare two machine learning algorithms on a dataset, implementing the data preprocessing and evaluation methodology (e.g., metrics and handling of train/test splits) from scratch.
Visualize the training progress of a neural network through learning curves in a well-established toolkit (e.g., TensorBoard) and visualize the learned features of the network.
Compare and contrast several learning techniques (e.g., decision trees, logistic regression, naive Bayes, neural networks, and belief networks), providing examples of when each strategy is superior.
Evaluate the performance of a simple learning system on a real-world dataset.
Characterize the state of the art in learning theory, including its achievements and shortcomings.
Explain the problem of overfitting, along with techniques for detecting and managing the problem.
Explain the triple tradeoff among the size of a hypothesis space, the size of the training set, and performance accuracy.
Given a real-world application of machine learning, describe ethical issues regarding the choices of data, preprocessing steps, algorithm selection, and visualization/presentation of results.
AI-ML: Machine Learning 4h CS 6h KA
CS Core 9
Definition and examples of a broad variety of machine learning tasks A
Supervised learning
Classification
Regression
Reinforcement learning
Unsupervised learning
Clustering
Fundamental ideas: A
No free lunch theorem: no one learner can solve all problems; representational design decisions have consequences.
Sources of error and undecidability in machine learning
A simple statistical-based supervised learning such as linear regression or decision trees Ev
Focus on how they work without going into mathematical or optimization details; enough to understand and use existing implementations correctly
The overfitting problem/controlling solution complexity (regularization, pruning – intuition only) Ev
The bias (underfitting) – variance (overfitting) tradeoff
Working with Data Ev
Data preprocessing
Importance and pitfalls of preprocessing choices
Handling missing values (imputing, flag-as-missing)
Implications of imputing vs flag-as-missing
Encoding categorical variables, encoding real-valued data
Normalization/standardization
Emphasis on real data, not textbook examples
Representations Ev
Hypothesis spaces and complexity
Simple basis feature expansion, such as squaring univariate features
Learned feature representations
Machine learning evaluation Ev
Separation of train, validation, and test sets
Performance metrics for classifiers
Estimation of test performance on held-out data
Tuning the parameters of a machine learning model with a validation set
Importance of understanding what a model is doing, where its pitfalls/shortcomings are, and the implications of its decisions
Basic neural networks Ev
Fundamentals of understanding how neural networks work and their training process, without details of the calculations
Basic introduction to generative neural networks (e.g., large language models)
Ethics for Machine Learning Ev
Focus on real data, real scenarios, and case studies
Dataset/algorithmic/evaluation bias and unintended consequences
KA Core 7
Formulation of simple machine learning as an optimization problem, such as least squares linear regression or logistic regression Ev
Objective function
Gradient descent
Regularization to avoid overfitting (mathematical formulation)
Ensembles of models Ev
Simple weighted majority combination
Deep learning Ev
Deep feed-forward networks (intuition only, no mathematics)
Convolutional neural networks (intuition only, no mathematics)
Visualization of learned feature representations from deep nets
Other architectures (generative NN, recurrent NN, transformers, etc.)
Performance evaluation Ev
Other metrics for classification (e.g., error, precision, recall)
Performance metrics for regressors
Confusion matrix
Cross-validation
Parameter tuning (grid/random search, via cross-validation)
Overview of reinforcement learning methods Ev
Two or more applications of machine learning algorithms Ev
E.g., medicine and health, economics, vision, natural language, robotics, game play
Ethics for Machine Learning Ev
Continued focus on real data, real scenarios, and case studies
Privacy
Fairness
Intellectual property
Explainability
Non-core 19
General statistical-based learning, parameter estimation (maximum likelihood) Ev
Supervised learning Ev
Decision trees
Nearest-neighbor classification and regression
Learning simple neural networks / multi-layer perceptrons
Linear regression
Logistic regression
Support vector machines (SVMs) and kernels
Gaussian Processes
Overfitting Ev
The curse of dimensionality
Regularization (mathematical computations, L2 and L1 regularization)
Experimental design
Data preparation (e.g., standardization, representation, one-hot encoding)
Hypothesis space
Biases (e.g., algorithmic, search)
Partitioning data: stratification, training set, validation set, test set
Parameter tuning (grid/random search, via cross-validation)
Performance evaluation
Cross-validation
Metric: error, precision, recall, confusion matrix
Receiver operating characteristic (ROC) curve and area under ROC curve
Bayesian learning (Cross-Reference AI/Reasoning Under Uncertainty) Ev
Naive Bayes and its relationship to linear models
Bayesian networks
Prior/posterior
Generative models
Deep learning Ev
Deep feed-forward networks
Neural tangent kernel and understanding neural network training
Convolutional neural networks
Autoencoders
Recurrent networks
Representations and knowledge transfer
Adversarial training and generative adversarial networks
Attention mechanisms
Representations Ev
Manually crafted representations
Basis expansion
Learned representations (e.g., deep neural networks)
Unsupervised learning and clustering Ev
K-means
Gaussian mixture models
Expectation maximization (EM)
Self-organizing maps
Graph analysis (e.g., PageRank)
Semi-supervised learning Ev
Graphical models
Ensembles Ev
Weighted majority
Boosting/bagging
Random forest
Gated ensemble
Learning theory Ev
General overview of learning theory / why learning works
VC dimension
Generalization bounds
Reinforcement learning Ev
Exploration vs exploitation tradeoff
Markov decision processes
Value and policy iteration
Policy gradient methods
Deep reinforcement learning
Learning from demonstration and inverse RL
Explainable / interpretable machine learning Ev
Understanding feature importance (e.g., LIME, Shapley values)
Interpretable models and representations
Recommender systems
Hardware for machine learning Ev
GPUs / TPUs
Application of machine learning algorithms to: Ev
Medicine and health
Economics
Education
Vision
Natural language
Robotics
Game play
Data mining (Cross-reference DM/Data Analytics)
Ethics for Machine Learning Ev
Continued focus on real data, real scenarios, and case studies
In depth exploration of dataset/algorithmic/evaluation bias, data privacy, and fairness (See also: SEP-Privacy, SEP-Context)
Trust / explainability
Illustrative Learning Outcomes 17
Describe the differences among the three main styles of learning (supervised, reinforcement, and unsupervised) and determine which is appropriate to a particular problem domain.
Differentiate the terms of AI, machine learning, and deep learning.
Frame an application as a classification problem, including the available input features and output to be predicted (e.g., identifying alphabetic characters from pixel grid input).
Apply two or more simple statistical learning algorithms to a classification task and measure the classifiers’ accuracy.
Identify overfitting in the context of a problem and learning curves and describe solutions to overfitting.
Explain how machine learning works as an optimization/search process.
Implement a statistical learning algorithm and the corresponding optimization process to train the classifier and obtain a prediction on new data.
Describe the neural network training process and resulting learned representations.
Explain proper ML evaluation procedures, including the differences between training and testing performance, and what can go wrong with the evaluation process leading to inaccurate reporting of ML performance.
Compare two machine learning algorithms on a dataset, implementing the data preprocessing and evaluation methodology (e.g., metrics and handling of train/test splits) from scratch.
Visualize the training progress of a neural network through learning curves in a well-established toolkit (e.g., TensorBoard) and visualize the learned features of the network.
Compare and contrast several learning techniques (e.g., decision trees, logistic regression, naive Bayes, neural networks, and belief networks), providing examples of when each strategy is superior.
Evaluate the performance of a simple learning system on a real-world dataset.
Characterize the state of the art in learning theory, including its achievements and shortcomings.
Explain the problem of overfitting, along with techniques for detecting and managing the problem.
Explain the triple tradeoff among the size of a hypothesis space, the size of the training set, and performance accuracy.
Given a real-world application of machine learning, describe ethical issues regarding the choices of data, preprocessing steps, algorithm selection, and visualization/presentation of results.
AI-SEP: Applications and Societal Impact 3h CS 3h KA
CS Core 3
At least one application of AI to a specific problem and field, such as medicine, health sustainability, social media, economics, education, robotics, etc. (choose at least one for the CS Core). Ev
Formulating and evaluating a specific application as an AI problem
How to deal with underspecified or ill-posed problems
Data availability/scarcity and cleanliness
Basic data cleaning and preprocessing
Data set bias
Algorithmic bias
Evaluation bias
Assessment of societal implications of the application
Deployed deep generative models Ev
High-level overview of deep image generative models (e.g., as of 2023, DALL-E, Midjourney Stable Diffusion, etc.), their uses, and their shortcomings/pitfalls.
High-level overview of large language models (e.g., as of 2023, ChatGPT, Bard, etc.), their uses, and their shortcomings/pitfalls.
Overview of societal impact of AI Ev
Ethics
Fairness
Trust/explainability
Privacy and usage of training data
Human autonomy and oversight/regulations/legal requirements
Sustainability
KA Core 3
One or more additional applications of AI to a broad set of problems and diverse fields, such as medicine, health, sustainability, social media, economics, education, robotics, etc. (choose a different area from that chosen for the CS Core). Ev
Formulating and evaluating a specific application as an AI problem
How to deal with underspecified or ill-posed problems
Data availability/scarcity and cleanliness
Basic data cleaning and preprocessing
Data set bias
Algorithmic bias
Evaluation bias
Assessment of societal implications of the application
Additional depth on deployed deep generative models Ev
Introduction to how deep image generative models work, (e.g., as of 2023, DALL-E, Midjourney Stable Diffusion) including discussion of attention
Introduction to how large language models work, (e.g., as of 2023, ChatGPT, Bard) including discussion of attention
Idea of foundational models, how to use them, and the benefits/issues with training them from big data
Analysis and discussion of the societal impact of AI Ev
Ethics
Fairness
Trust/explainability
Privacy and usage of training data
Human autonomy and oversight/regulations/legal requirements
Sustainability
Illustrative Learning Outcomes 3
Given a real-world application domain and problem, formulate an AI solution to it, identifying proper data/input, preprocessing, representations, AI techniques, and evaluation metrics/methodology.
Analyze the societal impact of one or more specific real-world AI applications, identifying issues regarding ethics, fairness, bias, trust, and explainability.
Describe some of the failure modes of current deep generative models for language or images, and how this could affect their use in an application.
AI-LRR: Logical Representation and Reasoning
Non-core 12
Review of propositional and predicate logic
Resolution and theorem proving (propositional logic only)
Forward chaining, backward chaining
Knowledge representation issues
Description logics
Ontology engineering
Semantic web
Non-monotonic reasoning (e.g., non-classical logics, default reasoning)
Argumentation
Reasoning about action and change (e.g., situation and event calculus)
Temporal and spatial reasoning
Logic programming
Prolog, Answer Set Programming
Rule-based Expert Systems
Semantic networks
Model-based and Case-based reasoning
Illustrative Learning Outcomes 13
Translate a natural language (e.g., English) sentence into a predicate logic statement.
Convert a logic statement into clausal form.
Apply resolution to a set of logic statements to answer a query.
Compare and contrast the most common models used for structured knowledge representation highlighting their strengths and weaknesses.
Identify the components of non-monotonic reasoning and its usefulness as a representational mechanism for belief systems.
Compare and contrast the basic techniques for representing uncertainty.
Compare and contrast the basic techniques for qualitative representation.
Apply situation and event calculus to problems of action and change.
Explain the distinction between temporal and spatial reasoning, and how they interrelate.
Explain the difference between rule-based, case-based, and model-based reasoning techniques.
Define the concept of a planning system and how it differs from classical search techniques.
Describe the differences between planning as search, operator-based planning, and propositional planning, providing examples of domains where each is most applicable.
Explain the distinction between monotonic and non-monotonic inference.
AI-Probability: Probabilistic Representation and Reasoning
Non-core 3
Conditional Independence review
Knowledge representations
Bayesian Networks
Exact inference and its complexity
Markov blankets and d-separation
Randomized sampling (Monte Carlo) methods (e.g., Gibbs sampling)
Markov Networks
Relational probability models
Hidden Markov Models
Decision Theory
Preferences and utility functions
Maximizing expected utility
Game theory
Illustrative Learning Outcomes 9
Compute the probability of a hypothesis given the evidence in a Bayesian network.
Explain how conditional independence assertions allow for greater efficiency of probabilistic systems.
Identify examples of knowledge representations for reasoning under uncertainty.
State the complexity of exact inference. Identify methods for approximate inference.
Design and implement at least one knowledge representation for reasoning under uncertainty.
Describe the complexities of temporal probabilistic reasoning.
Design and implement an HMM as one example of a temporal probabilistic system.
Describe the relationship between preferences and utility functions.
Explain how utility functions and probabilistic reasoning can be combined to make rational decisions.
AI-Planning: Planning
Non-core 10
Review of propositional and first-order logic
Planning operators and state representations
Total order planning
Partial-order planning
Plan graphs and GraphPlan
Hierarchical planning
Planning languages and representations
PDDL
Multi-agent planning
MDP-based planning
Interconnecting planning, execution, and dynamic replanning
Conditional planning
Continuous planning
Probabilistic planning
Illustrative Learning Outcomes 13
Non-core 13
Agent architectures (e.g., reactive, layered, cognitive)
Agent theory (including mathematical formalisms)
Rationality, Game Theory
Decision-theoretic agents
Markov decision processes (MDP)
Bandit algorithms
Software agents, personal assistants, and information access
Collaborative agents
Information-gathering agents
Believable agents (synthetic characters, modeling emotions in agents)
Learning agents
Cognitive systems
Cognitive architectures (e.g., ACT-R, SOAR, ICARUS, FORR)
Capabilities (e.g., perception, decision making, prediction, knowledge maintenance)
Knowledge representation, organization, utilization, acquisition, and refinement
Applications and evaluation of cognitive systems
Multi-agent systems
Collaborating agents
Agent teams
Competitive agents (e.g., auctions, voting)
Swarm systems and biologically inspired models
Multi-agent learning
Human-agent interaction
Communication methodologies (verbal and non-verbal)
Practical issues
Applications
Trading agents, supply chain management
Ethical issues of AI interactions with humans
Regulation and legal requirements of AI systems for interacting with humans
Characterize and contrast the standard agent architectures.
Describe the applications of agent theory to domains such as software agents, personal assistants and believable agents, and discuss associated ethical implications.
Describe the primary paradigms used by learning agents.
Demonstrate using appropriate examples how multi-agent systems support agent interaction.
Construct an intelligent agent using a well-established cognitive architecture (ACT-R, SOAR) for solving a specific problem.
AI-Agents: Agents and Cognitive Systems
Non-core 8
Agent architectures (e.g., reactive, layered, cognitive)
Agent theory (including mathematical formalisms)
Rationality, Game Theory
Decision-theoretic agents
Markov decision processes (MDP)
Bandit algorithms
Software agents, personal assistants, and information access
Collaborative agents
Information-gathering agents
Believable agents (synthetic characters, modeling emotions in agents)
Learning agents
Cognitive systems
Cognitive architectures (e.g., ACT-R, SOAR, ICARUS, FORR)
Capabilities (e.g., perception, decision making, prediction, knowledge maintenance)
Knowledge representation, organization, utilization, acquisition, and refinement
Applications and evaluation of cognitive systems
Multi-agent systems
Collaborating agents
Agent teams
Competitive agents (e.g., auctions, voting)
Swarm systems and biologically inspired models
Multi-agent learning
Human-agent interaction
Communication methodologies (verbal and non-verbal)
Practical issues
Applications
Trading agents, supply chain management
Ethical issues of AI interactions with humans
Regulation and legal requirements of AI systems for interacting with humans
Illustrative Learning Outcomes 5
Characterize and contrast the standard agent architectures.
Describe the applications of agent theory to domains such as software agents, personal assistants and believable agents, and discuss associated ethical implications.
Describe the primary paradigms used by learning agents.
Demonstrate using appropriate examples how multi-agent systems support agent interaction.
Construct an intelligent agent using a well-established cognitive architecture (ACT-R, SOAR) for solving a specific problem.
AI-NLP: Natural Language Processing
Non-core 12
Deterministic and stochastic grammars
Parsing algorithms
CFGs and chart parsers (e.g., CYK)
Probabilistic CFGs and weighted CYK
Representing meaning/Semantics
Logic-based knowledge representations
Semantic roles
Temporal representations
Beliefs, desires, and intentions
Corpus-based methods
N-grams and HMMs
Smoothing and backoff
Examples of use: POS tagging and morphology
Information retrieval
Vector space model
TF & IDF
Precision and recall
Information extraction
Language translation
Text classification, categorization
Bag of words model
Deep learning for NLP
RNNs
Transformers
Multi-modal embeddings (e.g., images + text)
Generative language models
Illustrative Learning Outcomes 6
Define and contrast deterministic and stochastic grammars, providing examples to show the adequacy of each.
Simulate, apply, or implement classic and stochastic algorithms for parsing natural language.
Identify the challenges of representing meaning.
List the advantages of using standard corpora. Identify examples of current corpora for a variety of NLP tasks.
Identify techniques for information retrieval, language translation, and text classification.
Implement a TF/IDF transform, use it to extract features from a corpus, and train an off-the-shelf machine learning algorithm using those features to do text classification.
AI-Robotics: Robotics
Non-core 15
Overview: problems and progress
State-of-the-art robot systems, including their sensors and an overview of their sensor processing
Robot control architectures, e.g., deliberative vs reactive control and Braitenberg vehicles
World modeling and world models
Inherent uncertainty in sensing and in control
Sensors and effectors
Sensors: e.g., LIDAR, sonar, vision, depth, stereoscopic, event cameras, microphones, haptics
Effectors: e.g., wheels, arms, grippers
Coordinate frames, translation, and rotation (2D and 3D)
Configuration space and environmental maps
Interpreting uncertain sensor data
Localization and mapping
Navigation and control
Forward and inverse kinematics
Motion path planning and trajectory optimization
Manipulation and grasping
Joint control and dynamics
Vision-based control
Multiple-robot coordination and collaboration
Human-robot interaction
Shared workspaces
Human-robot teaming and physical HRI
Social assistive robots
Motion/task/goal prediction
Collaboration and communication (explicit vs implicit, verbal or symbolic vs non-verbal or visual)
Trust
Applications and Societal, Economic, and Ethical Issues
Societal, economic, right-to-work implications
Ethical and privacy implications of robotic applications
Liability in autonomous robotics
Autonomous weapons and ethics
Human oversight and control
Illustrative Learning Outcomes 10
List capabilities and limitations of today's state-of-the-art robot systems, including their sensors and the crucial sensor processing that informs those systems.
Integrate sensors, actuators, and software into a robot designed to undertake a specific task.
Program a robot to accomplish simple tasks using deliberative, reactive, and/or hybrid control architectures.
Implement fundamental motion planning algorithms within a robot configuration space.
Characterize the uncertainties associated with common robot sensors and actuators; articulate strategies for mitigating these uncertainties.
List the differences among robots' representations of their external environment, including their strengths and shortcomings.
Compare and contrast at least three strategies for robot navigation within known and/or unknown environments, including their strengths and shortcomings.
Describe at least one approach for coordinating the actions and sensing of several robots to accomplish a single task.
Compare and contrast a multi-robot coordination and a human-robot collaboration approach and attribute their differences to differences between the problem settings.
Analyze the societal, economic, and ethical issues of a real-world robotics application.
AI-Vision: Perception and Computer Vision
Non-core 6
Computer vision
Image acquisition, representation, processing, and properties
Shape representation, object recognition, and segmentation
Motion analysis
Generative models
Audio and speech recognition
Touch and proprioception
Other modalities (e.g., olfaction)
Modularity in recognition
Approaches to pattern recognition
Classification algorithms and measures of classification quality
Statistical techniques
Deep learning techniques
Illustrative Learning Outcomes 22
CS Core 13
Abstract Data Type (ADT) and operations on an ADT
Dictionary operations (insert, delete, find)
Arrays
Numeric vs non-numeric, character strings
Single (vector) vs multidimensional (matrix)
Records/Structs/Tuples and Objects
Linked lists (for historical reasons)
Single vs Double and Linear vs Circular
Stacks
Queues and deques
Heap-based priority queue
Hash tables/maps
Collision resolution and complexity (e.g., probing, chaining, rehash)
Graphs (e.g., [un]directed, [a]cyclic, [un]connected, and [un]weighted)
Graph representation: adjacency list vs matrix
Trees
Binary, n-ary, and search trees
Balanced (e.g., AVL, Red-Black, Heap)
Sets
Search algorithms
O(n) complexity (e.g., linear/sequential array/list search)
O(log₂ n) complexity (e.g., binary search)
O(logb n) complexity (e.g., uninformed depth/breadth-first tree search)
Sorting algorithms (e.g., stable, unstable)
O(n²) complexity (e.g., insertion, selection)
O(n log n) complexity (e.g., quicksort, merge, timsort)
Graph algorithms
Shortest path (e.g., Dijkstra’s, Floyd’s)
Minimal spanning tree (e.g., Prim’s, Kruskal’s)
KA Core 3
Sorting algorithms
O(n log n) complexity heapsort
Pseudo O(n) complexity (e.g., bucket, counting, radix)
Graph algorithms
Transitive closure (e.g., Warshall’s)
Topological sort
Matching
Efficient string matching (e.g., Boyer-Moore, Knuth-Morris-Pratt)
Longest common subsequence matching
Regular expression matching
Non-core 6
Cryptography algorithms (e.g., SHA-256)
Parallel algorithms
Consensus algorithms (e.g., Blockchain)
Proof of work vs proof of stake
Quantum computing algorithms
Oracle-based (e.g., Deutsch-Jozsa, Bernstein-Vazirani, Simon)
Superpolynomial speed-up via QFT (e.g., Shor’s)
Polynomial speed-up via amplitude amplification (e.g., Grover’s)
Fast-Fourier Transform (FFT) algorithm
Differential evolution algorithm
Professional Dispositions 4
Meticulousness: Since attention must be paid to details when implementing AI and machine learning algorithms, students must be meticulous about detail.
Persistence: AI techniques often operate in partially observable environments and optimization processes may have cascading errors from multiple iterations. Getting AI techniques to work predictably takes trial and error, and repeated effort. These call for persistence on the part of the student.
Inventive: Applications of AI involve creative problem formulation and application of AI techniques, while balancing application requirements and societal and ethical issues.
Responsible: Applications of AI can have significant impacts on society, affecting both individuals and large populations. This calls for students to understand the implications of work in AI to society, and to make responsible choices for when and how to apply AI techniques.
Mathematics Requirements 10
Required 5
Algebra
Precalculus
Discrete Math
sets, relations, functions, graphs
predicate and first-order logic, logic-based proofs
Linear Algebra
Matrix operations, matrix algebra
Basis sets
Probability and Statistics
Basic probability theory, conditional probability, independence
Bayes theorem and applications of Bayes theorem
Expected value, basic descriptive statistics, distributions
Basic summary statistics and significance testing
All should be applied to real decision-making examples with real data, not “textbook”
Desirable 5
Calculus-based probability and statistics
Calculus: single-variable and partial derivatives
Other topics in probability and statistics
Hypothesis testing, data resampling, experimental design techniques
Optimization
Linear algebra (all other topics)
SPD – Specialized Platform Development 4 CS 8 units
SPD-Common: Common Aspects/Shared Concerns 3+(1SE)h CS 2h KA
CS Core 5
Overview of development platforms (i.e., web, mobile, game, robotics, embedded, and interactive). A
Input/sensors/control devices/haptic devices
Resource constraints
Computational
Data storage
Memory
Communication
Requirements – security, uptime availability, fault tolerance (See also: SE-Reliability, SEC- Engineering)
Output/actuators/haptic devices
Programming via platform-specific Application Programming Interface (API) vs traditional application construction A
Overview of platform Languages (e.g., Python, Swift, Lua, Kotlin) A
Programming under platform constraints and requirements (e.g., available development tools development, security considerations) A
Techniques for learning and mastering a platform-specific programming language A
Illustrative Learning Outcomes 4
CS Core 4
List the constraints of mobile programming.
List the characteristics of scripting languages.
Describe the three-tier model of web programming.
Describe how the state is maintained in web programming.
SPD-Web: Web Platforms 5+(1HCI)h KA
KA Core 5
Web programming languages (e.g., HTML5, JavaScript, PHP, CSS) A
Web platforms, frameworks, or meta-frameworks A
Cloud services
API, Web Components
Software as a Service (SaaS) A
Web standards such as document object model, accessibility A
Security and Privacy Considerations A
Non-core 5
Analyzing requirements for web applications
Computing services
Cloud Hosting
Scalability (e.g., Autoscaling, Clusters)
Cost estimation for services
Data management
Data residency: where the data is located and what paths can be taken to access it
Data integrity: guaranteeing data is accessible and that data is deleted when required
Architecture
Monoliths vs Microservices
Micro-frontends
Event-Driven vs RESTful architectures: advantages and disadvantages
Serverless, cloud computing on demand
Storage solutions
Relational Databases
NoSQL databases
Illustrative Learning Outcomes 6
KA Core 6
Design and implement a web-based application using a microservice architecture design.
Describe the constraints, such as hosting, services, and scalability, related to web platforms.
Compare and contrast web programming with general-purpose programming.
Describe the differences between Software-as-a-Service (SaaS) and traditional software products.
Discuss how web standards impact software development.
Evaluate an existing web application against current web standards.
SPD-Mobile: Mobile Platforms 3+(shared)h KA
KA Core 3
Development with A
Mobile programming languages
Mobile programming environments
Mobile platform constraints A
User interface design
Security
Access A
Accessing data through APIs
Designing API endpoints for mobile apps: pitfalls and design considerations
Network and web interfaces
Non-core 5
Development A
Native versus cross-platform development
Software design/architecture patterns for mobile applications
Mobile platform constraints A
Responsive user interface design
Heterogeneity and mobility of devices
Differences in user experiences (e.g., between mobile and web-based applications)
Power and performance tradeoff
Mobile computing affordances
Location-aware applications
Sensor-driven computing (e.g., gyroscope, accelerometer, health data from a watch)
Telephony and instant messaging
Augmented reality
Specification and testing
Asynchronous computing
Difference from traditional synchronous programming
Handling success via callbacks
Handling errors asynchronously
Testing asynchronous code and typical problems in testing
Illustrative Learning Outcomes 5
KA Core 5
Compare mobile programming with general-purpose programming.
Develop a location-aware mobile application with data API integration.
Build a sensor-driven mobile application capable of logging data on a remote server.
Create a communication app incorporating telephony and instant messaging.
Evaluate the pros and cons of native and cross-platform mobile application development.
SPD-Embedded: Embedded Platforms 4+(shared)h KA
KA Core 11
Introduction to the unique characteristics of embedded systems
Real-time vs soft real-time and non-real-time systems
Resource constraints, such as memory profiles and deadlines
API for custom architectures
GPU technology
Field Programmable Gate Arrays (FPGA)
Cross-platform systems
Embedded Systems
Microcontrollers
Interrupts and feedback
Interrupt handlers in high-level languages
Hard and soft interrupts and trap-exits
Interacting with hardware, actuators, and sensors
Energy efficiency
Loosely timed coding and synchronization
Software adapters
Embedded programming
Hard real-time systems vs soft real-time systems
Timeliness
Time synchronization/scheduling
Prioritization
Latency
Compute jitter
Real-time resource management
Memory management
Mapping programming construct (variable) to a memory location
Shared memory
Manual memory management.
Garbage collection
Safety considerations and safety analysis
Sensors and actuators
Analysis and verification
Application design
Illustrative Learning Outcomes 10
KA Core 10
Design and implement a small embedded system for a given platform (e.g., a smart alarm clock or a drone).
Describe the unique characteristics of embedded systems versus other systems.
Interface with sensors/actuators.
Debug a problem with an existing embedded platform.
Identify different types of embedded architectures.
Evaluate which architecture is best for a given set of requirements.
Design and develop software to interact with and control hardware.
Design methods for real-time systems.
Evaluate real-time scheduling and schedulability analysis.
Evaluate formal specification and verification of timing constraints and properties.
SPD-Game: Game Platforms 4+(shared)h KA
KA Core 5
Historical and contemporary platforms for games A
Evolution of Game Platforms (e.g., Brown Box to Metaverse and beyond; Improvement in Computing Architectures (CPU and GPU); Platform Convergence and Mobility)
Typical Game Platforms (e.g., Personal Computer; Home Console; Handheld Console Arcade Machine; Interactive Television; Mobile Phone; Tablet; Integrated Head-Mounted Display; Immersive Installations and Simulators; Internet of Things enabled Devices; CAVE Systems; Web Browsers; Cloud-based Streaming Systems)
Characteristics and Constraints of Different Game Platforms (e.g., Features (local storage internetworking, peripherals); Run-time performance (GPU/CPU frequency, number of cores); Chipsets (physics processing units, vector co-processors); Expansion Bandwidth (PCIe); Network throughput (Ethernet); Memory types and capacities (DDR/GDDR) Maximum stack depth; Power consumption; Thermal design; Endian)
Typical Sensors, Controllers, and Actuators (e.g., distinctive control system designs – peripherals (mouse, keypad, joystick), game controllers, wearables, interactive surfaces electronics and bespoke hardware; computer vision, inside-out tracking, and outside-in tracking; IoT-enabled electronics and I/O
eSports Ecosystems (e.g., evolution of gameplay across platforms; games and eSports game events such as LAN/arcade tournaments and international events such as the Olympic eSports Series; streamed media and spectatorship; multimedia technologies and broadcast management; professional play; data and machine learning for coaching and training)
Real-time Simulation and Rendering Systems A
CPU and GPU architectures (e.g., Flynn’s taxonomy; parallelization; instruction sets standard components – graphics compute array, graphics memory controller, video graphics array basic input/output system; bus interface; power management unit; video processing unit; display interface)
Pipelines for physical simulations and graphical rendering: (e.g., tile-based, immediate- mode).
Common Contexts for Algorithms, Data Structures, and Mathematical Functions (e.g., game loops; spatial partitioning, viewport culling, and level of detail; collision detection and resolution; physical simulation; behavior for intelligent agents; procedural content generation)
Media representations (e.g., I/O, and computation techniques for virtual worlds: audio music; sprites; models and textures; text; dialogue; multimedia (e.g., olfaction, tactile) (See also: GIT-Fundamentals)
Game Development Tools and Techniques A
Programming Languages (e.g., C++; C#; Lua; Python; JavaScript)
Shader Languages (e.g., HLSL, GLSL; Shader Graph)
Graphics Libraries and APIs (e.g., DirectX; SDL; OpenGL; Metal; Vulkan; WebGL). (See also: GIT-Rendering, HCI-Design)
Common Development Tools and Environments (e.g., IDEs; Debuggers; Profilers; Version Control Systems including those handling binary assets; Development Kits and Production/Consumer Kits; Emulators)
Game Engines A
Open Game Engines (e.g., Unreal; Unity; Godot; CryEngine; Phyre; Source 2; Pygame and Ren’Py; Phaser; Twine; Spring RTS)
Techniques (e.g., Ideation, Prototyping, Iterative Design and Implementation, Compiling Executable Builds, Development Operations and Quality Assurance – Play Testing and Technical Testing, Profiling; Optimization, Porting; Internationalization and Localization Networking)
Game Design D
Vocabulary (e.g., game definitions; mechanics-dynamics-aesthetics model; industry terminology; experience design; models of experience and emotion)
Design Thinking and User-Centered Experience Design (e.g., methods of designing games iteration, incrementing, and the double-diamond; phases of pre- and post-production; quality assurance, including alpha and beta testing; stakeholder and customer involvement community management)
Genres (e.g., adventure; walking simulator; first-person shooter; real-time strategy multiplayer online battle arena (MOBA); role-playing game (rpg))
Audiences and Player Taxonomies (e.g., people who play games; diversity and broadening participation; pleasures, player types, and preferences; Bartle, yee)
Proliferation of digital game technologies to domains beyond entertainment (e.g., Education and Training; Serious Games; Virtual Production; eSports; Gamification; Immersive Experience Design; Creative Industry Practice; Artistic Practice; Procedural Rhetoric) (See also: AI-SEP)
Illustrative Learning Outcomes 15
KA Core 15
Recall the characteristics of common general-purpose graphics processing architectures.
Identify the key stages of the immediate-mode rendering pipeline.
Describe the key constraints a specific game platform will likely impose on developers.
Explain how eSports are streamed to large audiences over the internet.
Translate complex mathematical functions into performant source code.
Use an industry-standard graphics API to render a 3D model in a virtual scene.
Modify a shader to change a visual effect according to stated requirements.
Implement a game for a particular platform according to the specification.
Optimize a function for processing collision detection in a simulated environment.
Assess a game's run-time and memory performance using an industry-standard tool and development environment.
Compare the interfaces of different game platforms, highlighting their respective implications for human-computer interaction.
Recommend an appropriate set of development tools and techniques for implementing a game of a particular genre for a given platform.
Discuss the key challenges in making a digital game that is cross-platform compatible.
Express how game developers can enhance the accessibility of a game interface.
Create novel forms of gameplay using frontier game platforms.
SPD-Robot: Robot Platforms 4+(shared)h KA
KA Core 8
Types of robotic platforms and devices A
Sensors, embedded computation, and effectors (actuators) A
Robot-specific languages and libraries A
Robotic software architecture (e.g., using the Robot Operating System (ROS)) A
Robotic platform constraints and design considerations A
Interconnections with physical or simulated systems A
Robotic Algorithms A
Forward kinematics
Inverse kinematics
Dynamics
Navigation and path planning
Grasping and manipulation
Safety and interaction considerations A
Illustrative Learning Outcomes 6
KA Core 6
Design and implement an application on a given robotic platform.
Integrate an Arduino-based robot kit and program it to navigate a maze.
Compare robot-specific languages and techniques with those used for general-purpose software development.
Explain the rationale behind the design of the robotic platform and its interconnections with physical or simulated systems.
Given a high-level application, design a robot software architecture using ROS specifying all components and interconnections (ROS topics) to accomplish that application.
Discuss the constraints a given robotic platform imposes on developers.
SPD-Interactive: Interactive Computing Platforms 3+(shared)h KA
Non-core 3
Data Analysis Platforms
Jupyter notebooks; Google Colab; R; SPSS; Observable.
Cloud SQL/data analysis platforms (e.g., BigQuery)
Apache Spark
Data Visualizations
Interactive presentations backed by data
Design tools requiring low-latency feedback loops
Rendering tools
Graphic design tools
Prompt programming
Generative AI (e.g., OpenAI’s ChatGPT, OpenAI’s Codex, GitHub’s Copilot) and LLMs are accessed/interacted
Quantum Platforms
Program quantum logic operators in quantum machines.
Use API for available quantum services
Signal analysis/Fourier analysis/Signal processing (for music composition, audio/RF analysis)
Illustrative Learning Outcomes 10
Non-core 10
Analyze large datasets interactively.
Create a backing track for a musical performance, such as live coding.
Create compelling computational notebooks that construct a narrative for a given journalistic goal/story.
Implement interactive code that uses a dataset and generates exploratory graphics.
Create a program that performs a task using LLM systems.
Contrast a program developed by an AI platform and by a human.
Implement a system that interacts with a human without using a screen.
Contextualize the attributes of different data analysis styles, such as interactive vs engineered pipeline.
Write a program using a notebook computing platform (e.g., searching, sorting, or graph manipulation).
Demonstrate a quantum gate outcome using a quantum platform.
SPD-SEP: Society, Ethics, and the Profession in SEP
CS Core 1
Included in SEP hours
Professional Dispositions 3
Self-Directed: Students should be able to learn new platforms and languages with a growth- oriented mindset and thrive in dynamic environments, while continually enhancing skills.
Inventive: Students should demonstrate excellence in designing software architecture within unconventional constraints, emphasizing adaptability and creative problem-solving for innovative solutions.
Adaptable: Students should adapt to diverse challenges, showing resilience, open-mindedness, and a proactive approach to changing requirements and constraints.
Mathematics Requirements 4
Required 1
MSF-Discrete
Desired 3
MSF-Calculus
MSF-Linear
MSF-Statistics
HCI – Human-Computer Interaction 8 CS 16 KA 6 units
HCI-User: Understanding the User: Individual goals and interactions with others 2h CS 5h KA
CS Core 1
User-centered design and evaluation methods. (See also: SEP-Context, SEP-Ethical-Analysis SEP-Professional-Ethics) D
“You are not the users”
User needs-finding
Formative studies
Interviews
Surveys
Usability tests
KA Core 4
User-centered design methodology. D
Personas/persona spectrum
User stories/storytelling and techniques for gathering stories
Empathy maps
Needs assessment (techniques for uncovering needs and gathering requirements - e.g. interviews, surveys, ethnographic and contextual enquiry)
Journey maps
Evaluating the design
Interfacing with stakeholders, as a team
Risks associated with physical, distributed, hybrid and virtual teams
Physical and cognitive characteristics of the user D
Physical capabilities that inform interaction design (e.g., color perception, ergonomics)
Cognitive models that inform interaction design (e.g., attention, perception and recognition movement, memory)
Topics in social/behavioral psychology (e.g., cognitive biases, change blindness)
Designing for diverse user populations. D
How differences (e.g., in race, ability, age, gender, culture, experience, and education) impact user experiences and needs
Internationalization
Designing for users from other cultures
Cross-cultural design
Challenges to effective design evaluation. (e.g., sampling, generalization; disability and disabled experiences)
Universal design
Collaboration and communication (See also: AI-SEP, SE-Teamwork, SEP-Communication, SPD- Game) D
Understanding the user in a multi-user context
Synchronous group communication (e.g., chat rooms, conferencing, online games)
Asynchronous group communication (e.g., email, forums, social networks)
Social media, social computing, and social network analysis
Online collaboration
Social coordination and online communities
Avatars, characters, and virtual worlds
Non-core 1
Multi-user systems
Illustrative Learning Outcomes 10
CS Core 1
Conduct a user-centered design process that is integrated into a project.
KA Core 8
Compare and contrast the needs of users with those of designers.
Identify the representative users of a design and discuss who else could be impacted by it.
Describe empathy and evaluation as elements of the design process.
Carry out and document an analysis of users and their needs.
Construct a user story from a needs assessment.
Redesign an existing solution to a population whose needs differ from those of the initial target population.
Contrast the different needs-finding methods for a given design problem.
Reflect on whether your design would benefit from low-tech or no-tech components.
Non-core 1
Recognize the implications of designing for a multi-user system/context.
HCI-Accountability: Accountability and Responsibility in Design 2h CS 2h KA
CS Core 3
Design impact Ev
Sustainability
Inclusivity
Safety, security and privacy
Harm and disparate impact
Ethics in design methods and solutions (See also: SEP-Ethical-Analysis, SEP-Context, SEP- Intellectual Property) D
The role of artificial intelligence
Responsibilities for considering stakeholder impact and human factors (See also: SEP- Professional-Ethics)
Role of design to meet user needs
Requirements in design D
Ownership responsibility
Legal frameworks, compliance requirements
Consideration beyond immediate user needs, including via iterative reconstruction of problem analysis and “digital well-being” features
KA Core 2
Value-sensitive design Ev
Identify direct and indirect stakeholders
Determine and include diverse stakeholder values and value systems.
Persuasion through design D
Assess the persuasive content of a design
Employ persuasion as a design goal
Distinguish persuasive interfaces from manipulative interfaces
Illustrative Learning Outcomes 12
CS Core 1
Identify and critique the potential impacts of a design on society and relevant communities to address such concerns as sustainability, inclusivity, safety, security, privacy, harm, and disparate impact.
KA Core 7
Identify the potential human factor elements in a design.
Identify and understand direct and indirect stakeholders.
Develop scenarios that consider the entire lifespan of a design, beyond the immediately planned uses that anticipate direct and indirect stakeholders.
Identify and critique the potential factors in a design that impact direct and indirect stakeholders and broader society (e.g., transparency, sustainability of the system, trust, artificial intelligence).
Assess the persuasive content of a design and its intent relative to user interests.
Critique the outcomes of a design given its intent.
Understand the impact of design decisions.
Non-core 4
Background
Unlearning and questioning
Disability studies
Technologies: the Return On Investment (ROI) of inclusion
Inclusive Design Frameworks: user-sensitive inclusive design
Critical approaches to HCI (e.g., inclusivity)
HCI-Accessibility: Accessibility and Inclusive Design 2h CS 2h KA
CS Core 5
Background Ev
Societal and legal support for and obligations to people with disabilities
Accessible design benefits everyone
Techniques D
Accessibility standards (e.g., Web Content Accessibility Guidelines)
Technologies D
Features and products that enable accessibility and support inclusive development by designers and engineers
IDFs (Inclusive Design Frameworks) D
Recognizing differences
Universal design A
KA Core 4
Background Ev
Demographics and populations (permanent, temporary, and situational disability)
International perspectives on disability
Attitudes towards people with disabilities
Techniques D
UX (user experience) design and research
Software engineering practices that enable inclusion and accessibility.
Technologies D
Examples of accessibility-enabling features, such as conformance to screen readers
Inclusive Design Frameworks D
Creating inclusive processes such as participatory design
Designing for larger impact
Non-core 4
Background Ev
Unlearning and questioning
Disability studies
Technologies: the Return On Investment (ROI) of inclusion D
Inclusive Design Frameworks: user-sensitive inclusive design D
Critical approaches to HCI (e.g., inclusivity)
Illustrative Learning Outcomes 10
CS Core 4
Identify accessibility challenges faced by people with different disabilities and specify the associated accessible and assistive technologies that address them.
Identify appropriate inclusive design approaches, such as universal design and ability-based design.
Identify and demonstrate understanding of software accessibility guidelines.
Demonstrate recognition of laws and regulations applicable to accessible design.
KA Core 4
Apply inclusive frameworks to design, such as universal design and usability and ability-based design, and demonstrate accessible design of visual, voice-based, and touch-based UIs.
Demonstrate understanding of laws and regulations applicable to accessible design.
Demonstrate understanding of what is appropriate and inappropriate high level of skill during interaction with individuals from diverse populations.
Analyze web pages and mobile apps for current standards of accessibility.
Non-core 2
Biases towards disability, race, and gender have historically, either intentionally or unintentionally informed technology design.
Find examples.
Consider how those experiences (learnings?) might inform design.
Conceptualize user experience research to identify user needs and generate design insights.
HCI-Evaluation: Evaluating the Design 1h CS 2h KA
CS Core 1
Methods for evaluation with users D
Formative (e.g., needs-finding, exploratory analysis) and summative assessment (e.g. functionality and usability testing)
Elements to evaluate (e.g., utility, efficiency, learnability, user satisfaction, affective elements such as pleasure and engagement)
Understanding ethical approval requirements before engaging in user research (See also: SE- Tools, SEP-Ethical-Analysis, SEP-Security, SEP-Privacy, SEP-Professional-Ethics)
KA Core 3
Methods for evaluation with users D
Qualitative methods (qualitative coding and thematic analysis)
Quantitative methods (statistical tests)
Mixed methods (e.g., observation, think-aloud, interview, survey, experiment)
Presentation requirements (e.g., reports, personas)
User-centered testing
Heuristic evaluation
Challenges and shortcomings to effective evaluation (e.g., sampling, generalization)
Study planning D
How to set study goals
Hypothesis design
Approvals from Institutional Research Boards and ethics committees (See also: SEP-Ethical- Analysis, SEP-Security, SEP-Privacy)
How to pre-register a study
Within-subjects vs between-subjects design
Implications and impacts of design with respect to the environment, material, society, security privacy, ethics, and broader impacts. D
The environment
Material
Society
Security
Privacy
Ethics
Broader impacts
Non-core 2
Techniques and tools for quantitative analysis
Statistical packages
Visualization tools
Statistical tests (e.g., ANOVA, t-tests, post-hoc analysis, parametric vs non-parametric tests)
Data exploration and visual analytics; how to calculate effect size.
Data management
Data storage and data sharing (open science)
Sensitivity and identifiability.
Illustrative Learning Outcomes 8
CS Core 1
Discuss the differences between formative and summative assessment and their role in evaluating design
KA Core 5
Select appropriate formative or summative evaluation methods at different points throughout the development of a design.
Discuss the benefits of using both qualitative and quantitative methods for evaluation.
Evaluate the implications and broader impacts of a given design.
Plan a usability evaluation for a given user interface, and justify its study goals, hypothesis design and study design.
Conduct a usability evaluation of a given user interface and draw defensible conclusions given the study design.
Non-core 2
Select and run appropriate statistical tests on provided study data to test for significance in the results.
Pre-register a study design, with planned statistical tests.
HCI-Design: System Design 1h CS 5h KA
CS Core 3
Prototyping techniques and tools D
Low-fidelity prototyping
Rapid prototyping
Throw-away prototyping
Granularity of prototyping
Design patterns D
Iterative design
Universal design
Interaction design (e.g., data-driven design, event-driven design)
Design constraints D
Platforms
Devices
Resources
Balance among usability, security and privacy
KA Core 4
Design patterns and guidelines D
Software architecture patterns
Cross-platform design
Synchronization considerations
Design processes D
Participatory design
Co-design
Double-diamond
Convergence and divergence
Interaction techniques D
Input and output vectors (e.g., gesture, pose, touch, voice, force)
Graphical user interfaces
Controllers
Haptics
Hardware design
Error handling
Visual UI design D
Color
Layout
Gestalt principles
Non-core 5
Immersive environments
XR (encompasses virtual reality, augmented reality, and mixed reality)
Spatial audio
3D printing and fabrication
Asynchronous interaction models D
Creativity support tools
Voice UI designs
Illustrative Learning Outcomes 8
CS Core 3
Propose system designs tailored to a specified appropriate mode of interaction.
Follow an iterative design and development process that incorporates the following:
Understanding the user
Developing an increment
Evaluating the increment
Feeding those results into a subsequent iteration
Explain the impact of changing constraints and design tradeoffs (e.g., hardware, user, security.) on system design.
KA Core 4
Evaluate architectural design approaches in the context of project goals.
Identify synchronization challenges as part of the user experience in distributed environments.
Evaluate and compare the privacy implications behind different input techniques for a given scenario.
Explain the rationale behind a UI design based on visual design principles.
Non-core 1
Evaluate the privacy implications within a VR/AR/MR scenario
HCI-SEP: Society, Ethics, and the Profession in SEP
CS Core 5
Universal and user-centered design D
Accountability D
Accessibility and inclusive design D
Evaluating the design E
System design A
KA Core 2
Participatory and inclusive design processes D
Evaluating the design: Implications and impacts of design: with respect to the environment material, society, security, privacy, ethics, and broader impacts (See also: SEC-Foundations, SEP- Privacy) E
Non-core 1
VR/AR/MR scenarios
Illustrative Learning Outcomes 5
CS Core 2
Conduct a user-centered design process that is integrated into a project.
Identify and critique the potential impacts of a design on society and relevant communities to address such concerns as sustainability, inclusivity, safety, security, privacy, harm, and disparate impact.
KA Core 2
Critique a recent example of a non-inclusive design choice, its societal implications, and propose potential design improvements.
Evaluating the design: Identify the implications and broader impacts of a given design.
Non-core 1
Evaluate the privacy implications within a VR/AR/MR scenario. user needs, and design challenges. friendly and meet the objectives of the project. of the audience, and HCI fundamentals. Creativity is required to blend these into something that solves the problem appropriately and elegantly. ● Basic statistics (MSF-Statistics) to support the evaluation and interpretation of results, including central tendency, variability, frequency distribution. Advanced Course: Usability Testing Prerequisites: M
Professional Dispositions 5
Adaptable: An HCI practitioner should be adaptable to address dynamic changes in technology, user needs, and design challenges.
Meticulous: An HCI practitioner should be meticulous in ensuring that their products are both user- friendly and meet the objectives of the project.
Empathetic: An HCI practitioner must demonstrate understanding of the user’s needs.
Team-oriented: The successful HCI practitioner should focus on the success of the team.
Inventive: An HCI practitioner should design solutions that are informed by past practice, the needs of the audience, and HCI fundamentals. Creativity is required to blend these into something that solves the problem appropriately and elegantly.
Mathematics Requirements 1
Required 1
Basic statistics (MSF-Statistics) to support the evaluation and interpretation of results, including central tendency, variability, frequency distribution.
Crosscutting 2 KAs

Present in all competency areas.

SEP – Society, Ethics, and the Profession 18 CS 14 KA 11 units
SEP-Context: Social Context 3h CS 2h KA
CS Core 4
Social implications (e.g., political and cultural ideologies) in a hyper-networked world where the capabilities and impact of social media, artificial intelligence, and computing in general are rapidly evolving. Ev
Impact of computing applications (e.g., social media, artificial intelligence applications) on individual well-being, and safety of all kinds (e.g., physical, emotional, economic). Ev
Consequences of involving computing technologies, particularly artificial intelligence, biometric technologies, and algorithmic decision-making systems, in civic life (e.g., facial recognition technology, biometric tags, resource distribution algorithms, policing software) and how human agency and oversight is crucial. Ev
How deficits in diversity and accessibility in computing affect society and what steps can be taken to improve equity in computing. Ev
KA Core 4
Growth and control of the internet, data, computing, and artificial intelligence Ev
Often referred to as the digital divide, differences in access to digital technology resources and its resulting ramifications for gender, class, ethnicity, geography, and/or developing countries including consideration of responsibility to those who might be less wealthy, under threat, or who would struggle to have their voices heard. Ev
Accessibility issues, including legal requirements such as Web Content Accessibility Guidelines (www.w3.org/TR/WCAG21) E
Context-aware computing E
Illustrative Learning Outcomes 11
CS Core 5
Describe the different ways that computer technology (networks, mobile computing, artificial intelligence) mediates social interaction at the personal and collective levels.
Identify developers’ assumptions and values embedded in hardware and software design especially as they pertain to usability for diverse populations including under-served and those with disabilities.
Interpret the social context of a given design and its implementation.
Analyze the efficacy of a given design and implementation using empirical data.
Understand the implications of technology use (e.g., social media) for different identities, cultures and communities.
KA Core 6
Describe the internet’s role in facilitating communication between citizens, governments, and each other.
Analyze the effects of reliance on computing in the implementation of democracy (e.g., delivery of social services, electronic voting).
Describe the impact of a lack of appropriate representation of people from historically minoritized populations in the computing profession (e.g., industry culture, product diversity).
Discuss the implications of context awareness in ubiquitous computing systems.
Express how access to the internet and computing technologies affect different societies.
Identify why/how internet access can be viewed as a human right.
SEP-Ethical-Analysis: Methods for Ethical Analysis 2h CS 1h KA
CS Core 4
Avoiding fallacies and misrepresentation in argumentation A
Ethical theories and decision-making (philosophical and social frameworks, e.g. [1]) Ev
Recognition of the role culture plays in our understanding, adoption, design, and use of computing technology Ev
Why ethics is important in computing, and how ethics is similar to, and different from, laws and social norms E
KA Core 5
Professional checklists A
Evaluation rubrics E
Stakeholder analysis E
Standpoint theory E
Introduction to ethical frameworks (e.g., consequentialism such as utilitarianism, non- consequentialism such as duty, rights, or justice, agent-centered such as virtue or feminism contractarianism, ethics of care) and their use for analyzing an ethical dilemma E
Illustrative Learning Outcomes 10
CS Core 6
Describe how a given cultural context impacts decision making.
Express the use of example and analogy in ethical argument.
Analyze (and avoid) basic logical fallacies in an argument.
Analyze an argument to identify premises and conclusion.
Evaluate how and why ethics is so important in computing and how it relates to cultural norms values, and law.
Justify a decision made on ethical grounds.
KA Core 4
Distinguish all stakeholder positions in relation to their cultural context in a given situation.
Analyze the potential for introducing or perpetuating ethical debt (deferred consideration of ethical impacts or implications) in technical decisions.
Discuss the advantages and disadvantages of traditional ethical frameworks.
Analyze ethical dilemmas related to the creation and use of technology from multiple perspectives using ethical frameworks.
SEP-Professional-Ethics: Professional Ethics 2h CS 2h KA
CS Core 7
Community values and the laws by which we live
The nature of being a professional including care, attention, discipline, fiduciary responsibility, and mentoring Ev
Keeping up to date as a computing professional in terms of familiarity, tools, skills, legal and professional frameworks as well as the ability and responsibility to self-assess and progress in the computing field Ev
Professional certification, codes of ethics, conduct, and practice, such as the ACM, IEEE, AAAI and other international societies A
Accountability, responsibility, and liability (e.g., software correctness, reliability and safety warranty, negligence, strict liability, ethical approaches to security vulnerability disclosures) including whether a product/service should be built, not just doing so because it is technically possible. A
Introduction to theories describing the human creation and use of technology including instrumentalism, sociology of technological systems, disability justice, neutrality thesis pragmatism, and decolonial models, including developing and using technology to right wrongs and do good E
Strategies for recognizing and reporting designs, systems, software, and professional conduct (or their outcomes) that may violate law or professional codes of ethics A
KA Core 8
The role of the computing professional and professional societies in public policy E
Maintaining awareness of consequences Ev
Ethical dissent and whistleblowing E
The relationship between regional culture and ethical dilemmas E
Dealing with harassment and discrimination E
Forms of professional credentialing E
Ergonomics and healthy computing environments E
Time-to-market and cost considerations versus quality professional standards E
Illustrative Learning Outcomes 14
CS Core 6
Identify ethical issues that arise in software design, development practices, and software deployment.
Discuss how to address ethical issues in specific situations.
Express the ethical responsibility of ensuring software correctness, reliability and safety including from where this responsibility arises (e.g., ACM/IEEE/AAAI Codes of Ethics, laws and regulations organizational policies).
Describe the mechanisms that typically exist for a professional to keep up to date in ethical matters.
Describe the strengths and weaknesses of relevant professional codes as expressions of being a professional and guides to decision-making.
Analyze a global computing issue, observing the role of professionals and government officials in managing this problem.
KA Core 8
Describe ways in which professionals and professional organizations may contribute to public policy.
Describe the consequences of inappropriate professional behavior.
Be familiar with whistleblowing and have access to knowledge to guide one through an incident.
Identify examples of how regional culture interplays with ethical dilemmas.
Describe forms of harassment and discrimination and avenues of assistance.
Assess various forms of professional credentialing.
State the relationship between ergonomics in computing environments and people’s health.
Describe issues associated with industries’ push to focus on time-to-market versus enforcing quality professional standards.
SEP-IP: Intellectual Property 1h CS 1h KA
CS Core 5
Intellectual property rights Ev
Intangible digital intellectual property (IDIP) Ev
Legal foundations for intellectual property protection Ev
Common software licenses (e.g., MIT, GPL and its variants, Apache, Mozilla, Creative Commons) E
Plagiarism and authorship E
KA Core 7
Philosophical foundations of intellectual property E
Forms of intellectual property (e.g., copyrights, patents, trade secrets, trademarks) and the rights they protect E
Limitations on copyright protections, including fair use and the first sale doctrine E
Intellectual property laws and treaties that impact the enforcement of copyrights E
Software piracy and technical methods for enforcing intellectual property rights, such as digital rights management and closed source software as a trade secret Ev
Moral and legal foundations of the open-source movement E
Systems that use others’ data (e.g., large language models) E
Illustrative Learning Outcomes 17
CS Core 8
Describe and critique legislation and precedent aimed at digital copyright infringements.
Identify contemporary examples of intangible digital intellectual property.
Select an appropriate software license for a given project.
Defend legal and ethical uses of copyrighted materials.
Interpret the intent and implementation of software licensing.
Discuss whether a use of copyrighted material is likely to be fair use.
Analyze the ethical issues inherent in various plagiarism detection mechanisms.
Identify multiple forms of plagiarism beyond verbatim copying of text or software (e.g., intentional paraphrasing, authorship misrepresentation, and improper attribution).
KA Core 9
Discuss the philosophical bases of intellectual property in an appropriate context (e.g., country).
Distinguish the conflicting issues involved in securing software patents.
Contrast the protections and obligations of copyright, patent, trade secret, and trademarks.
Describe the rationale for the legal protection of intellectual property in the appropriate context (e.g., country).
Analyze the use of copyrighted work under the concepts of fair use and the first sale doctrine.
Identify the goals of the open-source movement and its impact on fields beyond computing, such as the right-to-repair movement.
Summarize the global nature of software piracy.
Criticize the use of technical measures of digital rights management (e.g., encryption watermarking, copy restrictions, and region lockouts) from multiple stakeholder perspectives.
Discuss the nature of anti-circumvention laws in the context of copyright protection.
SEP-Privacy: Privacy and Civil Liberties 2h CS 1h KA
CS Core 4
Privacy implications of widespread data collection including but not limited to transactional databases, data warehouses, surveillance systems, cloud computing, and artificial intelligence E
Conceptions of anonymity, pseudonymity, and identity Ev
Technology-based solutions for privacy protection (e.g., end-to-end encryption and differential privacy) E
Civil liberties, privacy rights, and cultural differences E
KA Core 6
Philosophical and legal conceptions of the nature of privacy including the right to privacy E
Legal foundations of privacy protection in relevant jurisdictions (e.g., GDPR in the EU) Ev
Privacy legislation in areas of practice (e.g., HIPAA in the US, AI Act in the EU) E
Basic Principles of human-subjects research and principles beyond what the law requires (e.g. Belmont Report, UN Universal Declaration on Human Rights and how this relates to technology) E
Freedom of expression and its limitations E
User-generated content, content moderation, and liability A
Illustrative Learning Outcomes 8
CS Core 5
Evaluate solutions to privacy threats in transactional databases and data warehouses.
Describe the role of data collection in the implementation of pervasive surveillance systems (e.g. RFID, face recognition, toll collection, mobile computing).
Distinguish the concepts and goals of anonymity and pseudonymity.
Describe the ramifications of technology-based privacy protections, including differential privacy and end-to-end encryption.
Identify cultural differences regarding the nature and necessity of privacy and other civil liberties.
KA Core 3
Discuss the philosophical basis for the legal protection of personal privacy in an appropriate context (e.g., country).
Critique the intent, potential value, and implementation of various forms of privacy legislation and principles beyond what the law requires.
Identify strategies to enable appropriate freedom of expression.
SEP-Communication: Communication 2h CS 1h KA
CS Core 6
Oral, written, and electronic team and group communication
Technical communication materials (e.g., source code, and documentation, tutorials, reference materials, API documentation) A
Communicating with different stakeholders such as customers, leadership, or the public A
Team collaboration (including tools) and conflict resolution A
Accessibility and inclusivity requirements for addressing professional audiences D
Cultural competence in communication including considering the impact of difference in natural language D
KA Core 2
Tradeoffs in competing factors that affect communication channels and choices A
Communicating to solve problems or make recommendations in the workplace, such as raising ethical concerns or addressing accessibility issues A
Illustrative Learning Outcomes 9
CS Core 7
Understand the importance of writing concise and accurate technical documents following well- defined standards for format and for including appropriate tables, figures, and references.
Analyze written technical documentation for technical accuracy, concision, lack of ambiguity, and awareness of audience.
Compose and deliver an audience-aware, accessible, and organized formal presentation.
Plan interactions (e.g., virtual, face-to-face, shared documents) with others in ways that invite inclusive participation, model respectful consideration of others’ contributions, and explicitly value diversity of ideas.
Identify and describe qualities of effective communication (e.g., virtual, face-to-face, intragroup shared documents).
Understand how to communicate effectively and appropriately as a member of a team including conflict resolution techniques.
Discuss ways to influence performance and results in diverse and cross-cultural teams.
KA Core 2
Assess personal strengths and weaknesses to work remotely as part of a team drawing from diverse backgrounds and experiences.
Choose an appropriate way to communicate delicate ethical concerns.
SEP-Sustainability: Sustainability 1h CS 1h KA
CS Core 3
Environmental, social, and cultural impacts of implementation decisions (e.g., sustainability goals algorithmic bias/outcomes, economic viability, and resource consumption) Ev
Local/regional/global social and environmental impacts of computing systems and their use (e.g. carbon footprints, resource usage, e-waste) due to hardware (e.g., e-waste, data centers, rare element and resource utilization, recycling) and software (e.g., cloud-based services, blockchain AI model training and use). This includes everyday use of hardware (cheap hardware replaced frequently) and software (web-browsing, email, and other services with hidden/remote computational demands). Ev
Guidelines for sustainable design standards. Ev
KA Core 3
Systemic effects of complex computing technologies and phenomena (e.g., generative AI, data centers, social media, offshoring, remote work). Ev
Pervasive computing: Information processing that has been integrated into everyday objects and activities, such as smart energy systems, social networking, and feedback systems to promote sustainable behavior, transportation, environmental monitoring, citizen science and activism. Ev
How the sustainability of software systems is interdependent with social systems, including the knowledge and skills of its users, organizational processes and policies, and its societal context (e.g., market forces, government policies). E
Illustrative Learning Outcomes 8
CS Core 4
Identify ways to be a sustainable practitioner in a specific area or with a specific project.
Assess the environmental impacts of a given project’s deployment (e.g., energy consumption contribution to e-waste, impact of manufacturing).
Describe global social and environmental impacts of computer use and disposal.
List the sustainable effects of modern practices and activities (e.g., remote work, e-commerce cryptocurrencies, AI models, data centers).
KA Core 4
Describe the environmental impacts of design choices within the field of computing that relate to algorithm design, operating system design, networking design, database design, etc.
Analyze the social and environmental impacts of new system designs.
Design guidelines for sustainable IT design or deployment in areas such as smart energy systems social networking, transportation, agriculture, supply-chain systems, environmental monitoring, and citizen activism.
Assess computing applications in respect to environmental issues (e.g., energy, pollution, resource usage, recycling and reuse, food management and production).
SEP-History: Computing History 1h CS 1h KA
CS Core 2
The history of computing: hardware, software, and human/organizational. Ev
The role of history in the present including within different social contexts, and the relevance of this history on the future. Ev
KA Core 6
Age I (Pre-digital): Ancient analog computing (Stonehenge, Antikythera mechanism, Salisbury Cathedral clock, etc.), human-calculated number tables, Euclid, Lovelace, Babbage, Gödel Church, Turing, pre-electronic (electro-mechanical and mechanical) hardware E
Age II (Early modern computing): ENIAC, UNIVAC, Bombes (Bletchley Park and codebreakers) computer companies (e.g., IBM), mainframes, etc. E
Age III (PC era): PCs, modern computer hardware and software, Moore’s Law E
Age IV (Internet): Networking, internet architecture, browsers and their evolution, standards, born- on-the-internet companies, and services (e.g., Google, Amazon, Microsoft, etc.), distributed computing E
Age V (Mobile & Cloud): Mobile computing and smartphones, cloud computing and models thereof (e.g., SaaS), remote servers, security and privacy, social media E
Age VI (AI): Decision making systems, recommender systems, generative AI and other machine learning driven tools and technologies E
Illustrative Learning Outcomes 6
CS Core 2
Understand the relevance and impact of computing history on recent events, present context, and possible future outcomes, from more than one cultural perspective.
Discuss how perspectives held today have been shaped by history, and that alternative perspectives exist (e.g., fears of AI replacing human workers vs AI augmenting human work various views on Moore’s Law).
KA Core 4
Identify formative and consequential trends in the history of the computing field.
Identify the contributions of pioneering individuals or organizations (research labs, computer companies, government offices) in the computing field.
Discuss the historical context for important moments in history of computing, such as the move from vacuum tubes to transistors (TRADIC), early seminal operating systems (e.g., OS 360), Xerox PARC and the first Apple computer with a GUI, the creation of specific programming language paradigms, the first computer virus, the creation of the internet, the creation of the WWW, the dot com bubble, Y2K, the introduction of smartphones, etc.
Compare daily life before and after the advent of milestone developments (e.g., personal computers or the internet).
SEP-Economies: Economies of Computing 1h KA
KA Core 5
Economic models: regulated and unregulated, monopolies, network effects, and open market knowledge and attention economies
Pricing and deployment strategies: planned obsolescence, subscriptions, freemium, software licensing, open-source, free software, adware Ev
Impacts of differences in access to computing resources, and the effect of skilled labor supply and demand on the quality of computing products E
Automation, AI, and their effects on job markets, developers, and users Ev
Ethical concerns surrounding the attention economy and other economies of computing (e.g. informed consent, data collection, use of verbose legalese in user agreements) Ev
Illustrative Learning Outcomes 11
CS Core 6
Computer crimes, legal redress for computer criminals and impact on victims and society
Social engineering, computing-enabled fraud, identity theft and recovery from these
Cyber terrorism, criminal hacking, and hacktivism
Malware, viruses, worms
Attacks on critical infrastructure such as electrical grids and pipelines
Non-technical fundamentals of security (e.g., human engineering, policy, confidentiality)
KA Core 5
Summarize the social effects of economic models (e.g., the knowledge and attention economies).
Describe the differences and similarities of competing strategies (e.g., subscription vs freemium vs free).
Discuss examples of digital divides.
Understand the effects of automation and AI on society.
Understand the ethical implications of computing economies that rely on attention and data.
SEP-Security: Security Policies, Laws and Computer Crimes 2h CS 1h KA
CS Core 6
Computer crimes, legal redress for computer criminals and impact on victims and society E
Social engineering, computing-enabled fraud, identity theft and recovery from these E
Cyber terrorism, criminal hacking, and hacktivism E
Malware, viruses, worms E
Attacks on critical infrastructure such as electrical grids and pipelines E
Non-technical fundamentals of security (e.g., human engineering, policy, confidentiality) Ev
KA Core 4
Benefits and challenges of existing and proposed computer crime laws E
Security policies and the challenges of change and compliance E
Responsibility for security throughout the computing life cycle E
International and local laws and how they intersect E
Illustrative Learning Outcomes 8
CS Core 5
List classic examples of computer crimes and social engineering incidents with societal impact.
Identify issues with laws that apply to computer crimes.
Describe the motivation and ramifications of cyber terrorism, data theft, hacktivism, ransomware and other attacks.
Examine the ethical and legal issues surrounding the misuse of access and various breaches of security.
Discuss the professional's role in security and the tradeoffs and challenges involved.
KA Core 3
Investigate measures that can be taken by both individuals and organizations including governments to prevent or mitigate the undesirable effects of computer crimes.
Design a company-wide security policy, which includes procedures for managing passwords and employee monitoring.
Understand how legislation from one region may affect activities in another (e.g., how EU GDPR applies globally, when EU persons are involved).
SEP-DEIA: Diversity, Equity, Inclusion, and Accessibility 2h CS 2h KA
CS Core 6
How identity impacts and is impacted by computing technologies and environments (academic and professional) E
The benefits of diverse development teams and the impacts of teams that are not diverse A
Inclusive language and charged terminology, and why their use matters E
Inclusive behaviors and why they matter E
Designing and developing technology with accessibility in mind E
How computing professionals can influence and impact diversity, equity, inclusion and accessibility including but not only through the software they create E
KA Core 3
Experts and their practices that reflect the identities of the classroom and the world through practical DEIA principles E
Historic marginalization due to systemic social mechanisms, technological supremacy and global infrastructure challenges to diversity, equity, inclusion, and accessibility E
Cross-cultural differences in, and needs for, diversity, equity, inclusion, and accessibility E
Illustrative Learning Outcomes 23
CS Core 7
Define and distinguish equity, equality, diversity, inclusion, and accessibility.
Identify language, practices, and behaviors that may make someone feel included in a workplace and/or a team, and why is it relevant. Avoid charged terminology - see Words Matter (www.acm.org/diversity-inclusion/words-matter) – this includes identifying and accommodating users who are often excluded without thought and not considered at all.
Evaluate the accessibility of your classroom or lab. Evaluate the accessibility of your webpage. (See www.w3.org/WAI and www.w3.org/TR/WCAG21).
Demonstrate collegiality and respect when working with team members who do not share your
It is not enough to merely assign team projects. Faculty should prepare students for teamwork and monitor, mentor, and assess the effectiveness of their student teams throughout a project.
Compare the demographics of your institution’s computer science and STEM majors to the overall institutional demographics. If they differ, identify factors that contribute to inequitable access engagement, and achievement in computer science among marginalized groups. If they do not assess why not.
Identify developers’ assumptions and values embedded in hardware and software design especially as they pertain to usability by diverse populations.
Identify examples of the benefits that diverse teams can bring to software products, and how a lack of diversity has costs.
KA Core 16
Analyze the work of experts who reflect the identities of the classroom and the world.
Assess the impact of power and privilege in the computing profession as it relates to culture industry, products, and society.
Develop examples of systemic changes that could positively address diversity, equity, inclusion and accessibility in a familiar context (i.e., in an introductory computing course) and an unfamiliar context and when these might be different, or the same.
Compare the demographics of your institution to the overall community demographics. If they differ, identify factors that contribute to inequitable access, engagement, and achievement among marginalized groups. If they do not, assess why not. privileges, and motives to discover places where professional activity is not up to current standards. They must strive to understand both conscious and unconscious biases and continuously work to counteract them. professional manner, such as shifting from
https://cfiesler.medium.com/tech-ethics-curricula-a-collection-of-syllabi-3eedfb76be18 accessed March 12, 2024.
Tech Ethics Curricula; accessed March 12, 2024. ● Casey Fiesler. Tech Ethics Readings: A Spreadsheet of Readings Used to Teach Ethics in Technology Tech Ethics Class Readings; accessed March 12, 2024. ● Stanford Embedded EthiCS, Embedding Ethics in Computer Science. https://embeddedethics.stanford.edu/; accessed March 12, 2024. ● Jeremy, Weinstein, Rob Reich, and Mehran Sahami. System Error: Where Big Tech Went Wrong and How We Can Reboot. Hodder Paperbacks, 2023. ● Baecker, R. Computers in Soci
ACM/IEEE-CS Joint Curriculum Task Force. “Computing Curricula 1991.” (New York, USA: ACM Press and IEEE Computer Society Press, 1991).
ACM/IEEE-CS Interim Review Task Force. “Computer Science Curriculum 2008: An interim revision of CS 2001.” (New York, USA: ACM Press and IEEE Computer Society Press, 2008).
Randy Connolly. 2020. Why computing belongs within the social sciences. Commun. ACM 63, 8 (August 2020), 54–59. https://doi.org/10.1145/3383444
ACM Code of Ethics and Professional Conduct. www.acm.org/about/code-of-ethics
IEEE Code of Ethics. https://www.ieee.org/about/corporate/governance/p7-8.html; accessed March 12, 2024.
AAAI Code of Professional Ethics and Conduct. https://aaai.org/Conferences/code-of-ethics-and- conduct.php; accessed March 12, 2024.
Diversity, Equity, and Inclusion - Welcoming All to Computing https://www.acm.org/diversity- inclusion; accessed March 12, 2024.
Diversity, Equity & Inclusion at IEEE. https://www.ieee.org/about/diversity-index.html; accessed March 12, 2024.
AAAI Diversity Statement. https://aaai.org/about-aaai/ethics-and-diversity/#diversity-statement accessed March 12, 2024.
A Framework for Ethical Decision Making. https://www.scu.edu/ethics/ethics-resources/a- framework-for-ethical-decision-making/ accessed March 12, 2024.
Sustainability | United Nations. https://www.un.org/en/academic-impact/sustainability; accessed March 12, 2024.
What is Sustainability? https://www.sustain.ucla.edu/what-is-sustainability; accessed March 12 2024. Systems Fundamentals (SF) deprecated knowledge unit of Proximity and the deprecated knowledge unit of Virtualization and Isolation. deprecated unit of Evaluation and the deprecated unit of Quantitative Evaluation. deprecated some topics in the unit, and added topics from the deprecated unit of Cross-Layer Communications. as finite state machines. unit of Overview of Computer Systems. topics to th
Professional Dispositions 6
Critically Self-reflective: Students should be able to inspect their own actions, thoughts, biases, privileges, and motives to discover places where professional activity is not up to current standards. They must strive to understand both conscious and unconscious biases and continuously work to counteract them.
Responsive: Students must quickly and accurately respond to changes in the field and adapt in a professional manner, such as shifting from in-person office work to remote work at home. These shifts require rethinking one’s entire approach to what is considered “professional”. 286
Proactive: Students must be able to identify areas of importance (e.g., in accessibility and inclusion) and understand how to address them for a more professional working environment.
Culturally Competent: Students must prioritize cultural competence—the ability to work with people from cultures different from one’s own – by using inclusive language, watching for, and counteracting conscious and unconscious biases, and encouraging honest and open communication.
Advocative: Students must think, speak, and act in ways that foster and promote diversity, equity, inclusion, and accessibility in all ways including but not limited to teamwork, communication, and product development (hardware and software).
Responsible: Students must act responsibly in all areas of their work toward all users and stakeholders including the society at large, colleagues, and their profession in general.
MSF – Mathematical and Statistical Foundations 55 CS 145 KA 5 units
MSF-Discrete: Discrete Mathematics 29h CS 11h KA
CS Core 8
Sets, relations, functions, cardinality E
Recursive mathematical definitions E
Proof techniques (induction, proof by contradiction) E
Permutations, combinations, counting, pigeonhole principle E
Modular arithmetic E
Logic: truth tables, connectives (operators), inference rules, formulas, normal forms, simple predicate logic E
Graphs: basic definitions E
Order notation E
KA Core note
The recommended topics are the same between CS Core and KA Core, but with far more hours the KA Core can cover these topics in depth and might include more computing-related applications.
Illustrative Learning Outcomes 7
CS Core 7
Sets, Relations, and Functions, Cardinality
Explain with examples the basic terminology of functions, relations, and sets.
Perform the operations associated with sets, functions, and relations.
Relate practical examples to the appropriate set, function, or relation model, and interpret the associated operations and terminology in context.
Calculate the size of a finite set, including making use of the sum and product rules and inclusion-exclusion principle.
Explain the difference between finite, countable, and uncountable sets.
Recursive mathematical definitions
Apply recursive definitions of sequences or structures (e.g., Fibonacci numbers, linked lists parse trees, fractals).
Formulate inductive proofs of statements about recursive definitions.
Solve a variety of basic recurrence relations.
Analyze a problem to determine underlying recurrence relations.
Given a recursive/iterative code snippet, describe its underlying recurrence relation, hypothesize a closed form for the recurrence relation, and prove the hypothesis correct (usually, using induction).
Proof Techniques
Identify the proof technique used in a given proof.
Outline the basic structure of each proof technique (direct proof, proof by contradiction, and induction) described in this unit.
Apply each of the proof techniques (direct proof, proof by contradiction, and induction) correctly in the construction of a sound argument.
Determine which type of proof is best for a given problem.
Explain the parallels between ideas of mathematical and/or structural induction to recursion and recursively defined structures.
Explain the relationship between weak and strong induction and give examples of the appropriate use of each.
Permutations, combinations, and counting
Apply counting arguments, including sum and product rules, inclusion-exclusion principle, and arithmetic/geometric progressions.
Apply the pigeonhole principle in the context of a formal proof.
Compute permutations and combinations of a set, and interpret the meaning in the context of the specific application.
Map real-world applications to appropriate counting formalisms, such as determining the number of ways to arrange people around a table, subject to constraints on the seating arrangement, or the number of ways to determine certain hands in cards (e.g., a full house).
Modular arithmetic
Perform computations involving modular arithmetic.
Explain the notion of the greatest common divisor and apply Euclid's algorithm to compute it.
Logic
Convert logical statements from informal language to propositional and predicate logic expressions.
Apply formal methods of symbolic propositional and predicate logic, such as calculating validity of formulae, computing normal forms, or negating a logical statement.
Use the rules of inference to construct proofs in propositional and predicate logic.
Describe how symbolic logic can be used to model real-life situations or applications, including those arising in computing contexts such as software analysis (e.g., program correctness) database queries, and algorithms.
Apply formal logic proofs and/or informal, but rigorous, logical reasoning to real problems, such as predicting the behavior of software or solving problems such as puzzles.
Describe the strengths and limitations of propositional and predicate logic.
Explain what it means for a proof in propositional (or predicate) logic to be valid.
Graphs
Illustrate by example the basic terminology of graph theory, and some of the properties and special cases of types of graphs, including trees.
Demonstrate different traversal methods for trees and graphs, including pre-, post-, and in-order traversal of trees, along with breadth-first and depth-first search for graphs.
Model a variety of real-world problems in computer science using appropriate forms of graphs and trees, such as representing a network topology, the organization of a hierarchical file system, or a social network.
Show how concepts from graphs and trees appear in data structures, algorithms, proof techniques (structural induction), and counting.
MSF-Probability: Probability 11h CS 29h KA
CS Core 6
Basic notions: sample spaces, events, probability, conditional probability, Bayes’ rule
Discrete random variables and distributions A
Continuous random variables and distributions A
Expectation, variance, law of large numbers, central limit theorem D
Conditional distributions and expectation E
Applications to computing, the difference between probability and statistics (as subjects) E
KA Core note
The recommended topics are the same between CS Core and KA Core, but with far more hours the KA Core can cover these topics in depth and might include more computing-related applications.
Illustrative Learning Outcomes 10
CS Core 6
Basic notions: sample spaces, events, probability, conditional probability, Bayes’ rule
Translate a prose description of a probabilistic process into a formal setting of sample spaces outcome probabilities, and events.
Calculate the probability of simple events.
Determine whether two events are independent.
Compute conditional probabilities, including through applying (and explaining) Bayes' Rule.
Discrete random variables and distributions
Define the concept of a random variable and indicator random variable.
Determine whether two random variables are independent.
Identify common discrete distributions (e.g., uniform, Bernoulli, binomial, geometric).
Continuous random variables and distributions
Identify common continuous distributions (e.g., uniform, normal, exponential).
Calculate probabilities using cumulative density functions.
Expectation, variance, law of large numbers, central limit theorem
Define the concept of expectation and variance of a random variable.
Compute the expected value and variance of simple or common discrete/continuous random variables.
Explain the relevance of the law of large numbers and central limit theorem to probability calculations.
Conditional distributions and expectation
Explain the distinction between joint, marginal, and conditional distributions.
Compute marginal and conditional distributions from a full distribution, for both discrete and continuous random variables.
Compute conditional expectations for both discrete and continuous random variables.
Applications to computing
Describe how probability can be used to model real-life situations or applications, such as predictive text, hash tables, and quantum computation.
Apply probabilistic processes to solving computational problems, such as through randomized algorithms or in security contexts.
KA Core 4
Multivariate data: estimation, correlation, regression
Data transformation: dimension reduction, smoothing
Statistical models and algorithms
Hypothesis testing
MSF-Statistics: Statistics 10h CS 30h KA
CS Core 2
Basic definitions and concepts: populations, samples, measures of central tendency, variance D
Univariate data: point estimation, confidence intervals E
KA Core 4
Multivariate data: estimation, correlation, regression E
Data transformation: dimension reduction, smoothing E
Statistical models and algorithms E
Hypothesis testing E
Illustrative Learning Outcomes 6
CS Core 2
Basic definitions and concepts: populations, samples, measures of central tendency, variance
Create and interpret frequency tables.
Display data graphically and interpret graphs (e.g., histograms).
Recognize, describe, and calculate means, medians, quantiles (location of data).
Recognize, describe, and calculate variances, interquartile ranges (spread of data).
Univariate data: point estimation, confidence intervals
Formulate maximum likelihood estimation (in linear-Gaussian settings) as a least-squares problem.
Calculate maximum likelihood estimates.
Calculate maximum a posteriori estimates and make a connection with regularized least squares.
Compute confidence intervals as a measure of uncertainty.
KA Core 4
Sampling, bias, adequacy of samples, Bayesian vs frequentist interpretations
Multivariate data: estimation, correlation, regression
Formulate the multivariate maximum likelihood estimation problem as a least-squares problem.
Interpret the geometric properties of maximum likelihood estimates.
Derive and calculate the maximum likelihood solution for linear regression.
Derive and calculate the maximum a posteriori estimates for linear regression.
Implement both maximum likelihood and maximum a posteriori estimates in the context of a polynomial regression problem.
Formulate and understand the concept of data correlation (e.g., in 2D)
Data transformation: dimension reduction, smoothing
Formulate and derive Principal Component Analysis (PCA) as a least-squares problem.
Geometrically interpret PCA (when solved as a least-squares problem).
Describe when PCA works well (one can relate back to correlated data).
Geometrically interpret the linear regression solution (maximum likelihood).
Statistical models and algorithms
Apply PCA to dimensionality reduction problems.
Describe the tradeoff between compression and reconstruction power.
Apply linear regression to curve-fitting problems.
Explain the concept of overfitting.
Discuss and apply cross-validation in the context of overfitting and model selection (e.g., degree of polynomials in a regression context).
MSF-Linear: Linear Algebra 5h CS 35h KA
CS Core 1
Vectors: definitions, vector operations, geometric interpretation, angles: Matrices: definition, matrix operations, meaning of Ax=b. A
KA Core 7
Matrices, matrix-vector equation, geometric interpretation, geometric transformations with matrices E
Solving equations, row-reduction E
Linear independence, span, basis E
Orthogonality, projection, least-squares, orthogonal bases E
Linear combinations of polynomials, Bezier curves E
Eigenvectors and eigenvalues E
Applications to computer science: Principal Components Analysis (PCA), Singular Value Decomposition (SVD), page-rank, graphics E
Illustrative Learning Outcomes 8
CS Core 1
Vectors: definitions, vector operations, geometric interpretation, angles
Describe algebraic and geometric representations of vectors in Rn and their operations including addition, scalar multiplication, and dot product.
List properties of vectors in Rn.
Compute angles between vectors in Rn.
KA Core 7
Matrices, matrix-vector equation, geometric interpretation, geometric transformations with matrices
Perform common matrix operations, such as addition, scalar multiplication, multiplication, and transposition.
Relate a matrix to a homogeneous system of linear equations.
Recognize when two matrices can be multiplied.
Relate various matrix transformations to geometric illustrations.
Solving equations, row-reduction
Formulate, solve, apply, and interpret properties of linear systems.
Perform row operations on a matrix.
Relate an augmented matrix to a system of linear equations.
Solve linear systems of equations using the language of matrices.
Translate word problems into linear equations.
Perform Gaussian elimination.
Linear independence, span, basis
Define subspace of a vector space.
List examples of subspaces of a vector space.
Recognize and use basic properties of subspaces and vector spaces.
Determine if specific subsets of a vector space are subspaces.
Discuss the existence of a basis of an abstract vector space.
Describe coordinates of a vector relative to a given basis.
Determine a basis for and the dimension of a finite-dimensional space.
Discuss spanning sets for vectors in Rn.
Discuss linear independence for vectors in Rn.
Define the dimension of a vector space.
Orthogonality, projection, least-squares, orthogonal bases
Explain the Gram-Schmidt orthogonalization process.
Define orthogonal projections.
Define orthogonal complements.
Compute the orthogonal projection of a vector onto a subspace, given a basis for the subspace.
Explain how orthogonal projections relate to least square approximations.
Linear combinations of polynomials, Bezier curves
Identify polynomials as generalized vectors.
Explain linear combinations of basic polynomials.
Describe orthogonality for polynomials.
Distinguish between basic polynomials and Bernstein polynomials.
Apply Bernstein polynomials to Bezier curves.
Eigenvectors and eigenvalues
Find the eigenvalues and eigenvectors of a matrix.
Define eigenvalues and eigenvectors geometrically.
Use characteristic polynomials to compute eigenvalues and eigenvectors.
Use eigenspaces of matrices, when possible, to diagonalize a matrix.
Perform diagonalization of matrices.
Explain the significance of eigenvectors and eigenvalues.
Find the characteristic polynomial of a matrix.
Use eigenvectors to represent a linear transformation with respect to a particularly nice basis.
Applications to computer science: PCA, SVD, page-rank, graphics
Explain the geometric properties of PCA.
Relate PCA to dimensionality reduction.
Relate PCA to solving least-squares problems.
Relate PCA to solving eigenvector problems.
Apply PCA to reducing the dimensionality of a high-dimensional dataset (e.g., images).
Explain the page-rank algorithm and understand how it relates to eigenvector problems.
Explain the geometric differences between SVD and PCA.
Apply SVD to a concrete example (e.g., movie rankings).
MSF-Calculus: Calculus 40h KA
KA Core 9
Sequences, series, limits
Single-variable derivatives: definition, computation rules (chain rule etc.), derivatives of important functions, applications
Definition and computation rules
Derivatives of important functions
Applications
Single-variable integration: definition, computation rules, integrals of important functions, fundamental theorem of calculus, definite vs indefinite, applications (including in probability)
Definition and computation rules
Fundamental theorem of calculus
Definite vs indefinite integrals
Applications including probability
Parametric and polar representations
Taylor series
Multivariate calculus: partial derivatives, gradient, chain-rule, vector valued functions
Partial derivatives
Gradient
Chain rule
Vector valued functions
Optimization: convexity, global vs local minima, gradient descent, constrained optimization, and Lagrange multipliers
Convexity; global vs local minima
Gradient descent
Constrained optimization and Lagrange multipliers
Ordinary Differential Equations (ODEs): definition, Euler method, applications to simulation, Monte Carlo integration
Definition
Euler method
Applications to simulation
Monte Carlo integration
CS applications: gradient descent for machine learning, forward and inverse kinematics, applications of calculus to probability
Gradient descent for machine learning
Forward and inverse kinematics
Applications of calculus to probability
Illustrative Learning Outcomes 9
KA Core 9
Sequences, series, limits — Explain infinite sets vs sequences; formal definition of a limit; convergence and divergence; L’Hospital’s rule
Single-variable derivatives — Explain derivatives via limits; apply sum/product/quotient rules; compute elementary derivatives
Single-variable integration — Apply fundamental theorem of calculus; compute definite and indefinite integrals
Parametric and polar representations — Work with parametric and polar forms
Taylor series — Construct and apply Taylor series approximations
Multivariate calculus — Compute partial derivatives and gradients; apply chain rule
Optimization — Distinguish global vs local minima; apply gradient descent; use Lagrange multipliers
ODEs — Define ODEs; apply Euler method; relate to simulation
CS applications — Connect calculus to ML gradient descent, kinematics, and probability
Note: calculus topics listed are aligned with computer science goals rather than traditional calculus courses (e.g., only selected multivariate topics needed for machine learning).
Professional Dispositions 5
Growth mindset. Perhaps the most important of the dispositions, students should be persuaded: that anyone can learn mathematics, certainly the subset foundational to CS, and that success is not dependent on innate ability.
Practice mindset. Students should be educated about the nature of “doing” mathematics and: learning through practice with problems as opposed to merely listening or observing demonstrations in the classroom.
Deferred gratification. Most students are likely to learn at least some mathematics from: mathematics departments unfamiliar with computing applications; computing departments should acclimate the students to the notion of waiting to see computing applications. Many of the new growth areas such as AI or quantum computing can serve as motivation.
Persistence. Student perceptions are often driven by frustration with inability to solve hard: problems that they see some peers tackle seemingly effortlessly; computing departments should help promote the notion that eventual success through persistence is what matters.
Skepticism and inquiry. Students often look for “given formulas” as handed down by experts only: to be memorized and used. Yet, a theoretical mindset and, more broadly, a scientific one, should feature skepticism and a curiosity about how formulas are established.
Mathematics Requirements 2
Required 2
Algebra and numeracy notation, rough orders of magnitude, fractions, and decimals. factoring, algebraic manipulation of expressions with multiple variables.
Numeracy: numbers, operations, types of numbers, fluency with arithmetic, exponent
Algebra: rules of exponents, solving linear or quadratic equations with one or two variables
Precalculus
Coordinate geometry: distances between points, areas of common shapes.
Functions: function notation, drawing and interpreting graphs of functions.
Exponentials and logarithms: a general familiarity with the functions and their graphs.
Trigonometry: familiarity with basic trigonometric functions and the unit circle.