RFC: Uphold Curricular Categories

[ghost]

[waciumawanjohi]

An interesting proposal. Some notes:

• The CS2013 states, "CS2013 should provide the greatest flexibility in organizing topics into courses and curricula. Knowledge areas are not intended to describe specific courses. There are many novel, interesting, and effective ways to combine topics from the Body of Knowledge into courses." While we use the CS2013 as guidance for course selection and evaluation, the guidelines do not expect that students must complete all of a knowledge area at once.

• We do structure OSSU:CS to facilitate students working through the courses in order. "For simplicity, we recommend working through courses (especially Core CS) in order from top to bottom." Students often reach out for advice on course ordering, there is evidence that this prescriptive approach benefits students.

• The RFC states "The following curriculum structure its proposed to address the problem:" but what follows includes many changes to the curriculum that go beyond the curriculum's structure, courses have been added and courses have been removed. Opening an RFC on a single issue allows contributors to have focused conversations. If you would like to propose different courses for a topic, please break those out into separate RFCs.

[jehep]

Responses to your notes:

• Exactly, Knowledge Areas are not intended to describe specific courses, but that doesn't mean that a KA cannot be used as guided categories for courses. The courses in the KA row cover mostly Knowledge Units from that KA, but they also have KU from other KA, institutions do not publish courses from 100% one single KA, they incorporate topics from multiple Knowledge Areas since every KA is linked to each other. Thus when a student completes courses in a KA row he has completed most of the KA but not all of the KA at once like you inaccurately assumed.

• OSSU courses keep changing, its needed in order to respond to a rapidly changing field. Having stablished categories and knowledge areas will provide clear, implementable goals and flexibility. There are diverse successful approaches to introductory courses in computer science, many introductory courses in universities programs, OSSU and this proposed categorical organization focus on the topics in Software Development Fundamentals together with a subset of the topics in Programming Languages.

• Thanks for the suggestion, I added a note at the bottom of the RFC to avoid confusion, and focus on the single issue of the curriculum's categorical organization.

[waciumawanjohi]

• "Knowledge Areas are not intended to describe specific courses, but that doesn't mean that a KA cannot be used as guided categories for courses." With this in mind, can you elaborate on the problem that this RFC is targeting? The change you propose would rearrange all courses for students; what benefit will OSSU students gain from this disruption?

• "like you inaccurately assumed" This sentence fragment is unwelcoming. When I write a request for comments, I remember that I am asking others to take time and energy to give me feedback and to collaborate with me. I work hard to phrase my responses in a way that reflects that.

• "I added a note at the bottom of the RFC to avoid confusion" "Courses included are my personal preference and are meant as an example to fill the column, if the proposed organization by Category and Knowledge Area is accepted, the courses will be changed to match the specific ones that OSSU has made available at that time." Can you remove the information that is not relevant to the RFC from the RFC? When presenting something complicated, it is better to simplify it, rather than to tell reviewers to ignore the complication.

[jehep]

• A category and KA organization enjoys many benefits for students:

  1. The overview layer of the 3 dimensions tables present a representative summary of computing KA, providing a clearly articulated vision and sample high-level well understood consistent vocabulary for computing knowledge, rooted in the collective wisdom of the different computing communities, to enable work towards a plausible competency goal. (The amplified current curriculum with its irregular vocabulary in its outline is harder to digest, restraining work towards a feasible learning outcome. [Concepts that have 3 different levels of abstraction are presented in the same level e.g. the theory dimension is presented at the same layer as the math category and the security knowledge area.])
  2. Having 7 categories on a second layer is expansive and important for the curriculum constituents (e.g., students and prospective students) to contrast different types of computing programs to aid in their awareness of how one computing discipline (e.g., computer science) differs from another computing discipline (e.g., computer engineering). (Most of the computing categories are not present at all on the current curriculum, preventing learners from comparing disciplines.)
  3. Having an 18 granular KA layer makes the composite curriculum more adaptable, flexible and agile, to adjust in response to change and capture future trends and developments in courses from the industry. (It is easier to capture change with 18 KA than with the 8 multilevel subjects in 1 layer that OSSU currently has.)
  4. Disciplines interrelationships demonstrate that clear differences exist between the KA and that they all have distinguishing characteristics that are essential for their individual identities. (All the interrelationships between the KA are not present in the current OSSU layout.)
  5. Focusing on a category and a KA helps students see how they are progressing, and helps them highlight gaps in their knowledge. (Students can see they are progressing on the current OSSU curriculum but they cant spot the gaps of knowledge in each KA they are leaving behind.)
  6. With clear, specific, unadorned, and concise learning objectives that are measurable, students can identify where they require more emphasis lifting their confidence by showing them the existing knowledge they have to finish a task. (Learners cant put emphasis on a more granular KA since the curriculum is organized mostly in a higher level of abstraction.)
  7. The encyclopedia of computing knowledge that has accumulated with the efforts of the knowledge area, knowledge unit, learning outcome model over the last half-century provides a rich foundation upon which to develop computing competency catalogs for the various subdisciplines of computing education. (The absence of a KA organization provides a poor foundation for the current course catalog to be developed.)
  8. Adopting a coherent competency model to define the CS curricula will more clearly promote describing a computing competence in a practical context shifting the focus of curricula away from describing a body of knowledge in relation to a disciplinary area toward pragmatic student accomplishment. (This proposal has 3 levels of coherent organizational abstraction [Dimension, Category, and KA], currently OSSU has different levels of abstraction laid out in one single level, inhibiting the student to shift to a more pragmatic context.)

• My bad, I wasn't trying to be unwelcoming, like I said in the third bullet of my previous comment I'm thankful for your suggestions and I appreciate your feedback, but I have to point out that the statement you made "students must complete all of a knowledge area at once." is false. Even though courses in the KA row will mostly focus on that KA, completing courses on a KA row doesn't mean students have completed ALL of the KA at once. In fact, courses made by institutions are not one-to-one correspondence with a particular KA, published courses incorporate topics from multiple Knowledge Areas. Therefore after finishing a course in a KA row learners will still work on that KA on the following courses, inversely to how they worked on multiple KA when doing a course focused on a particular KA.

• Interesting opinion, but I don't believe showing examples of courses complicate things, on the contrary, I think it helps people visualize a solution, the same way examples in a math problem are relevant and benefit learners rather than make a complication. Besides the title is clear, the problem is short and concise, and the Proposal's statement is redundant and straightforward for ease of understanding of the single issue of the curriculum's categorical organization.

[wybrenl]

Interesting discussion, 2 thoughts and consequent alternative to consider

• Based on questions/discussions I see in discord my hypothesis is that topological order benefits students more than KAs.
• I do believe there is merit to showing how the OSSU curriculum maps to CS2013 KAs because it helps learners to understand the big ‘chunks’ in CS, and allows them to determine where the curriculum is rich on content and where potential gaps are.
• As an alternative to consider: add a mapping of the current OSSU courses to KAs on the OSSU page where curricular guidelines based on CS2013 are presented (https://github.com/ossu/computer-science/blob/master/CURRICULAR_GUIDELINES.md)

[jehep]

Great idea @wybrenl , adding the categorical organization table as a mapping section on the CURRICULAR_GUIDELINES.md will provide the benefits previously mentioned to learners, without being disruptive, which @waciumawanjohi was concerned about.

I made a prototype posted in the following comment, if it's approved ill change the courses to the current ones available in OSSU.

[jehep]

Curricular Guidelines

Our curricular guidelines are from the reports of the Association for Computing Machinery and the Institute of Electrical and Electronics Engineers: Curriculum Guidelines for Undergraduate Programs in Computer Science (CS2013) and Computing Curricula 2020: Paradigms for Global Computing Education (CC2020). These reports are the most recent in a series of such reports outlining the expectations of undergraduate degrees in Computer Science. The reports outline critical Knowledge Areas and topics within them. They drill down further to outline specific learning goals, going so far as to outline what concepts a student must be able to explain vs concepts a student must be able to demonstrate using in practice.

Organizations publishing

Association for Computing Machinery

The Association for Computing Machinery (ACM) is an international learned society for computing. It was founded in 1947 and is the world's largest scientific and educational computing society. The ACM is a non-profit professional membership group, with more than 100,000 members as of 2011.

Institute of Electrical and Electronics Engineers

The Institute of Electrical and Electronics Engineers (IEEE) is a professional association formed in 1963 from the amalgamation of the American Institute of Electrical Engineers and the Institute of Radio Engineers. As of 2018, it is the world's largest association of technical professionals with more than 423,000 members in over 160 countries around the world. Its objectives are the educational and technical advancement of electrical and electronic engineering, telecommunications, computer engineering, and allied disciplines.

Categorization

This summary of computer science Dimension/Category/Knowledge Area/Knowledge Unit/• Topic represents a well-understood and consistent vocabulary with composition at an exceedingly high level of abstraction as illustrations of plausible competency specifications.

Theory _{Develop effective ways to solve computing problems.}

Math	DS - Discrete Structures Sets, Relations, & Functions Sets Venn diagrams Union, intersection, complement Cartesian product Power sets Cardinality of finite sets Relations Reflexivity, symmetry, transitivity Equivalence relations, partial orders Functions Surjections, injections, bijections Inverses Composition Basic Logic Propositional logic (cross-reference: Propositional logic is also reviewed in IS/Knowledge Based Reasoning) Logical connectives Truth tables Normal forms (conjunctive and disjunctive) Validity of well-formed formula Propositional inference rules (concepts of modus ponens and modus tollens) Predicate logic Universal and existential quantification) Limitations of propositional and predicate logic (e.g., expressiveness issues) Proof Techniques Notions of implication, equivalence, converse, inverse, contrapositive, negation, and contradiction The structure of mathematical proofs Direct proofs Disproving by counterexample Proof by contradiction Induction over natural numbers Structural induction Weak and strong induction (i.e., First and Second Principle of Induction) Recursive mathematical definitions Well orderings Basics of Counting Counting arguments Set cardinality and counting Sum and product rule Inclusion-exclusion principle Arithmetic and geometric progressions) The pigeonhole principle Permutations and combinations Basic definitions Pascal’s identity The binomial theorem Solving recurrence relations An example of a simple recurrence relation, such as Fibonacci numbers Other examples, showing a variety of solutions Basic modular arithmetic Graphs & Trees Trees Properties Traversal strategies Undirected graphs Directed graphs Weighted graphs Spanning trees/forests Graph isomorphism Discrete Probability Finite probability space, events Axioms of probability and probability measures Conditional probability, Bayes’ theorem Independence Integer random variables (Bernoulli, binomial) Expectation, including Linearity of Expectation Variance Conditional Independence	Set, Log, Calc, Prob, CS & LA Prerequisites: high school
Soft. Fundam. Empirics Pattern, variaty, noise, entropy, channel capacity, redundacy, efficiency, codes	SDF - Softw. Development Fundam. Algorithms and Deisgn The concept and properties of algorithms Informal comparison of algorithm efficiency (e.g., operation counts) The role of algorithms in the problem-solving process Problem-solving strategies Iterative and recursive mathematical functions Iterative and recursive traversal of data structures Divide-and-conquer strategies Fundamental design concepts and principles Abstraction Program decomposition Encapsulation and information hiding Separation of behavior and implementation Fund. Prog. Concepts Basic syntax and semantics of a higher-level language Variables and primitive data types (e.g., numbers, characters, Booleans) Expressions and assignments Simple I/O including file I/O Conditional and iterative control structures Functions and parameter passing The concept of recursion Fund. Data Structures Arrays Records/structs (heterogeneous aggregates) Strings and string processing Abstract data types and their implementation Stacks Queues Priority queues Sets Maps References and aliasing Linked lists Strategies for choosing the appropriate data structure Development Methods Program comprehension Program correctness Types of errors (syntax, logic, run-time) The concept of a specification Defensive programming (e.g. secure coding, exception handling) Code reviews Testing fundamentals and test-case generation The role and the use of contracts, including pre- and post-conditions Unit testing Simple refactoring Modern programming environments Code search Programming using library components and their APIs Debugging strategies Documentation and program style	Py4e, Intro to CS & CS50 Prerequisites: none
	PL - Programming Languages Object-Oriented Programming Object-oriented design Decomposition into objects carrying state and having behavior Class-hierarchy design for modeling Definition of classes: fields, methods, and constructors Subclasses, inheritance, and method overriding Dynamic dispatch: definition of method-call Subtyping (cross-reference PL/Type Systems) Subtype polymorphism; implicit upcasts in typed languages Notion of behavioral replacement: subtypes acting like supertypes Relationship between subtyping and inheritance Object-oriented idioms for encapsulation Privacy and visibility of class members Interfaces revealing only method signatures Abstract base classes Using collection classes, iterators, and other common library components Funcitonal Programming Effect-free programming Function calls have no side effects, facilitating compositional reasoning Variables are immutable, preventing unexpected changes to program data by other code Data can be freely aliased or copied without introducing unintended effects from mutation Processing structured data (e.g., trees) via functions with cases for each data variant Associated language constructs such as discriminated unions and pattern-matching over them Functions defined over compound data in terms of functions applied to the constituent pieces First-class functions (taking, returning, and storing functions) Function closures (functions using variables in the enclosing lexical environment) 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 Currying and partial application Defining higher-order operations on aggregates, especially map, reduce/fold, and filter Event-Driven & Reawct. Prog. Events and event handlers Canonical uses such as GUIs, mobile devices, robots, servers Using a reactive framework Defining event handlers/listeners Main event loop not under event-handler-writer’s control Externally-generated events and program-generated events Separation of model, view, and controller Basic Type Systems A type as a set of values together with a set of operations Primitive types (e.g., numbers, Booleans) Compound types built from other types (e.g., records, unions, arrays, lists, functions, references) Association of types to variables, arguments, results, and fields Type safety and errors caused by using values inconsistently given their intended types Goals and limitations of static typing Eliminating some classes of errors without running the program Undecidability means static analysis must conservatively approximate program behavior Generic types (parametric polymorphism) Definition Use for generic libraries such as collections Comparison with ad hoc polymorphism (overloading) and subtype polymorphism Complementary benefits of static and dynamic typing 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 Avoid misuse of code vs. allow more code reuse Detect incomplete programs vs. allow incomplete programs to run Program Representation Programs that take (other) programs as input such as interpreters, compilers, type-checkers, documentation generators Abstract syntax trees; contrast with concrete syntax Data structures to represent code for execution, translation, or transmission Language Translation Interpretation vs. compilation to native code vs. compilation to portable intermediate representation Language translation pipeline: parsing, optional type-checking, translation, linking, execution Execution as native code or within a virtual machine Alternatives like dynamic loading and dynamic (or “just-in-time”) code generation Run-time representation of core language constructs such as objects (method tables) and first-class functions (closures) Run-time layout of memory: call-stack, heap, static data Implementing loops, recursion, and tail calls Memory management Manual memory management: allocating, de-allocating, and reusing heap memory Automated memory management: garbage collection as an automated technique using the notion of reachability	PL A B C, Compilers & Web Prerequisites: SDF
	CN - Computational Science Fundamentals Models as abstractions of situations Simulations as dynamic modeling Simulation techniques and tools, such as physical simulations, human-in-the-loop guided simulations, and virtual reality Foundational approaches to validating models (e.g., comparing a simulation’s output to real data or the output of another model) Presentation of results in a form relevant to the system being modeled	Computer Science Prerequisites: SDF DS
	AL - Algorithms & Complexity Basic Analysis Differences among best, expected, and worst case behaviors of an algorithm Asymptotic analysis of upper and expected complexity bounds Big O notation: formal definition Complexity classes, such as constant, logarithmic, linear, quadratic, and exponential Empirical measurements of performance Time and space trade-offs in algorithms Big O notation: use Little o, big omega and big theta notation Recurrence relations Analysis of iterative and recursive algorithms Some version of a Master Theorem Algorithmic Strategies Brute-force algorithms Greedy algorithms Divide-and-conquer (cross-reference SDF/Algorithms and Design/Problem-solving strategies) Recursive backtracking Dynamic Programming Branch-and-bound Heuristics Reduction: transform-and-conquer Fund. Data Structures & Alg Simple numerical algorithms, such as computing the average of a list of numbers, finding the min, max, and mode in a list, approximating the square root of a number, or finding the greatest common divisor Sequential and binary search algorithms Worst case quadratic sorting algorithms (selection, insertion) Worst or average case O(N log N) sorting algorithms (quicksort, heapsort, mergesort) Hash tables, including strategies for avoiding and resolving collisions Binary search trees Common operations on binary search trees such as select min, max, insert, delete, iterate over tree Graphs and graph algorithms Representations of graphs (e.g., adjacency list, adjacency matrix) Depth- and breadth-first traversals Heaps Graphs and graph algorithms Shortest-path algorithms (Dijkstra’s and Floyd’s algorithms) Minimum spanning tree (Prim’s and Kruskal’s algorithms) Pattern matching and string/text algorithms (e.g., substring matching, regular expression matching, longest common subsequence algorithms) Basic Autom. & Comp. Finite-state machines Regular expressions The halting problem Context-free grammars (cross-reference PL/Syntax Analysis) Introduction to the P and NP classes and the P vs. NP problem Introduction to the NP-complete class and exemplary NP-complete problems (e.g., SAT, Knapsack)	Algorithms Prerequisites: SDF DS CN
	OS - Operating Systems Overview of OS Role and purpose of the operating system Functionality of a typical operating system Mechanisms to support client-server models, hand-held devices Design issues (efficiency, robustness, flexibility, portability, security, compatibility) Influences of security, networking, multimedia, windowing systems Operating Systems Principles Structuring methods (monolithic, layered, modular, micro-kernel models) Abstractions, processes, and resources Concepts of application program interfaces (APIs) The evolution of hardware/software techniques and application needs Device organization Interrupts: methods and implementations Concept of user/system state and protection, transition to kernel mode Concurrency States and state diagrams (cross-reference SF/State and State Machines) Structures (ready list, process control blocks, and so forth) Dispatching and context switching The role of interrupts Managing atomic access to OS objects Implementing synchronization primitives Multiprocessor issues (spin-locks, reentrancy) (cross-reference SF/Parallelism) Scheduling and Dispatch Preemptive and non-preemptive scheduling (cross-reference SF/Resource Allocation and Scheduling, PD/Parallel Performance) Schedulers and policies (cross-reference SF/Resource Allocation and Scheduling, PD/Parallel Performance) Processes and threads (cross-reference SF/Computational paradigms) Deadlines and real-time issues Memory Management Review of physical memory and memory management hardware Working sets and thrashing Caching (cross-reference AR/Memory System Organization and Architecture) Security and Protection Overview of system security Policy/mechanism separation Security methods and devices Protection, access control, and authentication Backups	Intro & Power User Prerequisites: SDF
	GV - Graphics & Visualization Fundamental Concepts Media applications including user interfaces, audio and video editing, game engines, cad, visualization, virtual reality Digitization of analog data, resolution, and the limits of human perception, e.g., pixels for visual display, dots for laser printers, and samples for audio (HCI/Foundations) Use of standard APIs for the construction of UIs and display of standard media formats (see HCI/GUI construction) Standard media formats, including lossless and lossy formats Additive and subtractive color models (CMYK and RGB) and why these provide a range of colors Tradeoffs between storing data and re-computing data as embodied by vector and raster representations of images Animation as a sequence of still images	Computer Graphics Prerequisites: SDF DS

Systems _{Devise ways to use computers.}

Sys. Modeling Pragmatics Intensions, communications, conversations, negotiations	IM - Information Management Info. Management Concepts Information systems as socio-technical systems Basic information storage and retrieval (IS&R) concepts Information capture and representation Supporting human needs: searching, retrieving, linking, browsing, navigating Information management applications Declarative and navigational queries, use of links Analysis and indexing Quality issues: reliability, scalability, efficiency, and effectiveness Database Systems Approaches to and evolution of database systems Components of database systems Design of core DBMS functions (e.g., query mechanisms, transaction management, buffer management, access methods) Database architecture and data independence Use of a declarative query language Systems supporting structured and/or stream content Data Modeling Data modeling Conceptual models (e.g., entity-relationship, UML diagrams) Spreadsheet models Relational data models Object-oriented models (cross-reference PL/Object-Oriented Programming) Semi-structured data model (expressed using DTD or XML Schema, for example)	Databases & Data Analytics Prerequisites: none
Hardware Phyisical Signals, traces, physical distinctions, hardware, component density, speed, economics	AR - Architecture & Organization Digital Logic & Systems Overview and history of computer architecture Combinational vs. sequential logic/Field programmable gate arrays as a fundamental combinational + sequential logic building block Multiple representations/layers of interpretation (hardware is just another layer) Computer-aided design tools that process hardware and architectural representations Register transfer notation/Hardware Description Language (Verilog/VHDL) Physical constraints (gate delays, fan-in, fan-out, energy/power) Machine-level rep. of data Bits, bytes, and words Numeric data representation and number bases Fixed- and floating-point systems Signed and twos-complement representations Representation of non-numeric data (character codes, graphical data) Representation of records and arrays Assembly level mach. org. Basic organization of the von Neumann machine Control unit; instruction fetch, decode, and execution Instruction sets and types (data manipulation, control, I/O) Assembly/machine language programming Instruction formats Addressing modes Subroutine call and return mechanisms (cross-reference PL/Language Translation and Execution) I/O and interrupts Heap vs. Static vs. Stack vs. Code segments Shared memory multiprocessors/multicore organization Introduction to SIMD vs. MIMD and the Flynn Taxonomy Memory org. and arch. Storage systems and their technology Memory hierarchy: importance of temporal and spatial locality Main memory organization and operations Latency, cycle time, bandwidth, and interleaving Cache memories (address mapping, block size, replacement and store policy) Multiprocessor cache consistency/Using the memory system for inter-core synchronization/atomic memory operations Virtual memory (page table, TLB) Fault handling and reliability Error coding, data compression, and data integrity (cross-reference SF/Reliability through Redundancy) Interfacing and comm. I/O fundamentals: handshaking, buffering, programmed I/O, interrupt-driven I/O Interrupt structures: vectored and prioritized, interrupt acknowledgment External storage, physical organization, and drives Buses: bus protocols, arbitration, direct-memory access (DMA) Introduction to networks: communications networks as another layer of remote access Multimedia support RAID architectures	Circuits, Architecture & Org. Prerequisites: SDF
Sys. Infrast. Semantics Meanings, propositions, validity, truth, signification, denotations	SF - Systems Fundamentals Computational Paradigms 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 Application-level sequential processing: single thread Simple application-level parallel processing: request level (web services/client-server/distributed), single thread per server, multiple threads with multiple servers Basic concept of pipelining, overlapped processing stages Basic concept of scaling: going faster vs. handling larger problems Cross-layer Communications Programming abstractions, interfaces, use of libraries Distinction between Application and OS services, Remote Procedure Call Application-Virtual Machine Interaction Reliability State-State Trans-State Mach. Digital vs. Analog/Discrete vs. Continuous Systems Simple logic gates, logical expressions, Boolean logic simplification Clocks, State, Sequencing Combinational Logic, Sequential Logic, Registers, Memories Computers and Network Protocols as examples of state machines Parallelism Sequential vs. parallel processing Parallel programming vs. concurrent programming Request parallelism vs. Task parallelism Client-Server/Web Services, Thread (Fork-Join), Pipelining Multicore architectures and hardware support for synchronization Evaluation Performance figures of merit Workloads and representative benchmarks, and methods of collecting and analyzing performance figures of merit CPI (Cycles per Instruction) equation as tool for understanding tradeoffs in the design of instruction sets, processor pipelines, and memory system organizations. Amdahl’s Law: the part of the computation that cannot be sped up limits the effect of the parts that can Resource Alloc. & Sched. Kinds of resources (e.g., processor share, memory, disk, net bandwidth) Kinds of scheduling (e.g., first-come, priority) Advantages of fair scheduling, preemptive scheduling Proximity Speed of light and computers (one foot per nanosecond vs. one GHz clocks) Latencies in computer systems: memory vs. disk latencies vs. across the network memory Caches and the effects of spatial and temporal locality on performance in processors and systems Caches and cache coherency in databases, operating systems, distributed systems, and computer architecture Introduction into the processor memory hierarchy and the formula for average memory access time Virtualization & Isolation Rationale for protection and predictable performance Levels of indirection, illustrated by virtual memory for managing physical memory resources Methods for implementing virtual memory and virtual machines Reliab. through Redundancy Distinction between bugs and faults Redundancy through check and retry Redundancy through redundant encoding (error correcting codes, CRC, FEC) Duplication/mirroring/replicas Other approaches to fault tolerance and availability	Nand to Tetris I & II Prerequisites: SDF AR
	NC - Networking & Communications Introduction Organization of the Internet (Internet Service Providers, Content Providers, etc.) Switching techniques (e.g., circuit, packet) Physical pieces of a network, including hosts, routers, switches, ISPs, wireless, LAN, access point, and firewalls Layering principles (encapsulation, multiplexing) Roles of the different layers (application, transport, network, datalink, physical) Network Applications Naming and address schemes (DNS, IP addresses, Uniform Resource Identifiers, etc.) Distributed applications (client/server, peer-to-peer, cloud, etc.) HTTP as an application layer protocol Multiplexing with TCP and UDP Socket APIs Reliable Data Delivery Error control (retransmission techniques, timers) Flow control (acknowledgements, sliding window) Performance issues (pipelining) TCP Routing and Forwarding Routing versus forwarding Static routing Internet Protocol (IP) Scalability issues (hierarchical addressing) Local Area Networks Multiple Access Problem Common approaches to multiple access (exponential-backoff, time division multiplexing, etc) Local Area Networks Ethernet Switching Resource Allocation Need for resource allocation Fixed allocation (TDM, FDM, WDM) versus dynamic allocation End-to-end versus network assisted approaches Fairness Principles of congestion control Approaches to Congestion (e.g., Content Distribution Networks) Mobility Principles of cellular networks 802.11 networks Issues in supporting mobile nodes (home agents)	Bits and Bytes Networking Prerequisites: none
	IS - Intelligent Systems Fundamental Issues Overview of AI problems, examples of successful recent AI applications What is intelligent behavior? The Turing test Rational versus non-rational reasoning Problem characteristics Fully versus partially observable Single versus multi-agent Deterministic versus stochastic Static versus dynamic Discrete versus continuous Nature of agents Autonomous versus semi-autonomous Reflexive, goal-based, and utility-based The importance of perception and environmental interactions Philosophical and ethical issues. [elective] Basic Search Strategies Problem spaces (states, goals and operators), problem solving by search Factored representation (factoring state into variables) Uninformed search (breadth-first, depth-first, depth-first with iterative deepening) Heuristics and informed search (hill-climbing, generic best-first, A*) Space and time efficiency of search Two-player games (introduction to minimax search) Constraint satisfaction (backtracking and local search methods) Basic Knowledge Rep. Review of propositional and predicate logic (cross-reference DS/Basic Logic) Resolution and theorem proving (propositional logic only) Forward chaining, backward chaining Review of probabilistic reasoning, Bayes theorem (cross-reference with DS/Discrete Probability) Basic Machine Learning Definition and examples of broad variety of machine learning tasks, including classification Inductive learning Simple statistical-based learning, such as Naive Bayesian Classifier, decision trees The over-fitting problem Measuring classifier accuracy	Artif. Intel. & Machine Learn. Prerequisites: SDF DS
	PD - Parallel & Distribut. Comp. Parallelism Fundamentals Multiple simultaneous computations Goals of parallelism (e.g., throughput) versus concurrency (e.g., controlling access to shared resources) Parallelism, communication, and coordination Programming constructs for coordinating multiple simultaneous computations Need for synchronization Programming errors not found in sequential programming Data races (simultaneous read/write or write/write of shared state) Higher-level races (interleavings violating program intention, undesired non-determinism) Lack of liveness/progress (deadlock, starvation) Parallel Decomposotion Need for communication and coordination/synchronization Independence and partitioning Basic knowledge of parallel decomposition concepts (cross-reference SF/System Support for Parallelism) Task-based decomposition Implementation strategies such as threads Data-parallel decomposition Strategies such as SIMD and MapReduce Actors and reactive processes (e.g., request handlers) Comm. & Coord. Shared Memory Consistency, and its role in programming language guarantees for data-race-free programs Message passing Point-to-point versus multicast (or event-based) messages Blocking versus non-blocking styles for sending and receiving messages Message buffering (cross-reference PF/Fundamental Data Structures/Queues) Atomicity Specifying and testing atomicity and safety requirements Granularity of atomic accesses and updates, and the use of constructs such as critical sections or transactions to describe them Mutual Exclusion using locks, semaphores, monitors, or related constructs Potential for liveness failures and deadlock (causes, conditions, prevention) Composition Composing larger granularity atomic actions using synchronization Transactions, including optimistic and conservative approaches Parallel Algorithms Critical paths, work and span, and the relation to Amdahl’s law (cross-reference SF/Performance) Speed-up and scalability Naturally (embarrassingly) parallel algorithms Parallel algorithmic patterns (divide-and-conquer, map and reduce, master-workers, others) Specific algorithms (e.g., parallel MergeSort) Parallel Architecture Multicore processors Shared vs. distributed memory Symmetric multiprocessing (SMP) SIMD, vector processing	Parallel Programming Prerequisites: SDF PL DS
	IAS - Inf. Assurance & Security Fund. Concepts in Security CIA (Confidentiality, Integrity, Availability) Concepts of risk, threats, vulnerabilities, and attack vectors (cros- reference SE/Software Project Management/Risk) Authentication and authorization, access control (mandatory vs. discretionary) Concept of trust and trustworthiness Ethics (responsible disclosure). (cross-reference SP/Professional Ethics/Accountability, responsibility and liability) Principles of Secure Design Least privilege and isolation (cross-reference OS/Security and Protection/Policy/mechanism separation and SF/Virtualization and Isolation/Rationale for protection and predictable performance and PL/Language Translation and Execution/Memory management) Fail-safe defaults (cross-reference SE/Software Construction/ Coding practices: techniques, idioms/patterns, mechanisms for building quality programs and SDF/Development Methods/Programming correctness) Open design (cross-reference SE/Software Evolution/ Software development in the context of large, preexisting code bases) End-to-end security (cross-reference SF/Reliability through Redundancy/ How errors increase the longer the distance between the communicating entities; the end-to-end principle) Defense in depth (e.g., defensive programming, layered defense) Security by design (cross-reference SE/Software Design/System design principles) Tensions between security and other design goals Complete mediation Use of vetted security components Economy of mechanism (reducing trusted computing base, minimize attack surface) (cross-reference SE/Software Design/System design principles and SE/Software Construction/Development context: “green field” vs. existing code base) Usable security (cross-reference HCI/Foundations/Cognitive models that inform interaction design) Security composability Prevention, detection, and deterrence (cross-reference SF/Reliability through Redundancy/Distinction between bugs and faults and NC/Reliable Data Delivery/Error control and NC/Reliable Data Delivery/Flow control) Defensive Programming Input validation and data sanitization (cross-reference SDF/Development Methods/Program Correctness) Choice of programming language and type-safe languages Examples of input validation and data sanitization errors (cross-reference SDF/Development Methods/Program Correctness and SE/Software Construction/Coding Practices) Buffer overflows Integer errors SQL injection XSS vulnerability Race conditions (cross-reference SF/Parallelism/Parallel programming and PD/Parallel Architecture/Shared vs. distributed memory and PD/Communication and Coordination/Shared Memory and PD/Parallelism Fundamentals/Programming errors not found in sequential programming) Correct handling of exceptions and unexpected behaviors (cross-reference SDF/Development Methods/program correctness) Correct usage of third-party components (cross-reference SDF/Development Methods/program correctness and Operating System Principles/Concepts of application program interfaces (APIs) Effectively deploying security updates (cross-reference OS/Security and Protection/Security methods and devices) Threats and Attacks Attacker goals, capabilities, and motivations (such as underground economy, digital espionage, cyberwarfare, insider threats, hacktivism, advanced persistent threats) Examples of malware (e.g., viruses, worms, spyware, botnets, Trojan horses or rootkits) Denial of Service (DoS) and Distributed Denial of Service (DDoS) Social engineering (e.g., phishing) (cross-reference SP/Social Context/Social implications of computing in a networked world and HCI/Designing Interaction/Handling human/system failure) Network Security Network specific threats and attack types (e.g., denial of service, spoofing, sniffing and traffic redirection, man-in-the-middle, message integrity attacks, routing attacks, and traffic analysis) Use of cryptography for data and network security Architectures for secure networks (e.g., secure channels, secure routing protocols, secure DNS, VPNs, anonymous communication protocols, isolation) Defense mechanisms and countermeasures (e.g., network monitoring, intrusion detection, firewalls, spoofing and DoS protection, honeypots, tracebacks) Cryptography Basic Cryptography Terminology covering notions pertaining to the different (communication) partners, secure/unsecure channel, attackers and their capabilities, encryption, decryption, keys and their characteristics, signatures Cipher types (e.g., Caesar cipher, affine cipher) together with typical attack methods such as frequency analysis Public Key Infrastructure support for digital signature and encryption and its challenges	Secure Coding Practices Prerequisites: SDF

Applications _{Design and implement software.}

Users & Org. Social World Beliefs, expectations, functions, commitments, contracts, law, culture	SP - Social and Prof. Practice Social Context Social implications of computing in a networked world (cross-reference HCI/Foundations/social models; IAS/Fundamental Concepts/social issues) Impact of social media on individualism, collectivism and culture. Growth and control of the Internet (cross-reference NC/Introduction/organization of the Internet) 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 underdeveloped countries. Accessibility issues, including legal requirements Context-aware computing (cross-reference HCI/Design for non-mouse interfaces/ ubiquitous and contextaware) Analytical Tools Ethical argumentation Ethical theories and decision-making Moral assumptions and values Professional Ethics Community values and the laws by which we live The nature of professionalism including care, attention and discipline, fiduciary responsibility, and mentoring Keeping up-to-date as a computing professional in terms of familiarity, tools, skills, legal and professional framework as well as the ability to self-assess and progress in the computing field Professional certification, codes of ethics, conduct, and practice, such as the ACM/IEEE-CS, SE, AITP, IFIP and international societies (cross-reference IAS/Fundamental Concepts/ethical issues) Accountability, responsibility and liability (e.g. software correctness, reliability and safety, as well as ethical confidentiality of cybersecurity professionals) The role of the computing professional in public policy Maintaining awareness of consequences Ethical dissent and whistle-blowing The relationship between regional culture and ethical dilemmas Dealing with harassment and discrimination Forms of professional credentialing Acceptable use policies for computing in the workplace Ergonomics and healthy computing environments Time to market and cost considerations versus quality professional standards Intellectual Property Philosophical foundations of intellectual property Intellectual property rights (cross-reference IM/Information Storage and Retrieval/intellectual property and protection) Intangible digital intellectual property (IDIP) Legal foundations for intellectual property protection Digital rights management Copyrights, patents, trade secrets, trademarks Plagiarism Privacy & Civil Liberties Philosophical foundations of privacy rights (cross-reference IS/Fundamental Issues/philosophical issues) Legal foundations of privacy protection Privacy implications of widespread data collection for transactional databases, data warehouses, surveillance systems, and cloud computing (cross-reference IM/Database Systems/data independence; IM/Data Mining/data cleaning) Ramifications of differential privacy Technology-based solutions for privacy protection (cross-reference IAS/Threats and Attacks/attacks on privacy and anonymity) Prof. Communication Reading, understanding and summarizing technical material, including source code and documentation Writing effective technical documentation and materials Dynamics of oral, written, and electronic team and group communication (cross-reference HCI/Collaboration and Communication/group communication; SE/Project Management/team participation) Communicating professionally with stakeholders Utilizing collaboration tools (cross-reference HCI/Collaboration and Communication/online communities; IS/Agents/collaborative agents) Sustainability Being a sustainable practitioner by taking into consideration cultural and environmental impacts of implementation decisions (e.g. organizational policies, economic viability, and resource consumption). Explore global social and environmental impacts of computer use and disposal (e-waste) Environmental impacts of design choices in specific areas such as algorithms, operating systems, networks, databases, or human-computer interaction (cross-reference SE/Software Evaluation/software evolution; HCI/Design-Oriented HCI/sustainability)	Project Management Prerequisites: none
Software Dev. Syntactics Formal structure, language, logic, data, records, deduction, software, files	SE - Software Engineering Software Process Systems level considerations, i.e., the interaction of software with its intended environment (cross-reference IAS/Secure Software Engineering) Introduction to software process models (e.g., waterfall, incremental, agile) Activities within software lifecycles Programming in the large vs. individual programming Evaluation of software process models Software Project Manage. Team participation Team processes including responsibilities for tasks, meeting structure, and work schedule Roles and responsibilities in a software team Team conflict resolution Risks associated with virtual teams (communication, perception, structure) Effort Estimation (at the personal level) Risk (cross reference IAS/Secure Software Engineering) The role of risk in the lifecycle Risk categories including security, safety, market, financial, technology, people, quality, structure and process Tools and Environments Software configuration management and version control Release management Requirements analysis and design modeling tools Testing tools including static and dynamic analysis tools Programming environments that automate parts of program construction processes (e.g., automated builds) Continuous integration Tool integration concepts and mechanisms Requirements Engineering Describing functional requirements using, for example, use cases or users stories Properties of requirements including consistency, validity, completeness, and feasibility Software requirements elicitation Describing system data using, for example, class diagrams or entity-relationship diagrams Non-functional requirements and their relationship to software quality (cross-reference IAS/Secure Software Engineering) Evaluation and use of requirements specifications Software Design System design principles: levels of abstraction (architectural design and detailed design), separation of concerns, information hiding, coupling and cohesion, re-use of standard structures Design Paradigms such as structured design (top-down functional decomposition), object-oriented analysis and design, event driven design, component-level design, data-structured centered, aspect oriented, function oriented, service oriented Structural and behavioral models of software designs Design patterns Relationships between requirements and designs: transformation of models, design of contracts, invariants Software architecture concepts and standard architectures (e.g. client-server, n-layer, transform centered, pipes-and-filters) Refactoring designs using design patterns The use of components in design: component selection, design, adaptation and assembly of components, components and patterns, components and objects (for example, building a GUI using a standard widget set) Software Construction Coding practices: techniques, idioms/patterns, mechanisms for building quality programs (cross-reference IAS/Defensive Programming; SDF/Development Methods) Defensive coding practices Secure coding practices Using exception handling mechanisms to make programs more robust, fault-tolerant Coding standards Integration strategies Development context: “green field” vs. existing code base Change impact analysis Change actualization Software Verif. & Valid Verification and validation concepts Inspections, reviews, audits Testing types, including human computer interface, usability, reliability, security, conformance to specification (cross-reference IAS/Secure Software Engineering) Testing fundamentals (cross-reference SDF/Development Methods) Unit, integration, validation, and system testing Test plan creation and test case generation Black-box and white-box testing techniques Regression testing and test automation Defect tracking Limitations of testing in particular domains, such as parallel or safety-critical systems Software Evolution Software development in the context of large, pre-existing code bases Software change Concerns and concern location Refactoring Software evolution Characteristics of maintainable software Reengineering systems Software reuse Code segments Libraries and frameworks Components Product lines Software Reliability Software reliability engineering concepts Software reliability, system reliability and failure behavior (cross-reference SF/Reliability Through Redundancy) Fault lifecycle concepts and techniques	SDev., Design, Debug. & Test Prerequisites: SDF PL
	HCI - Human-Computer Interaction Foundations Contexts for HCI (anything with a user interface, e.g., webpage, business applications, mobile applications, and games) Processes for user-centered development, e.g., early focus on users, empirical testing, iterative design Different measures for evaluation, e.g., utility, efficiency, learnability, user satisfaction Usability heuristics and the principles of usability testing Physical capabilities that inform interaction design, e.g., color perception, ergonomics Cognitive models that inform interaction design, e.g., attention, perception and recognition, movement, and memory; gulfs of expectation and execution Social models that inform interaction design, e.g., culture, communication, networks and organizations Principles of good design and good designers; engineering tradeoffs Accessibility, e.g., interfaces for differently-abled populations (e.g., blind, motion-impaired) Interfaces for differently-aged population groups (e.g., children, 80+) Designing Interaction Principles of graphical user interfaces (GUIs) Elements of visual design (layout, color, fonts, labeling) Task analysis, including qualitative aspects of generating task analytic models Low-fidelity (paper) prototyping Quantitative evaluation techniques, e.g., keystroke-level evaluation Help and documentation Handling human/system failure User interface standards	(UX) User Experience Design Prerequisites: none
	PBD - Platform-based Development Introduction Overview of platforms (e.g., Web, Mobile, Game, Industrial) Programming via platform-specific APIs Overview of Platform Languages (e.g., Objective C, HTML5) Programming under platform constraints Web Platforms Web programming languages (e.g., HTML5, Java Script, PHP, CSS) Web platform constraints Software as a Service (SaaS) Web standards Mobile Platforms Mobile programming languages Challenges with mobility and wireless communication Location-aware applications Performance / power tradeoffs Mobile platform constraints Emerging technologies Industrial Platforms Types of Industrial Platforms (e.g., Mathematic, Robotic, Industrial Control) Robotic software and its architecture Domain-specific languages Industrial platform constraints Game Platforms Types of game platforms (e.g., XBox, Wii, PlayStation) Game platform languages (e.g., C++, Java, Lua, Python) Game platform constraints	The Odin Project Prerequisites: SDF PL AL

[bradleygrant]

It appears to me that the whole entire approach to the redesign is to arrange it in such a way that it makes it plain to see we've checked all the boxes in CS2013. That's a good quality control check but it does not improve the curriculum.

OSSU isn't a mere course listing. It's a curriculum. Curricula have opinions not only on what is presented but also when it is presented.

So the problem with this approach is there's no direction on how to take the courses or in what order. It's not reasonable to assume that one will deep-dive all of the Systems courses before taking any of the Applications courses. Just like there's no reason one needs to do all the Math courses before doing any of the Science courses in a Physics degree, for example.

I think the best use of a deep-dive such as the one you've presented is as an internal auditing and course selection tool. Not as a front-facing curriculum update or curriculum supplement.

The good news is there has been need for an internal auditing and course selection tool. A course competencies matrix has been envisioned for some time, but hasn't been executed as of yet. Would you be willing to consider assisting with the development of such a tool?

[jehep]

• @bradleygrant I agree, it should not be a front-facing curriculum, the current amplified topological arrangement can stay, I'm not proposing to remove it. But why not add another point of view? It's like having a To-do List with the option of viewing it as a Kanban Board too. A powerful perspective that would only benefit learners rather than hinder them.
• Besides exactly as you mentioned, having it directly on CURRICULAR_GUIDELINES.md is the perfect tool to make it plain to see if all the boxes in CS2013 and CC2020 are checked, also good for quality control.

[waciumawanjohi]

I should note that CS2013.org has a ready made spreadsheet for evaluating curriculum coverage. As Bradley Grant states, OSSU should carry out an evaluation of the curriculum against this spreadsheet. I've had some ideas knocking about regarding how to approach the effort. It's not a trivial undertaking.

Having such an effort live on the curricular guidelines page makes sense.

I'm don't think the structure above will give us the granularity that will be necessary for that review. I'll give as an example Introduction to Computer Science and Programming Using Python. It's an early course in the curriculum, and so we expect it to cover a fair bit of Software Development Fundamentals. But it also does a good amount of work covering data structures. A thorough review will get into this level of granularity.

With a thorough review complete, OSSU would then be in a great position to communicate that coverage to students!

[Exkywor]

I haven't looked too deeply into the proposal (yet), but is there a reason why we need to choose one option over the other? Could we not keep the curriculum organization as-is for students to know in what order to go through them, but also add this as an extra view of what is covered by OSSU?

[jehep]

• Exactly @waciumawanjohi, I agree that congruency between levels of granularity is important. Thats why • Topic below each Knowledge Unit dropdown was added.
• In the example you mention with Intro to CS you can see the corresponding knowledge units you cited Fund. Prog. Concepts and Fund. Data Structures bellow the SDF - Softw. Development Fundam. dropdown. And now you can see the specific topics like • Arrays when you dropdown each knowledge unit.
• @Exkywor correct, the proposal is the TO BE for CURRICULAR_GUIDELINES.md, the README.md can stay AS IS.

[MOSTAFAEZZAT]

Absolutely YESS, This's pretty neat to the current and good for new fellow, i even struggled when i picked Software Engineering Path and searched a lot to know what courses from the circular I should take.