CODE	NAME	CONTEXT	SEARCH
AL	Algorithms and Complexity	Algorithms are fundamental to computer science and software engineering. The real-world performance of any software system depends on: (1) the algorithms chosen and (2) the suitability and efficiency of the various layers of implementation. Good algorithm design is therefore crucial for the performance of all software systems. Moreover, the study of algorithms provides insight into the intrinsic nature of the problem as well as possible solution techniques independent of programming language, programming paradigm, computer hardware, or any other implementation aspect.	(algorithms and complexity)
AL.1	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	(basic analysis)
AL.2	Algorithmic Strategies	Brute-force algorithms. Greedy algorithms. Divide-and-conquer (cross-reference SDF/Algorithms and Design/Problem-solving strategies). Recursive backtracking. Dynamic Programming	(algorithmic strategies)
AL.3	Fundamental Data Structures and Algorithms	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	(fundamental data structures and algorithms)
AL.4	Basic Automata, Computability and Complexity	Finite-state machines. Regular expressions. The halting problem	(basic automata, computability and complexity)
AL.5	Advanced Computational Complexity	Review of the classes P and NP; introduce P-space and EXP. Polynomial hierarchy. NP-completeness (Cook’s theorem). Classic NP-complete problems. Reduction Techniques	(advanced computational complexity)
AL.6	Advanced Automata Theory and Computability	Sets and languages. Regular languages. Review of deterministic finite automata (DFAs). Nondeterministic finite automata (NFAs). Equivalence of DFAs and NFAs. Review of regular expressions; their equivalence to finite automata. Closure properties. Proving languages non-regular, via the pumping lemma or alternative means. Context-free languages. Push-down automata (PDAs). Relationship of PDAs and context-free grammars. Properties of context-free languages. Turing machines, or an equivalent formal model of universal computation. Nondeterministic Turing machines. Chomsky hierarchy. The Church-Turing thesis. Computability. Rice’s Theorem. Examples of uncomputable functions. Implications of uncomputability	(advanced automata theory and computability)
AL.7	Advanced Data Structures, Algorithms, and Analysis	Balanced trees (e.g., AVL trees, red-black trees, splay trees, treaps). Graphs (e.g., topological sort, finding strongly connected components, matching). Advanced data structures (e.g., B-trees, Fibonacci heaps). String-based data structures and algorithms (e.g., suffix arrays, suffix trees, tries). Network flows (e.g., max flow [Ford-Fulkerson algorithm], max flow – min cut, maximum bipartite matching). Linear Programming (e.g., duality, simplex method, interior point algorithms). Number-theoretic algorithms (e.g., modular arithmetic, primality testing, integer factorization). Geometric algorithms (e.g., points, line segments, polygons. [properties, intersections], finding convex hull, spatial decomposition, collision detection, geometric search/proximity). Randomized algorithms. Stochastic algorithms. Approximation algorithms. Amortized analysis. Probabilistic analysis. Online algorithms and competitive analysis	(advanced data structures, algorithms, and analysis)
AR	Architecture and Organization	Computing professionals should not regard the computer as just a black box that executes programs by magic. The knowledge area Architecture and Organization builds on Systems Fundamentals (SF) to develop a deeper understanding of the hardware environment upon which all computing is based, and the interface it provides to higher software layers. Students should acquire an understanding and appreciation of a computer system’s functional components, their characteristics, performance, and interactions, and, in particular, the challenge of harnessing parallelism to sustain performance improvements now and into the future. Students need to understand computer architecture to develop programs that can achieve high performance through a programmer’s awareness of parallelism and latency. In selecting a system to use, students should be able to understand the tradeoff among various components, such as CPU clock speed, cycles per instruction, memory size, and average memory access time.	(architecture and organization)
AR.1	Digital Logic and Digital 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)	(digital logic and digital systems)
AR.2	Machine Level Representation 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	(machine level representation of data)
AR.3	Assembly Level Machine Organization	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	(assembly level machine organization)
AR.4	Memory System Organization and Architecture	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	(memory system organization and architecture)
AR.5	Interfacing and Communication	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	(interfacing and communication)
AR.6	Functional Organization	Implementation of simple datapaths, including instruction pipelining, hazard detection and resolution. Control unit: hardwired realization vs. microprogrammed realization. Instruction pipelining. Introduction to instruction-level parallelism (ILP)	(functional organization)
AR.7	Multiprocessing and Alternative Architectures	Power Law. Example SIMD and MIMD instruction sets and architectures. Interconnection networks (hypercube, shuffle-exchange, mesh, crossbar). Shared multiprocessor memory systems and memory consistency. Multiprocessor cache coherence	(multiprocessing and alternative architectures)
AR.8	Performance Enhancements	Superscalar architecture. Branch prediction, Speculative execution, Out-of-order execution. Prefetching. Vector processors and GPUs. Hardware support for multithreading. Scalability. Alternative architectures, such as VLIW/EPIC, and Accelerators and other kinds of Special-Purpose Processors	(performance enhancements)
CN	Computational Science	Computational Science is a field of applied computer science, that is, the application of computer science to solve problems across a range of disciplines. In the book Introduction to Computational Science [3], the authors offer the following definition: “the field of computational science combines computer simulation, scientific visualization, mathematical modeling, computer programming and data structures, networking, database design, symbolic computation, and high performance computing with various disciplines." Computer science, which largely focuses on the theory, design, and implementation of algorithms for manipulating data and information, can trace its roots to the earliest devices used to assist people in computation over four thousand years ago. Various systems were created and used to calculate astronomical positions. Ada Lovelace’s programming achievement was intended to calculate Bernoulli numbers. In the late nineteenth century, mechanical calculators became available, and were immediately put to use by scientists. The needs of scientists and engineers for computation have long driven research and innovation in computing. As computers increase in their problem- solving power, computational science has grown in both breadth and importance. It is a discipline in its own right [2] and is considered to be “one of the five college majors on the rise [1]." An amazing assortment of sub-fields have arisen under the umbrella of Computational Science, including computational biology, computational chemistry, computational mechanics, computational archeology, computational finance, computational sociology and computational forensics.	(computational science)
CN.1	Introduction to Modeling and Simulation	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	(introduction to modeling and simulation)
CN.2	Modeling and Simulation	Purpose of modeling and simulation including optimization; supporting decision making, forecasting, safety considerations; for training and education. Tradeoffs including performance, accuracy, validity, and complexity. The simulation process; identification of key characteristics or behaviors, simplifying assumptions; validation of outcomes. Model building: use of mathematical formulas or equations, graphs, constraints; methodologies and techniques; use of time stepping for dynamic systems - 71 -. Formal models and modeling techniques: mathematical descriptions involving simplifying assumptions and avoiding detail. Examples of techniques include:. Monte Carlo methods. Stochastic processes. Queuing theory. Petri nets and colored Petri nets. Graph structures such as directed graphs, trees, networks. Games, game theory, the modeling of things using game theory. Linear programming and its extensions. Dynamic programming. Differential equations: ODE, PDE. Non-linear techniques. State spaces and transitions. Assessing and evaluating models and simulations in a variety of contexts; verification and validation of models and simulations. Important application areas including health care and diagnostics, economics and finance, city and urban planning, science, and engineering. Software in support of simulation and modeling; packages, languages	(modeling and simulation)
CN.3	Processing	Fundamental programming concepts:. The concept of an algorithm consisting of a finite number of well-defined steps, each of which completes in a finite amount of time, as does the entire process.. Examples of well-known algorithms such as sorting and searching.. The concept of analysis as understanding what the problem is really asking, how a problem can be approached using an algorithm, and how information is represented so that a machine can process it.. The development or identification of a workflow.. The process of converting an algorithm to machine-executable code.. Software processes including lifecycle models, requirements, design, implementation, verification and maintenance.. Machine representation of data computer arithmetic.. Numerical methods. Algorithms for numerically fitting data (e.g., Newton’s method). Architectures for numerical computation, including parallel architectures. Fundamental properties of parallel and distributed computation:. Bandwidth.. Latency.. Scalability.. Granularity.. Parallelism including task, data, and event parallelism.. Parallel architectures including processor architectures, memory and caching.. Parallel programming paradigms including threading, message passing, event driven techniques, parallel software architectures, and MapReduce.. Grid computing.. The impact of architecture on computational time.. Total time to science curve for parallelism: continuum of things.. Computing costs, e.g., the cost of re-computing a value vs. the cost of storing and lookup.	(processing)
CN.4	Interactive Visualization	Principles of data visualization. Graphing and visualization algorithms. Image processing techniques. Scalability concerns	(interactive visualization)
CN.5	Data, Information, and Knowledge	Content management models, frameworks, systems, design methods (as in IM. Information Management). Digital representations of content including numbers, text, images (e.g., raster and vector), video (e.g., QuickTime, MPEG2, MPEG4), audio (e.g., written score, MIDI, sampled digitized sound track) and animations; complex/composite/aggregate objects; FRBR. Digital content creation/capture and preservation, including digitization, sampling, compression, conversion, transformation/translation, migration/emulation, crawling, harvesting. Content structure / management, including digital libraries and static/dynamic/stream aspects for:. Data: data structures, databases. Information: document collections, multimedia pools, hyperbases (hypertext, hypermedia), catalogs, repositories. Knowledge: ontologies, triple stores, semantic networks, rules. Processing and pattern recognition, including indexing, searching (including: queries and query languages; central / federated / P2P), retrieving, clustering, classifying/categorizing, analyzing/mining/extracting, rendering, reporting, handling transactions. User / society support for presentation and interaction, including browse, search, filter, route, visualize, share, collaborate, rate, annotate, personalize, recommend. Modeling, design, logical and physical implementation, using relevant systems/software	(data, information, and knowledge)
CN.6	Numerical Analysis	Error, stability, convergence, including truncation and round-off. Function approximation including Taylor’s series, interpolation, extrapolation, and regression - 75 -. Numerical differentiation and integration (Simpson’s Rule, explicit and implicit methods). Differential equations (Euler’s Method, finite differences)	(numerical analysis)
DS	Discrete Structures	Discrete structures are foundational material for computer science. By foundational we mean that relatively few computer scientists will be working primarily on discrete structures, but that many other areas of computer science require the ability to work with concepts from discrete structures. Discrete structures include important material from such areas as set theory, logic, graph theory, and probability theory. The material in discrete structures is pervasive in the areas of data structures and algorithms but appears elsewhere in computer science as well. For example, an ability to create and understand a proof—either a formal symbolic proof or a less formal but still mathematically rigorous argument—is important in virtually every area of computer science, including (to name just a few) formal specification, verification, databases, and cryptography. Graph theory concepts are used in networks, operating systems, and compilers. Set theory concepts are used in software engineering and in databases. Probability theory is used in intelligent systems, networking, and a number of computing applications.	(discrete structures)
DS.1	Sets, Relations, and 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	(sets, relations, and functions)
DS.2	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)	(basic logic)
DS.3	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	(proof techniques)
DS.4	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 (cross-reference: AL/Basic Analysis). An example of a simple recurrence relation, such as Fibonacci numbers. Other examples, showing a variety of solutions. Basic modular arithmetic	(basics of counting)
DS.5	Graphs and Trees	Trees. Properties. Traversal strategies. Undirected graphs. Directed graphs. Weighted graphs	(graphs and trees)
DS.6	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	(discrete probability)
GV	Graphics and Visualization	Computer graphics is the term commonly used to describe the computer generation and manipulation of images. It is the science of enabling visual communication through computation. Its uses include cartoons, film special effects, video games, medical imaging, engineering, as well as scientific, information, and knowledge visualization. Traditionally, graphics at the undergraduate level has focused on rendering, linear algebra, and phenomenological approaches. More recently, the focus has begun to include physics, numerical integration, scalability, and special-purpose hardware. In order for students to become adept at the use and generation of computer graphics, many implementation-specific issues must be addressed, such as file formats, hardware interfaces, and application program interfaces. These issues change rapidly, and the description that follows attempts to avoid being overly prescriptive about them.	(graphics and visualization)
GV.1	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	(fundamental visualization concepts)
GV.2	Basic Rendering	Rendering in nature, e.g., the emission and scattering of light and its relation to numerical integration. Forward and backward rendering (i.e., ray-casting and rasterization). Polygonal representation. Basic radiometry, similar triangles, and projection model. Affine and coordinate system transformations. Ray tracing. Visibility and occlusion, including solutions to this problem such as depth buffering, Painter’s algorithm, and ray tracing. The forward and backward rendering equation. Simple triangle rasterization. Rendering with a shader-based API. Texture mapping, including minification and magnification (e.g., trilinear MIP-mapping). Application of spatial data structures to rendering. Sampling and anti-aliasing. Scene graphs and the graphics pipeline	(basic rendering)
GV.3	Geometric Modeling	Basic geometric operations such as intersection calculation and proximity tests. Volumes, voxels, and point-based representations. Parametric polynomial curves and surfaces. Implicit representation of curves and surfaces. Approximation techniques such as polynomial curves, Bezier curves, spline curves and surfaces, and non- uniform rational basis (NURB) spines, and level set method. Surface representation techniques including tessellation, mesh representation, mesh fairing, and mesh generation techniques such as Delaunay triangulation, marching cubes. Spatial subdivision techniques. Procedural models such as fractals, generative modeling, and L-systems. Graftals, cross referenced with programming languages (grammars to generated pictures). Elastically deformable and freeform deformable models. Subdivision surfaces. Multiresolution modeling. Reconstruction. Constructive Solid Geometry (CSG) representation	(geometric modeling)
GV.4	Advanced Rendering	Solutions and approximations to the rendering equation, for example:. Distribution ray tracing and path tracing. Photon mapping. Bidirectional path tracing. Reyes (micropolygon) rendering. Metropolis light transport. Time (motion blur), lens position (focus), and continuous frequency (color) and their impact on rendering. Shadow mapping. Occlusion culling. Bidirectional Scattering Distribution function (BSDF) theory and microfacets. Subsurface scattering. Area light sources. Hierarchical depth buffering. The Light Field, image-based rendering - 87 -. Non-photorealistic rendering. GPU architecture. Human visual systems including adaptation to light, sensitivity to noise, and flicker fusion	(advanced rendering)
GV.5	Computer Animation	Forward and inverse kinematics. Collision detection and response. Procedural animation using noise, rules (boids/crowds), and particle systems. Skinning algorithms. Physics based motions including rigid body dynamics, physical particle systems, mass-spring networks for cloth and flesh and hair. Key-frame animation. Splines. Data structures for rotations, such as quaternions. Camera animation. Motion capture	(computer animation)
GV.6	Visualization	Visualization of 2D/3D scalar fields: color mapping, isosurfaces. Direct volume data rendering: ray-casting, transfer functions, segmentation. Visualization of:. Vector fields and flow data. Time-varying data. High-dimensional data: dimension reduction, parallel coordinates,. Non-spatial data: multi-variate, tree/graph structured, text. Perceptual and cognitive foundations that drive visual abstractions. Visualization design. Evaluation of visualization methods. Applications of visualization	(visualization)
HCI	Human-Computer Interaction	Human-computer interaction (HCI) is concerned with designing interactions between human activities and the computational systems that support them, and with constructing interfaces to afford those interactions. Interaction between users and computational artefacts occurs at an interface that includes both software and hardware. Thus interface design impacts the software life-cycle in that it should occur early; the design and implementation of core functionality can influence the user interface – for better or worse. Because it deals with people as well as computational systems, as a knowledge area HCI demands the consideration of cultural, social, organizational, cognitive and perceptual issues. Consequently it draws on a variety of disciplinary traditions, including psychology, ergonomics, computer science, graphic and product design, anthropology and engineering.	(hci, human-computer interaction)
HCI.1	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+)	(hci foundations)
HCI.2	Designing Interactions	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	(designing interactions)
HCI.3	Programming Interactive Systems	Software Architecture Patterns, e.g., Model-View controller; command objects, online, offline (cross reference PL/Event Driven and Reactive Programming, where MVC is used in the context of event-driven programming). Interaction Design Patterns: visual hierarchy, navigational distance. Event management and user interaction. Geometry management (cross-reference GV/Geometric Modelling). Choosing interaction styles and interaction techniques. Presenting information: navigation, representation, manipulation. Interface animation techniques (e.g., scene graphs). Widget classes and libraries. Modern GUI libraries (e.g. iOS, Android, JavaFX) GUI builders and UI programming environments (cross- reference PBD/Mobile Platforms). Declarative Interface Specification: Stylesheets and DOMs. Data-driven applications (database-backed web pages). Cross-platform design. Design for resource-constrained devices (e.g. small, mobile devices)	(programming interactive systems)
HCI.4	User-Centered Design and Testing	Approaches to, and characteristics of, the design process. Functionality and usability requirements (cross-reference to SE/Requirements Engineering). Techniques for gathering requirements, e.g., interviews, surveys, ethnographic and contextual enquiry. Techniques and tools for the analysis and presentation of requirements, e.g., reports, personas. Prototyping techniques and tools, e.g., sketching, storyboards, low-fidelity prototyping, wireframes. Evaluation without users, using both qualitative and quantitative techniques, e.g., walkthroughs, GOMS, expert-based analysis, heuristics, guidelines, and standards. Evaluation with users, e.g., observation, think-aloud, interview, survey, experiment. Challenges to effective evaluation, e.g., sampling, generalization. Reporting the results of evaluations. Internationalization, designing for users from other cultures, cross-cultural	(user-centered design and testing, ux)
HCI.5	New Interactive Technologies	Choosing interaction styles and interaction techniques. Representing information to users: navigation, representation, manipulation. Approaches to design, implementation and evaluation of non-mouse interaction. Touch and multi-touch interfaces. Shared, embodied, and large interfaces. New input modalities (such as sensor and location data). New Windows, e.g., iPhone, Android. Speech recognition and natural language processing (cross reference IS/Natural Language Processing). Wearable and tangible interfaces. Persuasive interaction and emotion. Ubiquitous and context-aware interaction technologies (Ubicomp). Bayesian inference (e.g. predictive text, guided pointing). Ambient/peripheral display and interaction	(new interaction interactive technologies)
HCI.6	Collaboration and Communication	Asynchronous group communication, e.g., e-mail, forums, social networks. Synchronous group communication, e.g., chat rooms, conferencing, online games. Social media, social computing, and social network analysis. Online collaboration, 'smart' spaces, and social coordination aspects of workflow technologies. Online communities. Software characters and intelligent agents, virtual worlds and avatars (cross-reference IS/Agents). Social psychology	(collaboration and communication)
HCI.7	Statistical Methods for HCI	t-tests. ANOVA. Randomization (non-parametric) testing, within vs. between-subjects design. Calculating effect size. Exploratory data analysis. Presenting statistical data. Combining qualitative and quantitative results	(statistical methods for hci)
HCI.8	Human Factors and Security	Applied psychology and security policies. Security economics. Regulatory environments – responsibility, liability and self-determination. Organizational vulnerabilities and threats. Usability design and security. Pretext, impersonation and fraud, e.g., phishing and spear phishing (cross-reference IAS/Threats and Attacks). Trust, privacy and deception. Biometric authentication (camera, voice). Identity management	(human factors and security)
HCI.9	Design-Oriented HCI	Intellectual styles and perspectives to technology and its interfaces. Consideration of HCI as a design discipline. Sketching. Participatory design. Critically reflective HCI. Critical technical practice. Technologies for political activism. Philosophy of user experience. Ethnography and ethnomethodology. Indicative domains of application. Sustainability. Arts-informed computing	(design-oriented hci)
HCI.10	Mixed, Augmented and Virtual Reality	Output. Sound. Stereoscopic display. Force feedback simulation, haptic devices. User input. Viewer and object tracking. Pose and gesture recognition. Accelerometers. Fiducial markers. User interface issues. Physical modelling and rendering. Physical simulation: collision detection & response, animation. Visibility computation. Time-critical rendering, multiple levels of details (LOD). System architectures - 96 -. Game engines. Mobile augmented reality. Flight simulators. CAVEs. Medical imaging. Networking. p2p, client-server, dead reckoning, encryption, synchronization. Distributed collaboration	(augmented reality, ar, mixed reality, mr, virtual reality, vr, ar/vr)
IAS	Information Assurance and Security	In CS2013, the Information Assurance and Security KA is added to the Body of Knowledge in recognition of the world’s reliance on information technology and its critical role in computer science education. Information assurance and security as a domain is the set of controls and processes both technical and policy intended to protect and defend information and information systems by ensuring their confidentiality, integrity, and availability, and by providing for authentication and non-repudiation. The concept of assurance also carries an attestation that current and past processes and data are valid. Both assurance and security concepts are needed to ensure a complete perspective. Information assurance and security education, then, includes all efforts to prepare a workforce with the needed knowledge, skills, and abilities to protect our information systems and attest to the assurance of the past and current state of processes and data. The importance of security concepts and topics has emerged as a core requirement in the Computer Science discipline, much like the importance of performance concepts has been for many years.	(information assurance and security)
IAS.1	Foundational 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)	(foundational concepts in security)
IAS.2	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, pre- existing 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	(principles of secure design)
IAS.3	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)	(defensive programming)
IAS.4	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)	(threats and attacks)
IAS.5	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)	(network security)
IAS.6	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	(cryptography)
IAS.7	Web Security	Web security model. Browser security model including same-origin policy. Client-server trust boundaries, e.g., cannot rely on secure execution in the client.  Session management, authentication. Single sign-on. HTTPS and certificates.  Application vulnerabilities and defenses. SQL injection. XSS. CSRF.  Client-side security. Cookies security policy. HTTP security extensions, e.g. HSTS. Plugins, extensions, and web apps. Web user tracking.  Server-side security tools, e.g. Web Application Firewalls (WAFs) and fuzzers	(web security)
IAS.8	Platform Security	Code integrity and code signing.  Secure boot, measured boot, and root of trust.  Attestation.  TPM and secure co-processors.  Security threats from peripherals, e.g., DMA, IOMMU.  Physical attacks: hardware Trojans, memory probes, cold boot attacks.  Security of embedded devices, e.g., medical devices, cars.  Trusted path	(platform security)
IAS.9	Security Policy and Governance	Privacy policy (cross-reference SP/Social Context/Social implications of computing in a networked world; cross-reference SP/Professional Ethics/Accountability, responsibility and liability; cross-reference SP/Privacy and Civil Liberties/Legal foundations of privacy protection).  Inference controls/statistical disclosure limitation.  Backup policy, password refresh policy.  Breach disclosure policy.  Data collection and retention policies.  Supply chain policy.  Cloud security tradeoffs	(security policy and governance)
IAS.10	Digital Forensics	Basic Principles and methodologies for digital forensics.  Design systems with forensic needs in mind.  Rules of Evidence – general concepts and differences between jurisdictions and Chain of Custody.  Search and Seizure of evidence: legal and procedural requirements.  Digital Evidence methods and standards.  Techniques and standards for Preservation of Data.  Legal and Reporting Issues including working as an expert witness.  OS/File System Forensics.  Application Forensics.  Web Forensics.  Network Forensics.  Mobile Device Forensics.  Computer/network/system attacks.  Attack detection and investigation	(digital forensics)
IAS.11	Secure Software Engineering	Building security into the software development lifecycle (cross-reference SE/Software Processes).  Secure design principles and patterns.  Secure software specifications and requirements.  Secure software development practices (cross-reference SE/Software Construction).  Secure testing - the process of testing that security requirements are met (including static and dynamic analysis)..  Software quality assurance and benchmarking measurements	(secure software engineering)
IM	Information Management	Information Management is primarily concerned with the capture, digitization, representation, organization, transformation, and presentation of information; algorithms for efficient and effective access and updating of stored information; data modeling and abstraction; and physical file storage techniques. The student needs to be able to develop conceptual and physical data models, determine which IM methods and techniques are appropriate for a given problem, and be able to select and implement an appropriate IM solution that addresses relevant design concerns including scalability, accessibility and usability.	(information management)
IM.1	Information 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 concepts)
IM.2	Database Systems	Approaches to and evolution of database systems.  Components of database systems - 114 -.  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	(database systems)
IM.3	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)	(data modeling)
IM.4	Indexing	The impact of indices on query performance.  The basic structure of an index.  Keeping a buffer of data in memory.  Creating indexes with SQL.  Indexing text.  Indexing the web (e.g., web crawling)	(indexing)
IM.5	Relational Databases	Mapping conceptual schema to a relational schema.  Entity and referential integrity.  Relational algebra and relational calculus.  Relational Database design.  Functional dependency.  Decomposition of a schema; lossless-join and dependency-preservation properties of a decomposition.  Candidate keys, superkeys, and closure of a set of attributes.  Normal forms (BCNF).  Multi-valued dependency (4NF).  Join dependency (PJNF, 5NF).  Representation theory	(relational databases db)
IM.6	Query Languages	Overview of database languages.  SQL (data definition, query formulation, update sublanguage, constraints, integrity).  Selections.  Projections.  Select-project-join.  Aggregates and group-by.  Subqueries.  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	(query languages SQL)
IM.7	Transaction Processing	Transactions.  Failure and recovery.  Concurrency control.  Interaction of transaction management with storage, especially buffering	(transaction processing)
IM.8	Distributed Databases	Distributed DBMS. Distributed data storage. Distributed query processing. Distributed transaction model. Homogeneous and heterogeneous solutions. Client-server distributed databases (cross-reference SF/Computational Paradigms).  Parallel DBMS. Parallel DBMS architectures: shared memory, shared disk, shared nothing;. Speedup and scale-up, e.g., use of the MapReduce processing model (cross-reference CN/Processing, PD/Parallel Decomposition). Data replication and weak consistency models	(distrobuted databases)
IM.9	Physical Database Design	Storage and file structure.  Indexed files.  Hashed files.  Signature files.  B-trees.  Files with dense index.  Files with variable length records.  Database efficiency and tuning	(physical database design)
IM.10	Data Mining	Uses of data mining.  Data mining algorithms.  Associative and sequential patterns.  Data clustering.  Market basket analysis.  Data cleaning.  Data visualization (cross-reference GV/Visualization and CN/Interactive Visualization)	(data mining)
IM.11	Information Storage and Retrieval	Documents, electronic publishing, markup, and markup languages.  Tries, inverted files, PAT trees, signature files, indexing.  Morphological analysis, stemming, phrases, stop lists.  Term frequency distributions, uncertainty, fuzziness, weighting.  Vector space, probabilistic, logical, and advanced models.  Information needs, relevance, evaluation, effectiveness.  Thesauri, ontologies, classification and categorization, metadata.  Bibliographic information, bibliometrics, citations.  Routing and (community) filtering.  Multimedia search, information seeking behavior, user modeling, feedback.  Information summarization and visualization.  Faceted search (e.g., using citations, keywords, classification schemes).  Digital libraries.  Digitization, storage, interchange, digital objects, composites, and packages.  Metadata and cataloging.  Naming, repositories, archives.  Archiving and preservation, integrity.  Spaces (conceptual, geographical, 2/3D, VR).  Architectures (agents, buses, wrappers/mediators), interoperability.  Services (searching, linking, browsing, and so forth).  Intellectual property rights management, privacy, and protection (watermarking)	(information storage and retrieval)
IM.12	Multimedia Systems	Input and output devices, device drivers, control signals and protocols, DSPs.  Standards (e.g., audio, graphics, video).  Applications, media editors, authoring systems, and authoring.  Streams/structures, capture/represent/transform, spaces/domains, compression/coding.  Content-based analysis, indexing, and retrieval of audio, images, animation, and video - 120 -.  Presentation, rendering, synchronization, multi-modal integration/interfaces.  Real-time delivery, quality of service (including performance), capacity planning, audio/video conferencing, video-on-demand	(multimedia systems)
IS	Intelligent Systems	Artificial intelligence (AI) is the study of solutions for problems that are difficult or impractical to solve with traditional methods. It is used pervasively in support of everyday applications such as email, word-processing and search, as well as in the design and analysis of autonomous agents that perceive their environment and interact rationally with the environment. The solutions rely on a broad set of general and specialized knowledge representation schemes, problem solving mechanisms and learning techniques. They deal with sensing (e.g., speech recognition, natural language understanding, computer vision), problem-solving (e.g., search, planning), and acting (e.g., robotics) and the architectures needed to support them (e.g., agents, multi-agents). The study of Artificial Intelligence prepares the student to determine when an AI approach is appropriate for a given problem, identify the appropriate representation and reasoning mechanism, and implement and evaluate it.	(intelligent systems ai artificial intelligence)
IS.1	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	(fundamental ai issues)
IS.2	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 search strategies)
IS.3	Basic Knowledge Representation and Reasoning	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 knowledge representation and reasoning)
IS.4	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	(basic machine learning ml)
IS.5	Advanced Search	Constructing search trees, dynamic search space, combinatorial explosion of search space.  Stochastic search. Simulated annealing. Genetic algorithms. Monte-Carlo tree search.  Implementation of A* search, beam search.  Minimax search, alpha-beta pruning.  Expectimax search (MDP-solving) and chance nodes	(advanced search)
IS.6	Advanced Representation and Reasoning	Knowledge representation issues. Description logics. Ontology engineering.  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.  Rule-based Expert Systems.  Semantic networks.  Model-based and Case-based reasoning.  Planning:. Partial and totally ordered planning. Plan graphs. Hierarchical planning. Planning and execution including conditional planning and continuous planning. Mobile agent/Multi-agent planning	(advanced representation and reasoning)
IS.7	Reasoning Under Uncertainty	Review of basic probability (cross-reference DS/Discrete Probability).  Random variables and probability distributions. Axioms of probability. Probabilistic inference. Bayes’ Rule.  Conditional Independence.  Knowledge representations. Bayesian Networks Exact inference and its complexity 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	(reasoning under uncertainty)
IS.8	Agents	Definitions of agents.  Agent architectures (e.g., reactive, layered, cognitive).  Agent theory.  Rationality, game theory. Decision-theoretic agents. Markov decision processes (MDP).  Software agents, personal assistants, and information access. Collaborative agents. Information-gathering agents. Believable agents (synthetic characters, modeling emotions in agents).  Learning agents.  Multi-agent systems. Collaborating agents. Agent teams. Competitive agents (e.g., auctions, voting). Swarm systems and biologically inspired models	(agents)
IS.9	Natural Language Processing	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 - 127 -.  Examples of use: POS tagging and morphology.  Information retrieval (Cross-reference IM/Information Storage and Retrieval). Vector space model TF & IDF. Precision and recall.  Information extraction.  Language translation.  Text classification, categorization. Bag of words model	(natural language processing nlp)
IS.10	Advanced Machine Learning	Definition and examples of broad variety of machine learning tasks.  General statistical-based learning, parameter estimation (maximum likelihood).  Inductive logic programming (ILP).  Supervised learning. Learning decision trees. Learning neural networks. Support vector machines (SVMs).  Ensembles.  Nearest-neighbor algorithms.  Unsupervised Learning and clustering. EM. K-means. Self-organizing maps.  Semi-supervised learning.  Learning graphical models (Cross-reference IS/Reasoning under Uncertainty).  Performance evaluation (such as cross-validation, area under ROC curve).  Learning theory.  The problem of overfitting, the curse of dimensionality.  Reinforcement learning. Exploration vs. exploitation trade-off. Markov decision processes. Value and policy iteration.  Application of Machine Learning algorithms to Data Mining (cross-reference IM/Data Mining)	(advanced machine learning ml)
IS.11	Robotics	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.  Configuration space and environmental maps.  Interpreting uncertain sensor data.  Localizing and mapping.  Navigation and control.  Motion planning.  Multiple-robot coordination	(robotics)
IS.12	Perception and Computer Vision	Computer vision. Image acquisition, representation, processing and properties. Shape representation, object recognition and segmentation. Motion analysis.  Audio and speech recognition.  Modularity in recognition.  Approaches to pattern recognition (cross-reference IS/Advanced Machine Learning). Classification algorithms and measures of classification quality. Statistical techniques	(perception and computer vision cv)
NC	Networking and Communication	The Internet and computer networks are now ubiquitous and a growing number of computing activities strongly depend on the correct operation of the underlying network. Networks, both fixed and mobile, are a key part of the computing environment of today and tomorrow. Many computing applications that are used today would not be possible without networks. This dependency on the underlying network is likely to increase in the future. The high-level learning objective of this module can be summarized as follows:.  Thinking in a networked world. The world is more and more interconnected and the use of networks will continue to increase. Students must understand how the networks behave and the key principles behind the organization and operation of the networks..  Continued study. The networking domain is rapidly evolving and a first networking course should be a starting point to other more advanced courses on network design, network management, sensor networks, etc..  Principles and practice interact. Networking is real and many of the design choices that involve networks also depend on practical constraints. Students should be exposed to these practical constraints by experimenting with networking, using tools, and writing networked software.	(networking and communication)
NC.1	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	(networking intro introduction)
NC.2	Networked 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	(networked applications)
NC.3	Reliable Data Delivery	Error control (retransmission techniques, timers).  Flow control (acknowledgements, sliding window).  Performance issues (pipelining).  TCP	(reliable data delivery)
NC.4	Routing and Forwarding	Routing versus forwarding.  Static routing.  Internet Protocol (IP).  Scalability issues (hierarchical addressing)	(routing and forwarding)
NC.5	Local Area Networks	Multiple Access Problem.  Common approaches to multiple access (exponential-backoff, time division multiplexing, etc).  Local Area Networks.  Ethernet.  Switching	(local area networks LAN)
NC.6	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)	(resource allocation)
NC.7	Mobility	Principles of cellular networks.  802.11 networks.  Issues in supporting mobile nodes (home agents)	(mobility mobile network)
NC.8	Social Networking	Social networks overview.  Example social network platforms.  Structure of social network graphs.  Social network analysis	(social networks)
OS	Operating Systems	An operating system defines an abstraction of hardware and manages resource sharing among the computer’s users. The topics in this area explain the most basic knowledge of operating systems in the sense of interfacing an operating system to networks, teaching the difference between the kernel and user modes, and developing key approaches to operating system design and implementation. This knowledge area is structured to be complementary to the Systems Fundamentals (SF), Networking and Communication (NC), Information Assurance and Security (IAS), and the Parallel and Distributed Computing (PD) knowledge areas. The Systems Fundamentals and Information Assurance and Security knowledge areas are the new ones to include contemporary issues. For example, Systems Fundamentals includes topics such as performance, virtualization and isolation, and resource allocation and scheduling; Parallel and Distributed Systems includes parallelism fundamentals; and and Information Assurance and Security includes forensics and security issues in depth. Many courses in Operating Systems will draw material from across these knowledge areas.	(operating systems os)
OS.1	Overview of Operating Systems	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	(overview of operating systems)
OS.2	Operating System 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	(operating system principles)
OS.3	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)	(concurrency)
OS.4	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	(scheduling and dispatch)
OS.5	Memory Management	Review of physical memory and memory management hardware.  Working sets and thrashing.  Caching (cross-reference AR/Memory System Organization and Architecture)	(memory management)
OS.6	Security and Protection	Overview of system security.  Policy/mechanism separation.  Security methods and devices.  Protection, access control, and authentication.  Backups	(os security and protection)
OS.7	Virtual Machines	Types of virtualization (including Hardware/Software, OS, Server, Service, Network).  Paging and virtual memory.  Virtual file systems.  Hypervisors.  Portable virtualization; emulation vs. isolation.  Cost of virtualization	(virtual machines vm vms)
OS.8	Device Management	Characteristics of serial and parallel devices.  Abstracting device differences.  Buffering strategies.  Direct memory access.  Recovery from failures	(device management)
OS.9	File Systems	Files: data, metadata, operations, organization, buffering, sequential, nonsequential.  Directories: contents and structure.  File systems: partitioning, mount/unmount, virtual file systems.  Standard implementation techniques.  Memory-mapped files.  Special-purpose file systems.  Naming, searching, access, backups.  Journaling and log-structured file systems	(file systems)
OS.10	Real Time and Embedded Systems	Process and task scheduling.  Memory/disk management requirements in a real-time environment.  Failures, risks, and recovery.  Special concerns in real-time systems	(real time and embedded systems rt rtos)
OS.11	Fault Tolerance	Fundamental concepts: reliable and available systems (cross-reference SF/Reliability through Redundancy).  Spatial and temporal redundancy (cross-reference SF/Reliability through Redundancy).  Methods used to implement fault tolerance.  Examples of OS mechanisms for detection, recovery, restart to implement fault tolerance, use of these techniques for the OS’s own services	(fault tolerance)
OS.12	System Performance Evaluation	Why system performance needs to be evaluated (cross-reference SF/Performance/Figures of performance merit).  What is to be evaluated (cross-reference SF/Performance/Figures of performance merit).  Systems performance policies, e.g., caching, paging, scheduling, memory management, and security.  Evaluation models: deterministic, analytic, simulation, or implementation-specific.  How to collect evaluation data (profiling and tracing mechanisms)	(os system performance evaluation)
PBD	Platform-Based Development	Platform-based development is concerned with the design and development of software applications that reside on specific software platforms. In contrast to general purpose programming, platform-based development takes into account platform-specific constraints. For instance web programming, multimedia development, mobile computing, app development, and robotics are examples of relevant platforms that provide specific services/APIs/hardware that constrain development. Such platforms are characterized by the use of specialized APIs, distinct delivery/update mechanisms, and being abstracted away from the machine level. Platform-based development may be applied over a wide breadth of ecosystems.	(platform-based development pbd)
PBD.1	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	(introduction to platform-based development)
PBD.2	Web Platforms	Web programming languages (e.g., HTML5, Java Script, PHP, CSS).  Web platform constraints.  Software as a Service (SaaS).  Web standards	(web platforms)
PBD.3	Mobile Platforms	Mobile programming languages.  Challenges with mobility and wireless communication.  Location-aware applications.  Performance / power tradeoffs.  Mobile platform constraints.  Emerging technologies	(mobile platforms)
PBD.4	Industrial Platforms	Types of Industrial Platforms (e.g., Mathematic, Robotic, Industrial Control).  Robotic software and its architecture.  Domain-specific languages.  Industrial platform constraints	(industrial platforms)
PBD.5	Game Platforms	Types of game platforms (e.g., XBox, Wii, PlayStation).  Game platform languages (e.g., C++, Java, Lua, Python).  Game platform constraints	(game platforms)
PD	Parallel and Distributed Computing	The past decade has brought explosive growth in multiprocessor computing, including multi-core processors and distributed data centers. As a result, parallel and distributed computing has moved from a largely elective topic to become more of a core component of undergraduate computing curricula. Both parallel and distributed computing entail the logically simultaneous execution of multiple processes, whose operations have the potential to interleave in complex ways. Parallel and distributed computing builds on foundations in many areas, including an understanding of fundamental systems concepts such as concurrency and parallel execution, consistency in state/memory manipulation, and latency. Communication and coordination among processes is rooted in the message-passing and shared-memory models of computing and such algorithmic concepts as atomicity, consensus, and conditional waiting. Achieving speedup in practice requires an understanding of parallel algorithms, strategies for problem decomposition, system architecture, detailed implementation strategies, and performance analysis and tuning. Distributed systems highlight the problems of security and fault tolerance, emphasize the maintenance of replicated state, and introduce additional issues that bridge to computer networking.	(parallel and distributed computing)
PD.1	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)	(parallelism fundamentals)
PD.2	Parallel Decomposition	Need for communication and coordination/synchronization.  Independence and partitioning	(parallel decomposition)
PD.3	Communication and Coordination	Shared Memory.  Consistency, and its role in programming language guarantees for data-race-free programs	(parallel communication and coordination)
PD.4	Parallel Algorithms, Analysis, and Programming	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 algorithms, analysis, and programming)
PD.5	Parallel Architecture	Multicore processors.  Shared vs. distributed memory	(parallel architecture)
PD.6	Parallel Performance	Load balancing.  Performance measurement.  Scheduling and contention (cross-reference OS/Scheduling and Dispatch).  Evaluating communication overhead.  Data management. Non-uniform communication costs due to proximity (cross-reference SF/Proximity). Cache effects (e.g., false sharing). Maintaining spatial locality.  Power usage and management	(parallel performance)
PD.7	Distributed Systems	Faults (cross-reference OS/Fault Tolerance). Network-based (including partitions) and node-based failures. Impact on system-wide guarantees (e.g., availability).  Distributed message sending. Data conversion and transmission. Sockets. Message sequencing. Buffering, retrying, and dropping messages.  Distributed system design tradeoffs. Latency versus throughput. Consistency, availability, partition tolerance.  Distributed service design. Stateful versus stateless protocols and services. Session (connection-based) designs. Reactive (IO-triggered) and multithreaded designs.  Core distributed algorithms. Election, discovery	(distributed systems)
PD.8	Cloud Computing	Internet-Scale computing. Task partitioning (cross-reference PD/Parallel Algorithms, Analysis, and Programming). Data access. Clusters, grids, and meshes.  Cloud services. Infrastructure as a service Elasticity of resources Platform APIs - 154 -. Software as a service. Security. Cost management.  Virtualization (cross-reference SF/Virtualization and Isolation and OS/Virtual Machines). Shared resource management. Migration of processes.  Cloud-based data storage. Shared access to weakly consistent data stores. Data synchronization. Data partitioning. Distributed file systems (cross-reference IM/Distributed Databases). Replication	(cloud computing)
PD.9	Formal Models and Semantics	Formal models of processes and message passing, including algebras such as Communicating Sequential Processes (CSP) and pi-calculus.  Formal models of parallel computation, including the Parallel Random Access Machine (PRAM) and alternatives such as Bulk Synchronous Parallel (BSP).  Formal models of computational dependencies.  Models of (relaxed) shared memory consistency and their relation to programming language specifications.  Algorithmic correctness criteria including linearizability.  Models of algorithmic progress, including non-blocking guarantees and fairness.  Techniques for specifying and checking correctness properties such as atomicity and freedom from data races	(formal models and semantics)
PL	Programming Languages	Programming languages are the medium through which programmers precisely describe concepts, formulate algorithms, and reason about solutions. In the course of a career, a computer scientist will work with many different languages, separately or together. Software developers must understand the programming models underlying different languages and make informed design choices in languages supporting multiple complementary approaches. Computer scientists will often need to learn new languages and programming constructs, and must understand the principles underlying how programming language features are defined, composed, and implemented. The effective use of programming languages, and appreciation of their limitations, also requires a basic knowledge of programming language translation and static program analysis, as well as run-time components such as memory management.	(programming languages)
PL.1	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	(object oriented programming oop)
PL.2	Functional 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)	(functional programming)
PL.3	Event-Driven and Reactive Programming	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	(event-driven and reactive programming)
PL.4	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	(basic type systems)
PL.5	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	(program representation)
PL.6	Language Translation and Execution	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	(language translation and execution)
PL.7	Syntax Analysis	Scanning (lexical analysis) using regular expressions.  Parsing strategies including top-down (e.g., recursive descent, Earley parsing, or LL) and bottom-up (e.g., backtracking or LR) techniques; role of context-free grammars.  Generating scanners and parsers from declarative specifications	(syntax analysis)
PL.8	Compiler Semantic Analysis	High-level program representations such as abstract syntax trees.  Scope and binding resolution.  Type checking.  Declarative specifications such as attribute grammars	(compiler semantic analysis)
PL.9	Code Generation	Procedure calls and method dispatching.  Separate compilation; linking.  Instruction selection.  Instruction scheduling.  Register allocation.  Peephole optimization	(code generation)
PL.10	Runtime Systems	Dynamic memory management approaches and techniques: malloc/free, garbage collection (mark-sweep, copying, reference counting), regions (also known as arenas or zones) - 163 -.  Data layout for objects and activation records.  Just-in-time compilation and dynamic recompilation.  Other common features of virtual machines, such as class loading, threads, and security	(runtime systems)
PL.11	Static Analysis	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 analyses, such as type-checking and scalable pointer and alias analyses.  Flow-sensitive analyses, such as forward and backward dataflow analyses.  Path-sensitive analyses, such as software model checking.  Tools and frameworks for defining analyses.  Role of static analysis in program optimization.  Role of static analysis in (partial) verification and bug-finding	(static analysis)
PL.12	Advanced Programming Constructs	Lazy evaluation and infinite streams.  Control Abstractions: Exception Handling, Continuations, Monads.  Object-oriented abstractions: Multiple inheritance, Mixins, Traits, Multimethods - 164 -.  Metaprogramming: Macros, Generative programming, Model-based development.  Module systems.  String manipulation via pattern-matching (regular expressions).  Dynamic code evaluation (“eval").  Language support for checking assertions, invariants, and pre/post-conditions	(advanced programming constructs)
PL.13	Concurrency and Parallelism	Constructs for thread-shared variables and shared-memory synchronization.  Actor models.  Futures.  Language support for data parallelism.  Models for passing messages between sequential processes.  Effect of memory-consistency models on language semantics and correct code generation	(concurrency and parallelism)
PL.14	Type Systems	Compositional type constructors, such as product types (for aggregates), sum types (for unions), function types, quantified types, and recursive types.  Type checking.  Type safety as preservation plus progress.  Type inference.  Static overloading	(type systems, typing)
PL.15	Formal Semantics	Syntax vs. semantics.  Lambda Calculus.  Approaches to semantics: Operational, Denotational, Axiomatic.  Proofs by induction over language semantics.  Formal definitions and proofs for type systems (cross-reference PL/Type Systems).  Parametricity (cross-reference PL/Type Systems).  Using formal semantics for systems modeling	(formal semantics)
PL.16	Language Pragmatics	Principles of language design such as orthogonality.  Evaluation order, precedence, and associativity.  Eager vs. delayed evaluation.  Defining control and iteration constructs.  External calls and system libraries	(language pragmatics)
PL.17	Logic Programming	Clausal representation of data structures and algorithms.  Unification.  Backtracking and search.  Cuts	(logic programming)
SDF	Software Development Fundamentals	Fluency in the process of software development is a prerequisite to the study of most of computer science. In order to use computers to solve problems effectively, students must be competent at reading and writing programs in multiple programming languages. Beyond programming skills, however, they must be able to design and analyze algorithms, select appropriate paradigms, and utilize modern development and testing tools. This knowledge area brings together those fundamental concepts and skills related to the software development process. As such, it provides a foundation for other software-oriented knowledge areas, most notably Programming Languages, Algorithms and Complexity, and Software Engineering. It is important to note that this knowledge area is distinct from the old Programming Fundamentals knowledge area from CC2001. Whereas that knowledge area focused exclusively on the programming skills required in an introductory computer science course, this new knowledge area is intended to fill a much broader purpose. It focuses on the entire software development process, identifying those concepts and skills that should be mastered in the first year of a computer science program. This includes the design and simple analysis of algorithms, fundamental programming concepts and data structures, and basic software development methods and tools. As a result of its broader purpose, the Software Development Fundamentals knowledge area includes fundamental concepts and skills that could naturally be listed in other software-oriented knowledge areas (e.g., programming constructs from Programming Languages, simple algorithm analysis from Algorithms & Complexity, simple development methodologies from Software Engineering). Likewise, each of these knowledge areas will contain more advanced material that builds upon the fundamental concepts and skills listed here.	(software development fundamentals)
SDF.1	Algorithms and Design	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	(algorithms and design)
SDF.2	Fundamental Programming 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	(fundamental programming concepts)
SDF.3	Fundamental 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	(fundamental data structures)
SDF.4	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	(development methods, dev ops)
SE	Software Engineering	In every computing application domain, professionalism, quality, schedule, and cost are critical to producing software systems. Because of this, the elements of software engineering are applicable to developing software in all areas of computing. A wide variety of software engineering practices have been developed and utilized since the need for a discipline of software engineering was first recognized. Many trade-offs between these different practices have also been identified. Practicing software engineers have to select and apply appropriate techniques and practices to a given development effort in order to maximize value. To learn how to do so, they study the elements of software engineering.	(software engineering se)
SE.1	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	(software process)
SE.2	Software Project Management	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	(software project management pm)
SE.3	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	(tools and environments dev tools)
SE.4	Requirements Engineering	Describing functional requirements using, for example, use cases or users stories.  Properties of requirements including consistency, validity, completeness, and feasibility	(requirements engineering)
SE.5	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	(software design)
SE.6	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 construction)
SE.7	Software Verification and Validation	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 verification and validation v and v v&v)
SE.8	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 - 184 -. Code segments. Libraries and frameworks. Components. Product lines	(software evolution)
SE.9	Software Reliability	Software reliability engineering concepts.  Software reliability, system reliability and failure behavior (cross-reference SF/Reliability Through Redundancy).  Fault lifecycle concepts and techniques	(software reliability)
SE.10	Formal Methods	Role of formal specification and analysis techniques in the software development cycle.  Program assertion languages and analysis approaches (including languages for writing and analyzing pre- and post-conditions, such as OCL, JML).  Formal approaches to software modeling and analysis. Model checkers. Model finders.  Tools in support of formal methods	(formal methods)
SF	Systems Fundamentals	The underlying hardware and software infrastructure upon which applications are constructed is collectively described by the term "computer systems." Computer systems broadly span the sub- disciplines of operating systems, parallel and distributed systems, communications networks, and computer architecture. Traditionally, these areas are taught in a non-integrated way through independent courses. However these sub-disciplines increasingly share important common fundamental concepts within their respective cores. These concepts include computational paradigms, parallelism, cross-layer communications, state and state transition, resource allocation and scheduling, and so on. The Systems Fundamentals Knowledge Area is designed to present an integrative view of these fundamental concepts in a unified albeit simplified fashion, providing a common foundation for the different specialized mechanisms and policies appropriate to the particular domain area.	(systems fundamentals)
SF.1	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	(computational paradigms)
SF.2	Cross-Layer Communications	Programming abstractions, interfaces, use of libraries.  Distinction between Application and OS services, Remote Procedure Call.  Application-Virtual Machine Interaction.  Reliability	(cross-layer communication)
SF.3	State and State Machines	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	(state and state machines)
SF.4	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	(parallelism)
SF.5	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	(evaluation)
SF.6	Resource Allocation and Scheduling	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	(resource allocation and scheduling)
SF.7	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	(proximity)
SF.8	Virtualization and 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	(virtualization and isolation)
SF.9	Reliability Through Redundancy	Distinction between bugs and faults.  Redundancy through check and retry - 191 -.  Redundancy through redundant encoding (error correcting codes, CRC, FEC).  Duplication/mirroring/replicas.  Other approaches to fault tolerance and availability	(reliability through redundancy)
SF.10	Quantitative Evaluation	Analytical tools to guide quantitative evaluation.  Order of magnitude analysis (Big-Oh notation).  Analysis of slow and fast paths of a system.  Events on their effect on performance (e.g., instruction stalls, cache misses, page faults).  Understanding layered systems, workloads, and platforms, their implications for performance, and the challenges they represent for evaluation.  Microbenchmarking pitfalls	(quantitative evaluation)
SP	Social Issues and Professional Practice	While technical issues are central to the computing curriculum, they do not constitute a complete educational program in the field. Students must also be exposed to the larger societal context of computing to develop an understanding of the relevant social, ethical, legal and professional issues. This need to incorporate the study of these non-technical issues into the ACM curriculum was formally recognized in 1991, as can be seen from the following excerpt [2]: 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 as appreciate the philosophical questions, technical problems, and aesthetic values that play an important part in the development of the discipline. Students also need to develop the ability to ask serious questions about the social impact of computing and to evaluate proposed answers to those questions. Future practitioners must be able to anticipate the impact of introducing a given product into a given environment. Will that product enhance or degrade the quality of life? What will the impact be upon individuals, groups, and institutions? Finally, students need to be aware of the basic legal rights of software and hardware vendors and users, and they also need to appreciate the ethical values that are the basis for those rights. 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. As technological advances continue to significantly impact the way we live and work, the critical importance of social issues and professional practice continues to increase; new computer-based products and venues pose ever more challenging problems each year. It is our students who must enter the workforce and academia with intentional regard for the identification and resolution of these problems	(social issues and professional practice)
SP.1	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.	(social context)
SP.2	Analytical Tools	Ethical argumentation.  Ethical theories and decision-making.  Moral assumptions and values	(ethical analytical tools)
SP.3	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)	(professional ethics)
SP.4	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	(intellectual property ip)
SP.5	Privacy and 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)	(privacy and civil liberties)
SP.6	Professional 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)	(professional communication)
SP.7	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)	(sustainability)
SP.8	History	Prehistory—the world before 1946.  History of computer hardware, software, networking (cross-reference AR/Digital logic and digital systems/ history of computer architecture).  Pioneers of computing.  History of the Internet	(history)
SP.9	Economies of Computing	Monopolies and their economic implications.  Effect of skilled labor supply and demand on the quality of computing products.  Pricing strategies in the computing domain.  The phenomenon of outsourcing and off-shoring software development; impacts on employment and on economics.  Consequences of globalization for the computer science profession - 202 -.  Differences in access to computing resources and the possible effects thereof.  Cost/benefit analysis of jobs with considerations to manufacturing, hardware, software, and engineering implications.  Cost estimates versus actual costs in relation to total costs.  Entrepreneurship: prospects and pitfalls.  Network effect or demand-side economies of scale.  Use of engineering economics in dealing with finances	(economies of computing)
SP.10	Security Policies, Laws, and Computer Crimes	Examples of computer crimes and legal redress for computer criminals (cross-reference IAS/Digital Forensics/rules of evidence).  Social engineering, identity theft and recovery (cross-reference HCI/Human Factors and Security/trust, privacy and deception).  Issues surrounding the misuse of access and breaches in security.  Motivations and ramifications of cyber terrorism and criminal hacking, “cracking".  Effects of malware, such as viruses, worms and Trojan horses.  Crime prevention strategies.  Security policies (cross-reference IAS/Security Policy and Governance/policies)	(security policies, laws, and computer crimes)