CS Curricula

Courses tagged with sys

    COSC-163: Introduction to Computer Architecture (1) sys

    This course will provide an introduction to basic computer systems architecture, stressing how computers work. Beginning with Boolean logic and the design of combinational and sequential circuits, the course will develop the design of memory and processing hardware, including the structure and interpretation of machine instructions and assembly languages, with a focus on datapath and control for classic processor architectures and for modern pipelined architectures. Projects will include the design of digital circuits and basic processor structures. (Amherst)

    COSC-171: Computer Systems (1) sys

    This course will examine the principles and design choices involved in creating general purpose computer systems. Topics will include instruction set architectures, virtual memory, caching, allocators and garbage collectors, threads and synchronization, file systems, virtual machines, and distributed systems. Projects will involve the implementation and use of these capabilities and abstractions. (Amherst)

    COSC-175: Systems I: Computer Organization and Design (1) sys

    This course will cover building blocks and design principles of computer systems, including how user programs are translated and executed on hardware. Beginning with Boolean logic and the design of combinational and sequential circuits, the course discusses the design of computer hardware components, microprocessing, pipelining, basic machine architecture, and the interpretation of machine instructions and assembly languages. The course will also introduce operating systems topics, basic memory management, and parallel processing. Projects will include the design of digital circuits and the simulated hardware execution of code. Two lectures and one lab each week. Fall semester. Professor Pentecost. (Amherst)

    COSC-257: Databases (1) sys

    This course is an introduction to the use of relational databases and the inner workings of systems to manage these databases. Relational databases allow one to store, retrieve, and operate on data in a well-defined way, independent of the nature of the data. Database Management Systems (DBMS) are computer systems designed with the goal of making operations on relational databases as efficient as possible. Students will learn about: the Entity-Relationship model and its algebra, the Structured Query Language (SQL), the actual implementation of the relational algebra operation in a DBMS, the creation and use of indices, the execution of transactions, and DBMS internals such as disk layouts, query planning, and concurrency control. These notions will be made concrete with implementation projects. (Amherst)

    COSC-265: Modern Computing Hardware (1) sys

    This course will provide students with a deeper understanding of modern computer systems and hardware platforms, including design principles for desktop CPUs, mobile devices, graphics processing units (GPUs), and flexible computing platforms (e.g., FPGAs). Key topics include multi-core processing, hardware acceleration, software-hardware co-design, and memory management. This course includes a laboratory component and projects developing and interacting with hardware platforms. (Amherst)

    COSC-273: Parallel and Distributed Computing (1) sys

    Modern computers are becoming increasingly parallel, with many cores or processors working concurrently to perform a single task. In order to utilize the full power of modern computers, it is essential to write programs that exploit parallelism. This course introduces students to the art and science of writing parallel programs. We consider two computing paradigms: shared memory and message passing. We will introduce standard libraries for writing efficient code in each paradigm, and create software that is many times faster than any serial (non-parallel) program performing the same task. (Amherst)

    COSC-275: Systems II: Operating Systems (1) sys

    This course will cover the crucial responsibilities and mechanisms of operating system kernels, focusing on the themes of abstraction, virtualization, concurrency, caching, and persistence. Topics will include processes, memory management and virtual memory, multi-processing and threads, file systems, and virtual machines. (Amherst)

    COSC-277: Operating Systems (1) sys

    An operating system kernel abstracts the hardware to make programming easier, controls how the hardware is shared between programs, and provides essential capabilities like processes, threads, virtual memory, file systems, network sockets, and virtual machines. (Amherst)

    COSC-283: Networks (1) sys

    This course will begin with the problem of communicating between two computers, followed by the problems of building generalized networks for different types and varying numbers of computing devices. (Amherst)

    COSC-365: Performance Evaluation and Optimization (1) sys

    Computer systems are complex structures of multiple hardware and software components, with each component affecting the performance of every computation. To measure and improve performance requires a full understanding of how a system's components interact and the unexpected ways that changes in one component may affect others. In this course we will develop methods for measuring computational performance that account for these complex interactions. We will optimize computations first by empirically identifying the greatest opportunities for improvement and then by evaluating those optimizations through proper measurement and analysis. Topics will include compiler optimizations, memory hierarchy performance, probe effects, cache contention, parallel bottlenecks and scaling, and performance analysis techniques. (Amherst)

    COSC-383: Computer Security (1) sys

    There is an ongoing arms race between hackers and defenders in the cyber world. This course introduces concepts of computer security including exploitation, diagnosis, and protection. Topics will range from program exploits like buffer overflow attacks and privilege escalation to analysis of recent real-world attacks to discussions about the ethics of hacking. We will also cover security protocols such as those for authentication (proving that you are who you say you are), password checking, and cryptography. (Amherst)

    CSE 230: Computer Organization and Assembly Language Programming (3) sys

    Register-level computer organization. Instruction set architecture. Assembly language. Processor organization and design. Memory organization. IO programming. Exception/interrupt handling. (ASU)

    CSE 302: Circuits for Computer Engineers (3) sys

    Covers circuit theory and practical applications to elementary circuit analysis concepts. Digital systems need to be electrically analyzed to determine whether they will perform to a specific speed or face signal integrity problems. Focuses on analyzing electrical circuits with the basis on digital system performance limitations. Shows that simple symbolic analytical models can lead to great design insight, through SPICE simulations which are a part of the lab component for this course. (ASU)

    CPI 310: Web-Based Information Management Systems (3) sys

    Relational database design, entity-relationship modeling, relational algebra, SQL, database access through Web, Web data management, introduction to XML, fundamentals of Web application development, Web server architectures, lecture, in-class lab activities. (ASU)

    CSE 320: Design and Synthesis of Digital Hardware (3) sys

    Design and synthesis of digital hardware with hardware description language, computer-aided design tools, and programmable devices. (ASU)

    CSE 325: Embedded Microprocessor Systems (3) sys

    System-level programming and analysis of embedded microprocessors systems. Fundamental concepts of digital system design for embedded system applications. (ASU)

    CSE 330: Operating Systems (3) sys

    Operating system structure and services, processor scheduling, concurrent processes, synchronization techniques, memory management, virtual memory, input/output, storage management, and file systems. (ASU)

    CSE 335: Principles of Mobile Application Development (3) sys

    Covers topics pertaining to fundamental concepts of mobile application development principles including design patterns; data persistence; interfacing with services and devices; location and incorporation of existing frameworks; user interface and experience; context awareness; utilization of built-in tools for software profiling, testing, and version control; and security/privacy issues. (ASU)

    CPI 360: Decision Making and Problem Solving (3) impactsys

    Practical use of database systems, computer graphics, and modeling to inform decision making. (ASU)

    CSE 408: Multimedia Information Systems (3) sys

    Design, use, and applications of multimedia systems. Introduces acquisition, compression, storage, retrieval, and presentation of data from different media such as images, text, voice, and alphanumeric. (ASU)

    CSE 412: Database Management (3) sys

    Introduces DBMS concepts. Data models and languages. Relational database theory. Database security/integrity and concurrency. (ASU)

    CSE 414: Advanced Database Concepts (3) sys

    Object-oriented data modeling, advanced relational features, JDBC and Web access to databases, XML and databases, object-oriented databases, and object-relational databases. (ASU)

    CSE 420: Computer Architecture I (3) sys

    Computer architecture. Performance versus cost tradeoffs. Instruction set design. Basic processor implementation and pipelining. (ASU)

    CSE 434: Computer Networks (3) sys

    Network architecture and protocols, principles of network applications, socket programming, flow and congestion control, switching and routing, link-layer technologies, traffic capture and analysis, security. (ASU)

    CSE 438: Embedded Systems Programming (3) sys

    Development of embedded system software, I/O handlers, and multiple threaded programs. Scheduling algorithms. Embedded software structures. Real-time operating system. (ASU)

    CSE 445: Distributed Software Development (3) sys

    Distributed system architectures and design, service-oriented computing, and frameworks for development of distributed applications and software components. (ASU)

    CSE 466: Computer Systems Security (3) sys

    Countermeasures to attacks to computer systems from miscreants (or hackers) and basic topics of cryptography and network security. (ASU)

    CSE 467: Data and Information Security (3) sys

    Basic concepts of security and privacy, data and database security, access controls, trust models, watermarking, and private information retrieval. (ASU)

    CSE 468: Computer Network Security (3) sys

    Practical network security exposure and hands-on experience about basic security concepts, case studies and useful tools. (ASU)

    CSE 469: Computer and Network Forensics (3) sys

    Identification, extraction, documentation, interpretation, and preservation of computer media for evidentiary purposes, file system forensics, and network forensics. (ASU)

    IEE 305: Information Systems Engineering (3) sys

    Overview of computer and information systems applications. Topics include client/server; distributed computing; networks; process modeling; e-commerce; enterprise applications; Internet. (ASU)

    COMP 2000: Network Programming with Html And Java (3) sys

    Introduction to network programming using HTML and Java to build web pages and web-based applications; presentation graphics; retrieval of information from the Internet; integration of data among applications. (Auburn)

    COMP 3350: Computer Organization and Assembly Language Programming (3) sys

    Stored Program Computers, hardware and software components; data representation, instruction sets, addressing modes; assembly language programming; linkers, loader, and operating systems. (Auburn)

    COMP 3500: Introduction To Operating Systems (3) sys

    Structure and functions of operating systems; processes and process scheduling; synchronization and mutual exclusion; memory management; auxiliary storage management; resource allocation and deadlock; security, privacy, and ethical concerns; design tradeoffs. (Auburn)

    COMP 3510: Embedded Systems Development (3) sys

    Operating system design and analysis for embedded systems: Real-time issues, resource management, scheduling, exception handling, device driver development, kernel development, synchronization, network support. (Auburn)

    COMP 3710: Wireless Software Engineering (3) sys

    Software engineering for wireless applications: specification, process, testing, and performance evaluation. Design and development of wireless application layer software, including current protocols. (Auburn)

    COMP 4300: Computer Architecture (3) sys

    Comparison of computer architectures, emphasizing the relationships between system software and hardware. Includes processor control and datapath organization, memory subsystem design, instruction set design, processor simulation, and quantitative analysis of computer performance. (Auburn)

    COMP 4320: Introduction To Computer Networks (3) sys

    Fundamentals of computer networks, OSI model, LAN, WAN, packet transmission, interworking, Internet Protocol, WWW and Java technology. (Auburn)

    COMP 5120: Database Systems I (3) sys

    Theoretical and applied issues related to the analysis, design, and implementation of relational database systems. (Auburn)

    CYBR 2000: Introduction to Cybersecurity (3) sys

    Overview of information security practices and needs. Topics include information security, types of attacks, risk analysis and management, security technologies, and basic information security implementation. (Augusta)

    AIST 2310: Introduction to Computer Networking (3) sys

    Introduces networking technology to include networking standards, networking media, networking hardware, access methods, network operating systems, TCP/IP basics, network security and the fundamentals of local area network and wide area network technologies. (Augusta)

    CSCI 2320: Introduction to Computer Networking (3) sys

    Introduces networking technology to include networking standards, networking media, networking hardware, access methods, network operating systems, TCP/IP basics, network security and the fundamentals of local area network and wide area network technologies. Credit not allowed for both CSCI 2320 & MINF 3614. (Augusta)

    CSCI 2330: System Administration (3) sys

    A basic study of the UNIX operating system geared towards the operating system user, future system administrator, and security officer. Topics include listing, finding, displaying and printing files; system security, command-line editing, handling backups, system resources, and file permissions; script programming, and other administrative tasks. (Augusta)

    CYBR 2600: Introduction to Networking and Cyber Security (4) sys

    Introduces networking technology and information security practices. Topics include network models and protocols as well as information security fundamentals. The course includes hands-on lab activities where techniques and procedures are demonstrated and implemented. (Augusta)

    MINF 2650: Principles of Data Management and Analysis (3) sys

    An introduction to information systems with a focus on the collection, manipulation and analysis of structured data. Students will utilize spreadsheets and relational databases to formulate solutions to common business challenges. In addition to fundamental data planning and modeling concepts, students will be introduced to data analysis and visualization techniques, as well as the use of structured programming to automate some data management tasks. (Augusta)

    CYBR 3100: Introduction to Defensive Cyber Operations (3) sys

    Overview of network security activities and techniques. Heavy use of information security tools will be demonstrated and practiced. (Augusta)

    CSCI 3170: Computer Organization (3) sys

    A study of logic circuits and computer organization. Topics include Boolean algebra representation and minimization, logic gates, the design and analysis of combinational and sequential circuits, and registers, ALU and data paths. (Augusta)

    CYBR 3200: Cyber Network Defense and Counter Measures (3) sys

    Emphasis placed on understanding the tools and devices used to secure a computer network (i.e. firewall, IDS, IPS). Course includes hands-on lab activities where techniques and procedures are displayed and tested. (Augusta)

    CSCI 3271: Operating System (3) sys

    A study of computer operating systems and related computer architecture topics. Topics include process management, scheduling, synchronization, deadlock, memory management, virtual memory, disk management, file systems, I/O and protection. (Augusta)

    AIST 3310: Advanced Networking (3) sys

    This course explores routing and switching protocols, and practical applications of enterprise network design. There is a lab component to the course. (Augusta)

    AIST 3320: TCP/IP Protocol Analysis (3) sys

    Introduces network packet analysis and network traffic analysis techniques. Course provides in-depth coverage of the TCP/IP protocol suite. Popular diagnostic tools are used to monitor protocols in action and to understand how the network protocols work. (Augusta)

    AIST 3360: Cellular and Mobile Technology (3) sys

    This course explores mobile and cellular technologies. Students will gain a solid understanding of the key principles of wireless and mobile networks including security impact and mitigation techniques. (Augusta)

    CSCI 3370: Assembly Language Programming (3) sys

    A study of the fundamentals of assembly language programming concepts and techniques. Topics include the representation of instructions and data, the use of registers, the stack, and addressing techniques. In addition, translating high-level programming statements into well-structured assembly code is studied. (Augusta)

    CSCI 3371: Low-Level Programming Languages (3) sys

    Study of computer systems and programming at the level of low-level programming languages. Students will have the opportunity to learn basic principles and fundamentals of machine language, assembly language and C. Topics include pointers, bit operations, and system programming in the C# language, and register operations, control structures, bitwise operations, subprograms, and addressing techniques in assembly language. (Augusta)

    CSCI 3410: Database Systems (3) sys

    This course offers an introduction to database systems as a key concept in information management. The course covers logical and physical database organization, data models, file structures, indexing, hashing, query optimization, and design issues. This course will cover the design and implementation of databases. (Augusta)

    AIST 3410: Database Management Systems (3) sys

    Designing, developing, and maintaining database resources is treated, emphasizing application of established database development tools within a structured development method. (Augusta)

    CSCI 3420: Distributed and Mobile Systems (3) sys

    This course covers the fundamentals of distributed computing and mobile systems including techniques for creating distributed and mobile applications. (Augusta)

    CSCI 3600: Internet Programming (3) sys

    This is an advanced course in Internet programming for real-world business applications. The focus is on the complete application development cycle including analysis and design, implementation, verification, and demonstration/support. Course topics include multi-tier application design, network programming, XML, web server and client programming, JavaScript, AJAX, and web services. (Augusta)

    AIST 3610: System Analysis and Design (3) sys

    Introduces students to modern approaches for analyzing and designing information systems. (Augusta)

    MINF 3618: Business Introduction to Web Development (3) sys

    Business students will be exposed to appropriate format and page layout, adding and manipulating visuals, images, and rich media, creating a navigation scheme and linking together multiple pages and sites, creating basic forms, building interactive features, and publishing/maintaining web sites. (Augusta)

    AIST 3720: Operating System Concepts and Administration (3) sys

    An introduction to operating systems geared towards future administrators. Includes coverage of operating system roles, functions and services, hardware components, virtualization, and the installation, configuration, and administration of a secure operating system. (Augusta)

    CYBR 4400: Digital Forensics (3) sys

    Overview of information security forensics activities. Topics include digital forensics investigative basics, techniques, and digital forensics examination criteria. Course includes hands-on lab activities where techniques and procedures are displayed and tested. (Augusta)

    CSCI 4531: Malware Analysis and Reverse Engineering (3) sys

    Introduces malware analysis and reverse engineering techniques. Course provides in-depth coverage of the malware types, techniques, and capabilities. Popular diagnostic tools are used to analyze malware, observe malware in action, and to understand how the malware works. (Augusta)

    CSCI 4532: Hardware and Embedded Systems (3) sys

    This course explores microcontroller design, embedded systems, and programmable logic devices (FPGAs). Hardware reverse engineering is introduced. Industrial Control Systems are examined as an implementation of embedded systems. There is a lab component to the course. (Augusta)

    AIST 4720: Enterprise System Architectures (3) sys

    A broader examination of operating systems as used in secure, large-scale enterprise environments. Includes coverage of virtualized/hosted/cloud-based systems and services, network storage, configuration & change management, distributed authentication, and other contemporary concepts. (Augusta)

    AIST 4725: Cyber Security in Healthcare Settings (3) sys

    This course conveys the foundational knowledge a healthcare information security and privacy practitioner (HCISPP) must understand. The course provides and in-depth look at the six domains of the HCISPP Common Body of Knowledge (CBK). Material covers the diversity of the healthcare industry, the types of technologies and information flows that require various levels of protection and the exchange of healthcare information within the industry, including relevant regulatory, compliance and legal requirements. (Augusta)

    CYBR 5600: Networking and Cybersecurity (3) sys

    This course explores networking technology and information security practices. The course includes hands-on lab activities where techniques and procedures are demonstrated and implemented. Students will learn about network models, the protocols they utilize, and best security practices. (Augusta)

    CYBR 6400: Digital Forensics (3) sys

    This course presents an overview of information security forensics activities. Topics include digital forensics investigative basics, techniques, and digital forensics examination criteria. The course includes hands-on lab activities where techniques and procedures are displayed and tested. Note: This course is a cross-leveled course with CYBR 4400. For masters level programs, no more than 12 credits of didactic courses required for the program may be in cross-leveled courses. Students are ineligible to take the MS cross-leveled course if they took the undergraduate version previously. Graduate students are expected to complete a digital forensics project utilizing rigorous methods that are beyond what would be expected of undergraduate students. (Augusta)

    CSI 2334: Introduction to Computer Systems (3) sys

    An introduction to the structure of computer systems and the relationship between software and hardware. Topics include computer organization and representation of information in a computer. An assembly language will be used for programming assignments to illustrate the relationship between high-level languages and machine operations and interpretation of software. (Baylor)

    CSI 3335: Database Design and Applications (3) sys

    Current relational database design concepts including ER diagrams and normalization. Database access techniques such as SQL and JDBC. Database issues including performance and security. Web-database applications. (Baylor)

    CSI 3336: Systems Programming (3) sys

    The organization and structure of computer systems, basic concepts of an operating system, command line interpreter, script programming, and system calls. Programming projects in Unix and C programming language. (Baylor)

    CSI 3338: Computer Organization (3) sys

    Introduction to the organization and design of general purpose digital computers. Topics include instruction sets, CPU structures, hardwired and microprogrammed controllers, memory, I/O systems, hardware description languages and simulations. (Baylor)

    CSI 3439: Computer Architecture (4) sys

    Continued study of computer organization, focusing on hardware structure and implementation. Topics include digital logic CPU organization and microprogramming, memory organization, and input/output structures. (Baylor)

    CSI 4111: Cybersecurity Laboratory (1) sys

    This is a laboratory course that will emphasize both offensive and defensive security techniques in an applied laboratory environment. The course may be taken 3 times to earn an upper division elective. (Baylor)

    CSI 4321: Data Communications (3) sys

    Fundamentals of computer networking including data transmission, communication software, protocols, simple networks and internetworking. (Baylor)

    CSI 4325: Advanced Cybersecurity (3) sys

    This course provides additional depth and application of the cybersecurity concepts introduced in CSI 4323 (Introduction to Cybersecurity). Example topics include: penetration testing, cyber resilience, trusted computing, reverse engineering, network situational awareness, security architecture, incident handling, threat intelligence, and forensics. (Baylor)

    CSI 4335: Database Design I (3) sys

    Concepts for current relational database design and implementation, including SQL, ER diagrams, normalization, JDBC, XML and DBMS components. Semester project designing a relational database. (Baylor)

    CSI 4337: Introduction to Operating Systems (3) sys

    Operating system design and implementation. Topics include process control and synchronization, memory management, processor scheduling, file systems, and security. Course projects implement parts of an operating system. (Baylor)

    CS 220: Architecture from a Programmer's Perspective (4) sys

    The architecture and programming of computer systems. Data representation and computer arithmetic. Processor and memory organization. Assembly and machine language programming. Advanced C programming language constructs and their implementation in assembly language. Introduction to system software (assemblers, linkers, loaders, compilers). Supervised laboratory work involves programming and debugging using machine language, assembly language and C. (Binghamton)

    CS 320: Advanced Computer Architecture (4) sys

    Performance metrics and analysis; instruction set architecture and its implications; high-performance computer arithmetic; instruction pipelines and pipelined datapath implementation; out-of-order execution, register renaming, branch prediction and superscalar processors; caches and memory systems; memory hierarchy; the I/O subsystem; reliable storage systems; introduction to multicore and multithreaded architectures; hardware and architectural support for security. Required lab includes programming projects. (Binghamton)

    CS 350: Operating Systems (4) sys

    Introduction to the design and implementation of operating systems: hardware/software interface; processes and threads; CPU scheduling; virtual memory; memory management; concurrency, race conditions, deadlocks, and synchronization; file and storage systems; input/output; protection and security; virtualization and hypervisors; multi-processor operating systems. Required lab includes programming exercises and presentations. (Binghamton)

    CS 426: Internet of Things (4) sys

    This course covers the applied area of Internet of Things (IoT). IoT are pervasive computing systems consisting of smart sensors embedded in physical environments with many promising applications. IoT challenge many classical approaches to computing and networking. Students will learn about key techniques in IoT through this course. A substantial part of the material will cover wireless sensor networks, embedded operating systems, and network protocols. A variety of different IoT applications will be introduced, including clinical monitoring, structural health monitoring, and industrial process automation. In this course, students will also have an opportunity to obtain hands-on experience on programming embedded devices to sense and communicate. (Binghamton)

    CS 427: Mobile Systems Security (4) sys

    This course discusses cybersecurity issues in various aspects of mobile systems, including mobile networks, mobile communications, mobile OSes, mobile applications, and mobile devices. It presents technical details of how mobile systems work and explains their vulnerabilities with potential security risks. The course uses a combination of real-world mobile devices and high-fidelity emulation testbeds to demonstrate common types of attacks in mobile systems as well as how to defend against these attacks. In this course, students are expected to gain hands-on experiences with mobile systems and learn basic techniques to tackle their cybersecurity problems. (Binghamton)

    CS 428: Computer Networks (4) sys

    Communication protocols and layering, hardware-software infrastructures for networking, MAC protocols, data link protocols, switching, inter- and intra-domain routing, the TCP/IP protocol suite, transport protocols, application layer protocols, local and system area networks, wireless and sensor networks, overlay and virtual networks, client-server and peer-to-peer models, network programming with sockets, protocol design and implementation issues, network security. (Binghamton)

    CS 432: Database Systems (4) sys

    Associations between data elements and data models: entity-relationship, relational and object-oriented. Relational database design techniques. Formal and commercial query languages. Introduction to query processing, transaction management and concurrency control. (Binghamton)

    CS 433: Information Retrieval (4) sys

    Indexing and data structures for storing and searching the index. Boolean, statistical, inference nets and knowledge-based models. Thesaurus construction. Query expansion. Natural language and linguistic techniques. Evaluation. Distributed information retrieval. Information integration and fusion. Dissemination of information. Summaries, themes and reading tours. Hypertext. Internet tools. Intelligent agents. Digital libraries. (Binghamton)

    CS 441: Game Dev For Mobile Platforms (4) sys

    This course focuses software development for mobile computing platforms, such as smartphones and tables, with an emphasis on games. Students will develop interactive applications, and utilize the wide variety of sensors and networking features available on the platform, along with basic elements of graphics programming and animation. The course also covers the mechanics of distributing software for mobile computing platforms. Both iOS and Android operating systems will be covered. The course will feature a mix of individual and team projects. (Binghamton)

    CS 444: Programming for the Web (4) sys

    An in-depth understanding of programming for the World Wide Web: detailed coverage of widely used language(s) for web programming, asynchronous programming, principles of web architecture, web protocols, web design patterns, client-side programming, templating, server-side programming, a technical history of the web, web security. Students are expected to have experience with a modern programming language and will be assigned programming projects using current state-of-the-art web technologies. (Binghamton)

    CS 447: High Performance Computing (4) sys

    This course covers the applied area of high performance computing for machine learning, big data, and scientific computing. Students will learn about techniques for programs where the amount of computation is substantial enough that performance is a major concern. A substantial part of the material will cover parallel computation, including message-passing, multicore, and vectorization. A variety of different algorithms and applications will be considered, including machine learning, big data, and more traditional scientific computing. (Binghamton)

    CS 451: Systems Programming (4) sys

    A detailed study of the application program interface of a modern operating system. File operations, concurrency, processes, threads, inter-process communication, synchronization, client-server programming, multi-tier programming. (Binghamton)

    CS 452: Intro to Cloud Computing (4) sys

    This course will provide students with topics in cloud computing with coverage of core cloud components such as virtualization techniques, distributed systems, cloud service models, and representative cloud computing systems. It will not only include the in-depth study of the fundamental enabling techniques such as server, network, and data storage virtualization, but also provide the demonstration of how these techniques work inside today’s widely-used cloud-based systems such as MapReduce, key-value stores, and Openstack. The course will include weekly assignments in the form of homework, labs, and projects. (Binghamton)

    CS 453: Software Security (4) sys

    This hands-on course covers offensive and defensive technologies in the area of software security. Particularly, students will learn about various vulnerabilities that lead to software compromise, attacks that exploit such vulnerabilities, and defenses that defend against such attacks. Topics covered include simple control-flow corruption attacks, slightly harder buffer overflow and return-to-libc attacks, and advanced ROP attacks. Students are expected to not only learn the concepts behind each attack, but also execute them in a controlled environment. (Binghamton)

    CS 457: Intro To Distributed Systems (4) sys

    Fundamental issues in distributed systems. Distributed synchronization and concurrency control. Distributed process management (scheduling, remote invocation, task forces, load balancing). Protection and security. Robust distributed systems. Case studies. (Binghamton)

    CS 458: Intro to Computer Security (4) sys

    The course provides an introduction to the principles and practices of network, computer, and information security. Topics include authentication and cryptographic techniques, intrusion detection, access control, security policies, and program/policy analysis techniques. (Binghamton)

    CS 459: Science of Cyber Security (4) sys

    This course focuses on techniques that approach cyber security problems in a principled manner using concepts from data mining, game theory, graph theory, and psychology. The intent of this course is to permit students to bridge the divide between real-world cyber threats and formal, scientific foundations of solutions that address such threats. Real-world cyber security issues, such as spamming, phishing attacks, malware, sybil attacks in social networks, and DDoS attacks, are used to illustrate how cyber threats can be modeled with abstract representations that are amenable to rigorous analysis and formal reasoning. The course also emphasizes the development of cyber defense mechanisms that are rooted in scientific foundations. (Binghamton)

    CS 476: Program Models Emerg Platforms (4) sys

    The landscape of computation platforms has changed dramatically in recent years. Computing devices such as Unmanned Aerial Vehicles (UAVs) are on the horizon. Big data processing becomes an indispensable part of numerous applications. Multi-core CPUs are commonly deployed in computer systems. Programming on these emerging platforms remains a challenging task. This course introduces a number of state-of-the-art programming models on these platforms, and further explores the frontier of next-generation programming language design that may potentially impact the future programming practice for emerging platforms. In particular, the course investigates UAV programming, Big Data programming, and multi-core programming, with additional presentations on other platforms on the rise. Applications of these programming models range from high-performance computing, cyber-physical systems, databases, to energy-conscious systems. (Binghamton)

    ADIT2000: Computer Security (4) sys

    This course provides a strong starting foundation for understanding the complex threats system managers face today and what they need to do to harden their systems against attack. Today's business system managers need to understand these threats and know how to protect their digital assets. Students in this course will look at computer security through a variety of lenses. Specific topics will include: protecting the physical infrastructure, computer system design considerations, identity and access management functions and how they fit in, the role of network security tools, the importance of audits and having the right security processes and policies in place, business continuity and disaster recover planning, managing vendor contracts and special consideration for cloud-based systems, and ethical considerations. (Boston)

    ADIT2010: Operating Systems (4) sys

    This course provides a comprehensive overview of the principles and practices of operating systems. Students will delve into the architecture, management, and optimization of modern operating systems, understanding how they manage resources, provide user interfaces, and ensure security and reliability. The curriculum emphasizes both theoretical concepts and hands-on application. (Boston)

    ADIT2100: Computer Networks (4) sys

    This course is an in-depth study of networking utilizing the Open Systems Interconnection (OSI) and Transmission Control Protocol/Internet Protocol (TCP/IP) models. A granular discussion of each layer of the model structure included reviewing core components, security vulnerabilities and options for mitigating risk. The building blocks of the Internet will be discussed including ethernet, routing, and secure communication. Network related software and utilities will be utilized throughout the class to provide a greater understanding of the technologies. (Boston)

    CSCI2254: Web Application Development (3) sys

    The web connects our society, providing enormous opportunities for changing and improving how we live every day, from sharing information to interacting with others. We have witnessed the power of the web through various web-based applications, including social media, productivity, and transportation applications. These digital utilities have seamlessly integrated into our routines, fundamentally altering our methods of communication, work, and mobility in recent times.Students will learn how to develop usable and useful web applications in this course. The overall architecture of Internet applications is examined at a high level. Special emphasis is placed on front-end development, including HTML, CSS, and JavaScript. This course further expands to encompass React, a component-based library for building frontend interfaces, as well as Firebase, a cloud-based backend service. The course will culminate with a final project where students take a human-centered design approach to address the needs of people by constructing a sophisticated web application. (Boston)

    CSCI2271: Computer Systems (3) sys

    This course is about how computing machines implement the human-friendly abstractions we express in our programs. It reveals the internal representations of data and instructions, as well as the management of data storage in memory, the coordination of processes, and the interactions between operating systems and the programs being executed. Computer Systems explores system behavior and operations in considerable detail. This greater detail is essential for optimizing program performance, for working within the finite memory and word size constraints of computers, for effective debugging, and for systems-level programming. This hands-on course introduces you to the C programming language and techniques of systems programming through extensive coding exercises (Boston)

    CSCI2272: Computer Organization and Lab (4) sys

    This course studies the internal organization of computers and the processing of machine instructions. Topics include computer representation of numbers, combinational circuit design (decoders, multiplexers), sequential circuit design and analysis, memory design (registers and main memory), and simple processors including datapaths, instruction formats, and control units. In the laboratory-based portion of course students design and build digital circuits related to lecture. Exercises include hardware description languages, combinational and sequential circuits, arithmetic and logic units, and simple datapath and control units. (Boston)

    ADIT2500: Cybersecurity Fundamentals (4) sys

    This course introduces students to the field of, and concepts and principles of cybersecurity. Students will be introduced to various security topics including security awareness through discussing common security threats and attacks, cybersecurity infrastructure, cryptography, and an overview of risk management. (Boston)

    ADIT3010: DevOps Automation and Cloud Security (4) sys

    ? (Boston)

    ADIT3102: DevOps Automation and Cloud Security (4) sys

    ? (Boston)

    CSCI3363: Computer Networks (3) sys

    This course studies computer networks and the services built on top of them. Topics include packet-switch and multi-access networks, routing and flow control, congestion control and quality-of-service, resource sharing, Internet protocols (IP, TCP, BGP), the client-server model and RPC, elements of distributed systems (naming, security, caching, consistency) and the design of network services (peer-to-peer networks, file and web servers, content distribution networks). Coursework involves a significant amount of Java/C programming. (Boston)

    CSCI3390: Topics in Computer Science: Wireless and Mobile Networks (3) sys

    This course will provide an introduction to the state of the art in wireless and mobile networks. The course will cover the fundamental principles, architectures, and standards of current and upcoming wireless and mobile communication systems, including their applications and uses. (Boston)

    ADIT3650: Incident Response and Disaster Recovery (4) sys

    This course provides an overview of contingency planning, including incident response, disaster recovery, and business continuity planning. Effective techniques to minimize risk and downtime in emergency situations will be discussed. Tabletop exercises will be utilized to mimic actual incidents to prepare students for incident management. (Boston)

    ADIT4110: Ethical Hacking (4) sys

    ? (Boston)

    CS 210: Computer Systems (4) sys

    Fundamental concepts of computer systems and systems programming. Hardware fundamentals including digital logic, memory systems, processor design, buses, I/O subsystems, data representations, computer arithmetic, and instruction-set architecture. Software concepts including assembly language programming, operating systems, assemblers, linkers, and systems programming in C. (BU)

    CS 350: Fundamentals of Computing Systems (4) sys

    Programming-centric introduction to computer systems. The course discusses system design principles, performance analysis, communication and synchronization primitives, concurrency control, database transactions, data consistency, task and data parallelism, replication, fault tolerance, and distributed consensus. Part of the discussion includes case studies of real systems from industry. All programming assignments will be in Go. (BU)

    CS 357: Introduction to Information Security (4) sys

    Provides basic concepts needed for understanding information security. Discusses vulnerabilities, design principles, basic algorithms, security definitions, and analytical methods. Covers system security, network security, web security, cryptography, and data privacy. Also addresses social, ethical, and policy aspects of security. (BU)

    CS 410: Advanced Software Systems (4) sys

    Systems programming including such topics as project management, tools, I/O networking, multiprocessing, exception handling, and system services. Other topics are explored using C and Perl under the UNIX operating system. Requires a working knowledge of the C programming language and experience with UNIX as a user, or equivalent. (BU)

    CS 412: Full-Stack Application Design and Development (4) sys

    Introduction to design and development of full-stack web applications. Topics include asynchronous programming; non-relational data stores; use of APIs; serverless (cloudbased) applications; decoupled client/server architectures; performance; testing; packaging; and deployment. Examines current and proposed technology stacks. (BU)

    CS 451: Distributed Systems (4) sys

    Programming-centric introduction to how networks of computers are structured to operate as coherent single systems. Introducing principles of architecture, processes, communications, naming, synchronization, consistency and replication, fault tolerance and security, and paradigms such as web-based, object-based, file system, and consistency-based. (BU)

    CS 454: Embedded Systems Development (4) sys

    Lab-based course exploring concepts, techniques, best practices, and tools for the development of connected embedded systems, including: signal processing; sensing, control and actuation; programming and debugging on microprocessors; I/O interfacing and development of device drivers; and time-critical data handling. (BU)

    CS 455: Computer Networks (4) sys

    Concepts underlying the design of high-performance computer networks and scalable protocols. Topics include Internet design principles and methodology, TCP/IP implementation, packet switching and routing algorithms, multicast, quality of service considerations, error detection and correction, and performance evaluation. (BU)

    CS 460: Introduction to Database Systems (4) sys

    Introduction to database management systems. Examines entity-relationship, relational, and object-oriented data models; commercial query languages: SQL, relational algebra, relational calculus, and QBE; file organization, indexing and hashing, query optimization, transaction processing, concurrency control and recovery, integrity, and security. (BU)

    CS 528: Cloud Computing (4) sys

    Fundamentals of cloud computing covering IaaS platforms, OpenStack, key Big Data platforms, and data center scale systems. Examines influential publications in cloud computing. Culminates in a group project supervised by a mentor from industry or academia. (BU)

    CS 551: Streaming and Event-driven Systems (4) sys

    Fundamentals of stream processing and event-driven systems. Topics include Pub/Sub systems; Distributed streaming systems; Dataflow programming; Fault-tolerance and processing guarantees; State management; Windowing semantics; Complex event processing; Microservice architectures; Serverless functions; Examines current and emerging architectures and use-cases. (BU)

    CS 558: Computer Networks Security (4) sys

    This course covers securing core internet infrastructure protocols and constructing secure, private, and censorship-free communications on the modern internet. Topics include BGP, ARP, DNS, TLS, censorship-resistant systems like Tor, end-to-end secure messaging, metadata protection, and trusted execution environments. (BU)

    CS 561: Data Systems Architectures (4) sys

    Discusses the design of data systems that can address the modern challenges of managing and accessing large, ever-growing, diverse sets of data, often streaming from heterogenous sources, in the context of continuously evolving hardware and software. We use examples from several data management areas including relational systems, distributed database systems, key value stores, newSQL and NoSQL systems, data systems for machine learning (and machine learning for data systems), interactive analytics, and data management as a service. (BU)

    COSI 107a: Introduction to Computer Security (4) sys

    Introduces students to foundational concepts in computer and network security. Focuses on topics essential in many areas of contemporary software development, including security for application software, uses of cryptography, secure communications in the World-Wide Web, and issues in data privacy. Across these areas students will learn from real-world systems analyzing systems for threats and vulnerabilities, mechanisms of attack, and methods to design and implement defenses against attack. Course assignments will include techniques for both attack and defense as well as written and oral presentations about security issues, design, and implementation. Usually offered every year. (Brandeis)

    COSI 127b: Database Management Systems (4) sys

    Introduces database structure, organization, and languages. Studies relational and object-oriented models, query languages, optimization, normalization, file structures and indexes, concurrency control and recovery algorithms, and distributed databases. Usually offered every second year. (Brandeis)

    COSI 128a: Introduction to Computer Networking (4) sys

    Provides a comprehensive introduction to the principles and practices of computer networking. Students will engage with the principles of data communication, network architectures, and protocols, including state-of-the-art networking technologies. Usually offered every year. (Brandeis)

    COSI 131a: Operating Systems (4) sys

    Fundamental structures of a computer system from hardware abstractions through machine and assembly language, to the overall structure of an operating system and key resource management abstractions. Usually offered every year. (Brandeis)

    COSI 142a: Embedded Systems Development (4) sys

    A project-based course that teaches the foundational aspects of embedded systems and the development process utilizing Raspberry Pi. Students will will create prototypes of embedded systems, including applications for IoT devices. Usually offered every year. (Brandeis)

    COSI 143b: Data Management for Data Science (4) sys

    This experiential class will study techniques and systems for ingesting, processing, analyzing, and visualizing large data sets. The end goal of the class is to familiarize students with the data management tools and concepts that can support the full-stack of data science pipelines. Usually offered every second year. (Brandeis)

    COSI 146a: Principles of Computer System Design (4) sys

    Topics on the design and engineering of computer systems: techniques for controlling complexity; strong modularity using client-server design; layering; naming; networks; security and privacy; fault-tolerant systems, atomicity and recovery; performance; impact of computer systems on society. (Brandeis)

    COSI 147a: Distributed Systems (4) sys

    This course covers abstractions and implementation techniques for the design of distributed systems. Topics include: distributed state sharing, coherence, storage systems, naming systems, security, fault tolerance and replication, scalability and performance. (Brandeis)

    COSI 152a: Web Application Development (4) sys

    Introduces web programming that covers the fundamental languages and tools, including HTML/CSS for page layout, javascript/ajax for client-side integration, and server-side programming in Java, Ruby, and SQL. (Brandeis)

    COSI 153a: Mobile Application Development (4) sys

    Introduces the design and analysis of mobile applications that covers the architecture of mobile devices, APIs for graphical user interfaces on mobile devices, location-aware computing, social networking. (Brandeis)

    COSI 167a: Advanced Data Systems (4) sys

    Explores the principles of designing data systems tackling challenges such as optimizing the use of ever-evolving hardware (storage, computation, network), ensuring efficient collection of incoming data, querying dynamic data collections, parallelizing query processing, and more. Students will gain a comprehensive understanding of the key drivers of innovation in data systems: hardware and workloads, delving into the detailed analysis of recent and anticipated trends in both areas. Usually offered every year. (Brandeis)

    CSCI 0300: Fundamentals of Computer Systems (1) sys

    Covers fundamental concepts, principles, and abstractions that underlie the design and engineering of computer systems. Students will learn how a computer works, how to write safe and performant systems software, and what systems abstractions support today’s complex, high-performance systems developed in industry. Specific topics include machine organization, systems programming and performance, key concepts of operating systems, isolation, security, virtualization, concurrent programming, and the basics of distributed systems. Combined lectures, labs, and several hands-on projects involving programming exercises in C/C++. (Brown)

    CSCI 0330: Introduction to Computer Systems (1) sys

    Covers high-level computer architecture, systems programming, assembly-language programming, C-language programming, and operating systems functions. (Brown)

    CSCI 1040: The Basics of Cryptographic Systems (1) sys

    This course will cover cryptographic concepts such as data privacy, encryption, authentication, digital signatures, differential privacy, privacy-enhancing technologies, secure computation, and electronic money. The emphasis will be on how to use cryptographic systems correctly in a larger context, rather than on the mathematical details of how they work; although we will cover some of those details too, on a high level. This course will be aimed at practicing and aspiring poets, economists, software engineers, law and policy wonks, and business tycoons. (Brown)

    CSCI 1270: Database Management Systems (1) sys

    Introduction to database structure, organization, languages and implementation. Relational model. Query languages, query processing, query optimization, normalization, file structures, concurrency control and recovery algorithms, and distributed databases. Studies of actual systems. While database management system usage is covered, emphasis is on the systems-building aspects of these large, complex systems. We also relate the material to modern applications such as the web. (Brown)

    CSCI 1310: Fundamentals of Computer Systems (1) sys

    Covers fundamental concepts, principles, and abstractions that underlie the design and engineering of computer systems. Students will learn how a computer works, how to write safe and performant systems software, and what systems abstractions support today’s complex, high-performance systems developed in industry. Specific topics include machine organization, systems programming and performance, key concepts of operating systems, isolation, security, virtualization, concurrent programming, and the basics of distributed systems. (Brown)

    CSCI 1330: Computer Systems (1) sys

    High-level computer architecture and systems programming. The course covers the organization of computer systems (in terms of storage units, caches, processors, and I/O controllers) and teaches students assembly-language programming and C-language programming. Extensive programming exercises introduce students to systems-level programming on Linux systems, as well as to multi-threaded programming with POSIX threads. Students will be introduced to the functions of operating systems. (Brown)

    CSCI 1380: Distributed Computer Systems (1) sys

    Explores the fundamental principles and practice underlying networked information systems, first we cover basic distributed computing mechanisms (e.g., naming, replication, security, etc.) and enabling middleware technologies. We then discuss how these mechanisms and technologies fit together to realize distributed databases and file systems, web-based and mobile information systems. (Brown)

    CSCI 1515: Applied Cryptography (1) sys

    This course teaches cryptography from a practical perspective and provides students with hands-on experience in building secure systems. Students will implement secure authentication and communication systems using foundational cryptographic algorithms such as encryption schemes, authentication codes, digital signatures, key exchange, and hash functions. The course also covers advanced topics including zero-knowledge proofs, secure multi-party computation, fully homomorphic encryption, and post-quantum cryptography. Students will use these tools to develop applications such as secure online anonymous voting, privacy-preserving data analysis, and private information retrieval. (Brown)

    CSCI 1600: Real-time and Embedded Software (1) sys

    Comprehensive introduction to the design and implementation of software for programmable embedded computing systems, in applications such as Internet of Things, transportation, and mobile. Includes the overall embedded real-time software design and development processes, with a focus on engineering for reliability. Major project component. (Brown)

    CSCI 1620: Computer Systems Security Lab (0.5) sys

    CSCI 1620 is a half-credit laboratory course intended to be taken concurrently with CSCI 1660 and provides students with a deeper understanding of the material by doing additional assignments, which include extensions of the 1660's assignments. Instructor permission required. (Brown)

    CSCI 1650: Software Security and Exploitation (1) sys

    CSCI 1650 covers software exploitation techniques and state-of-the-art mechanisms for hardening software. The course begins with a summary of prevalent software defects, typically found in applications written in memory unsafe languages, like C/C++, and proceeds with studying traditional and modern exploitation techniques, ranging from classical code injection and code reuse up to the latest goodies (e.g., JIT-ROP). For the most part, it focuses on defenses against certain vulnerability classes and the way(s) to bypass them. Students will be introduced to advanced software exploitation techniques and countermeasures, and study (in depth) the boundaries and effectiveness of standard hardening mechanisms, such as address space randomization and stack and heap protections. (Brown)

    CSCI 1660: Computer Systems Security (1) sys

    This course teaches principles of computer security from an applied viewpoint and provides hands-on experience on security threats and countermeasures. Topics include code execution vulnerabilities (buffer overflow, sandboxing, mobile code), malware (trojans, viruses, and worms), access control (users, roles, policies), cryptosystems (hashing, signatures, certificates), network security (firewalls, TLS, intrusion detection, VPN), and human and social issues (usability, social engineering, digital rights management) (Brown)

    CSCI 1670: Operating Systems (1) sys

    Covers not just the principles of operating systems but the intricacies of how they work. Topics include multithreaded programming, managing threads and interrupts, managing storage, processor scheduling, operating-system structure, virtualization, security, and the design of file systems (both local and distributed). Extensive examples are taken from actual systems, including Linux and Windows. Students are expected to complete both problem sets and programming assignments (in C). (Brown)

    CSCI 1680: Computer Networks (1) sys

    Covers the technologies supporting the Internet, from Ethernet and WiFi through the routing protocols that govern the flow of traffic and the web technologies that are generating most of it. A major concern is understanding the protocols used on the Internet: what the issues are, how they work, their shortcomings, and what improvements are on the horizon. (Brown)

    CSCI 1690: Operating Systems Laboratory (0.5) sys

    Half-credit course intended to be taken with CSCI 1670. Students individually write a simple operating system in C. Reinforces the concepts learned in CSCI 1670 and provides valuable experience in systems programming. (Brown)

    CSCI 1710: Logic for Systems (1) sys

    Uses industry-standard tools to address quandaries both in and outside of computer science. Students learn to model systems, reason about those systems automatically using logic, and build essential algorithms behind tools used at Amazon, Intel, and more. The course culminates in a student-proposed project that applies to a real-world system of their choice. (Brown)

    CSCI 1760: Multiprocessor Synchronization (1) sys

    This course examines the theory and practice of multiprocessor synchronization. Subjects covered include multiprocessor architecture, mutual exclusion, wait-free and lock-free synchronization, spin locks, monitors, load balancing, concurrent data structures, and transactional synchronization. (Brown)

    CSCI 1880: Introduction to Computer Security (1) sys

    This course examines the basic principles of computer security for an organization, recognizing which system components relate to which principles. Additionally, the course covers methodologies and skills for making informed security decisions and understanding how to apply security principles to design security mechanisms while considering tradeoffs. Topics include general security principles, cryptography, authentication authorization, identity, and access management, operating systems security, network security, web security, and applications security. Throughout the course, you will develop a preliminary cybersecurity plan for an organization. This course is not intended for CS concentrators and registration is by instructor permission. (Brown)

    CSCI 1951-L: Blockchains & Cryptocurrencies (1) sys

    Introduction to modern blockchain-based systems. Topics covered include consensus and distributed computing, examples cryptocurrencies, programming smart contracts, privacy and secrecy, transfer networks, atomic swaps and transactions, non-currency applications of blockchains, and legal and social implications. Students will do a programming project and a term project. (Brown)

    CSCI 1952-Y: Computer Architecture (1) sys

    How does a computer program actually turn into the electrons moving inside of your computer? What are the relevant metrics and tradeoffs for designing a computer, and what impact do these tradeoffs have on our software? In this course, we cover computer organization and design, from a software lens. Topics include instruction set architectures, processor design and pipelining, memory hierarchies, program flow optimization, I/O, and emerging applications. Homeworks and final project will use powerful architecture simulators and explore general and specialized hardware for various applications. (Brown)

    CSCI 1953-A: Accessible and Inclusive Cybersecurity and Privacy (1) sys

    This seminar course will address the unique privacy and security challenges faced by select vulnerable communities (e.g., youth, refugees, survivors of gender-based violence, journalists, sex workers, etc.). Students will examine the technical foundations of security and privacy, pinpointing where they fail to provide holistic safety solutions. The course will blend theoretical knowledge with practical applications, covering inclusive design principles in cybersecurity and privacy, threat models for marginalized groups, societal and ethical considerations for security practices, and strategies for integrating inclusivity into security research, policymaking, and system design. Through readings, guest lectures, case studies, and collaborative projects, students will learn how to incorporate the needs of at-risk users into research and design. No prerequisites are required. (Brown)

    CS 10 ab: Introduction to Digital Logic and Embedded Systems (6) sys

    This course is intended to give the student a basic understanding of the major hardware and software principles involved in the specification and design of embedded systems. The course will cover basic digital logic, programmable logic devices, CPU and embedded system architecture, and embedded systems programming principles (interfacing to hardware, events, user interfaces, and multi-tasking). (Caltech)

    CS 24: Introduction to Computing Systems (9) sys

    Basic introduction to computer systems, including hardware-software interface, computer architecture, and operating systems. Course emphasizes computer system abstractions and the hardware and software techniques necessary to support them, including virtualization (e.g., memory, processing, communication), dynamic resource management, and common-case optimization, isolation, and naming. (Caltech)

    CS 119 abc: Advanced Digital Systems Design (9) sys

    Advanced digital design as it applies to the design of systems using PLDs and ASICs (in particular, gate arrays and standard cells). The course covers both design and implementation details of various systems and logic device technologies. The emphasis is on the practical aspects of ASIC design, such as timing, testing, and fault grading. Topics include synchronous design, state machine design, arithmetic circuit design, application-specific parallel computer design, design for testability, CPLDs, FPGAs, VHDL, standard cells, timing analysis, fault vectors, and fault grading. Students are expected to design and implement both systems discussed in the class as well as self-proposed systems using a variety of technologies and tools. Given in alternate years; Not offered 2023-24. (Caltech)

    CS 121: Relational Databases (9) sys

    Introduction to the basic theory and usage of relational database systems. It covers the relational data model, relational algebra, and the Structured Query Language (SQL). The course introduces the basics of database schema design and covers the entity-relationship model, functional dependency analysis, and normal forms. Additional topics include other query languages based on the relational calculi, data-warehousing and dimensional analysis, writing and using stored procedures, working with hierarchies and graphs within relational databases, and an overview of transaction processing and query evaluation. Extensive hands-on work with SQL databases. (Caltech)

    CS 124: Operating Systems (12) sys

    This course explores the major themes and components of modern operating systems, such as kernel architectures, the process abstraction and process scheduling, system calls, concurrency within the OS, virtual memory management, and file systems. Students must work in groups to complete a series of challenging programming projects, implementing major components of an instructional operating system. Most programming is in C, although some IA32 assembly language programming is also necessary. Familiarity with the material in CS 24 is strongly advised before attempting this course. (Caltech)

    CS 125: Digital Circuit Design with FPGAs and VHDL (9) sys

    Study of programmable logic devices (FPGAs). Detailed study of the VHDL language, accompanied by tutorials of popular synthesis and simulation tools. Review of combinational circuits (both logic and arithmetic), followed by VHDL code for combinational circuits and corresponding FPGA-implemented designs. Review of sequential circuits, followed by VHDL code for sequential circuits and corresponding FPGA-implemented designs. Review of finite state machines, followed by VHDL code for state machines and corresponding FPGA-implemented designs. Final project. The course includes a wide selection of real-world projects, implemented and tested using FPGA boards. Not offered 2023-24. (Caltech)

    CS 132: Web Development (9) sys

    Covers full-stack web development with HTML5, CS, client-side JS (ES6) and server-side JS (Node.js/Express) for web API development. Concepts including separation of concerns, the client-server relationship, user experience, accessibility, and security will also be emphasized throughout the course. Assignments will alternate between formal and semi-structured student-driven projects, providing students various opportunities to apply material to their individual interests. No prior web development background is required, though students who have prior experience may still benefit from learning best practices and HTML5/ES6 standards. (Caltech)

    CS 142: Distributed Computing (9) sys

    Programming distributed systems. Mechanics for cooperation among concurrent agents. Programming sensor networks and cloud computing applications. Applications of machine learning and statistics by using parallel computers to aggregate and analyze data streams from sensors. Not offered 2023-24. (Caltech)

    CS 143: Networks: Algorithms & Architecture (12) sys

    Social networks, the web, and the internet are essential parts of our lives, and we depend on them every day. CS 143 and CS 144 study how they work and the 'big' ideas behind our networked lives. In this course, the questions explored include: Why is an hourglass architecture crucial for the design of the Internet? Why doesn't the Internet collapse under congestion? How are cloud services so scalable? How do algorithms for wireless and wired networks differ? For all these questions and more, the course will provide a mixture of both mathematical analysis and hands-on labs. The course expects students to be comfortable with graph theory, probability, and basic programming. (Caltech)

    CS 144: Networks: Structure & Economics (12) sys

    Social networks, the web, and the internet are essential parts of our lives, and we depend on them every day. CS 143 and CS 144 study how they work and the 'big' ideas behind our networked lives. In this course, the questions explored include: What do networks actually look like (and why do they all look the same)?; How do search engines work?; Why do epidemics and memes spread the way they do?; How does web advertising work? For all these questions and more, the course will provide a mixture of both mathematical analysis and hands-on labs. The course expects students to be comfortable with graph theory, probability, and basic programming. (Caltech)

    CS 145: Projects in Networking (9) sys

    Students are expected to execute a substantial project in networking, write up a report describing their work, and make a presentation. (Caltech)

    CS 161: Big Data Networks (9) sys

    Next generation networks will have tens of billions of nodes forming cyber-physical systems and the Internet of Things. A number of fundamental scientific and technological challenges must be overcome to deliver on this vision. This course will focus on (1) How to boost efficiency and reliability in large networks; the role of network coding, distributed storage, and distributed caching; (2) How to manage wireless access on a massive scale; modern random access and topology formation techniques; and (3) New vistas in big data networks, including distributed computing over networks and crowdsourcing. A selected subset of these problems, their mathematical underpinnings, state-of-the-art solutions, and challenges ahead will be covered. Not offered 2023-24. (Caltech)

    CS 167: Introduction to Data Compression and Storage (9) sys

    The course will introduce the students to the basic principles and techniques of codes for data compression and storage. The students will master the basic algorithms used for lossless and lossy compression of digital and analog data and the major ideas behind coding for flash memories. Topics include the Huffman code, the arithmetic code, Lempel-Ziv dictionary techniques, scalar and vector quantizers, transform coding; codes for constrained storage systems. Given in alternate years; not offered 2023-24. (Caltech)

    CS 175: Advanced Topics in Digital Design with FPGAs and VHDL (9) sys

    Quick review of the VHDL language and RTL concepts. Dealing with sophisticated, multi-dimensional data types in VHDL. Dealing with multiple time domains. Transfer of control versus data between clock domains. Clock division and multiplication. Using PLLs. Dealing with global versus local and synchronous versus asynchronous resets. How to measure maximum speed in FPGAs (for both registered and unregistered circuits). The (often) hard task of time closure. The subtleties of the time behavior in state machines (a major source of errors in large, complex designs). Introduction to simulation. Construction of VHDL testbenches for automated testing. Dealing with files in simulation. All designs are physically implemented using FPGA boards. Not offered 2023-24. (Caltech)

    CS 208: Introduction to Computer Systems (6) sys

    Are you curious what’s really going on when a computer runs your code? In this course we will demystify the machine and the tools that we use to program it. Our broad survey of how computer systems execute programs, store information, and communicate will focus on the hardware/software interface, including data representation, instruction set architecture, the C programming language, memory management, and the operating system process model. (Carleton)

    CS 231: Computer Security (6) sys

    Hackers, phishers, and spammers–at best they annoy us, at worst they disrupt communication systems, steal identities, bring down corporations, and compromise sensitive systems. In this course, we’ll study various aspects of computer and network security, focusing mainly on the technical aspects as well as the social and cultural costs of providing (or not providing) security. Topics include cryptography, authentication and identification schemes, intrusion detection, viruses and worms, spam prevention, firewalls, denial of service, electronic commerce, privacy, and usability. (Carleton)

    CS 330: Introduction to Real-Time Systems (6) sys

    How can we prove that dynamic cruise control will brake quickly enough if traffic suddenly stops? How must a system coordinate processes to detect pedestrians and other vehicles to ensure fair sharing of computing resources? In real-time systems, we explore scheduling questions like these, which require provable guarantees of timing constraints for applications including autonomous vehicles. This course will start by considering such questions for uniprocessor machines, both when programs have static priorities and when priorities can change over time. We will then explore challenges introduced by modern computers with multiple processors. We will consider both theoretical and practical perspectives. (Carleton)

    CS 331: Computer Networks (6) sys

    The Internet is composed of a large number of heterogeneous, independently-operating computer networks that work together to transport all sorts of data to points all over the world. The fact that it does this so well given its complexity is a minor miracle. In this class, we’ll study the structure of these individual networks and of the Internet, and figure out how this “magic” takes place. Topics include TCP/IP, protocols and their implementations, routing, security, network architecture, DNS, peer-to-peer networking, and Wi-Fi along with ethical and privacy issues. (Carleton)

    CS 332: Operating Systems (6) sys

    If you’re working in the lab, you might be editing a file while waiting for a program to compile. Meanwhile, the on-screen clock ticks, a program keeps watch for incoming e-mail, and other users can log onto your machine from elsewhere in the network. Not only that, but if you write a program that reads from a file on the hard drive, you are not expected to concern yourself with turning on the drive’s motor or moving the read/write arms to the proper location over the disk’s surface. Coordinating all this hardware and software is the job of the operating system. In this course we will study the fundamentals of operating system design, including the operating system kernel, scheduling and concurrency, memory management, and file systems. (Carleton)

    CS 334: Database Systems (6) sys

    Database systems are used in almost every aspect of computing, including managing data for websites and apps, but also large-scale data science archives. Why, and how? This course takes a multi-pronged approach. From a systems perspective, we will look at the low-level details of how a database system works internally, studying data storage, indexing, and query optimization. From a theory perspective, we will examine ideas such as normal forms and relational algebra. From a utilization perspective, we will look at how query languages such as SQL interface with the database system, and understand how SQL queries really work. (Carleton)

    CS 338: Computer Security (6) sys

    When hackers can disable gas pipelines, national hospital systems, and electrical grids, and data brokers can create a largely unregulated world-wide surveillance system, there’s a clear need for people who understand the mechanisms of computer security and insecurity. Towards that end, in this course we will study technical and social aspects of computer and network security. Topics will include threat modeling, cryptography, secure network protocols, web security, ethical hacking and penetration testing, authentication, authorization, historical hacking incidents, usability, privacy, and security-related law. (Carleton)

    CS 348: Parallel and Distributed Computing (6) sys

    As multi-core machines become more prevalent, different programming paradigms have emerged for harnessing extra processors for better performance. This course explores parallel computation for both shared memory and distributed parallel programming paradigms. In particular, we will explore how these paradigms affect the code we write, the libraries we use, and the advantages and disadvantages of each. Topics will include synchronization primitives across these models for parallel execution, debugging concurrent programs, fork/join parallelism, example parallel algorithms, computational complexity and performance considerations, computer architecture as it relates to parallel computation, and related theory topics. (Carleton)

    16-299: Introduction to Feedback Control Systems (12) sys

    This course is designed as a first course in feedback control systems for computer science majors. Course topics include classical linear control theory (differential equations, Laplace transforms, feedback control), linear state-space methods (controllability/observability, pole placement, LQR), nonlinear systems theory, and an introduction to control using computer learning techniques. Priorities will be given to computer science majors with robotics minor. (CMU)

    15-319: Cloud Computing (12) sys

    This course gives students an overview of Cloud Computing, which is the delivery of computing as a service over a network, whereby distributed resources are rented, rather than owned, by an end user as a utility. Students will study its enabling technologies, building blocks, and gain hands-on experience through projects utilizing public cloud infrastructures. Cloud computing services are widely adopted by many organizations across domains. The course will introduce the cloud and cover the topics of data centers, software stack, virtualization, software defined networks and storage, cloud storage, and programming models. We will start by discussing the clouds motivating factors, benefits, challenges, service models, SLAs and security. We will describe several concepts behind data center design and management, which enable the economic and technological benefits of the cloud paradigm. Next, we will study how CPU, memory and I/O resources, network (SDN) and storage (SDS) are virtualized, and the key role of virtualization to enable the cloud. Subsequently, students will study cloud storage concepts like data distribution, durability, consistency and redundancy. We will discuss distributed file systems, NoSQL databases and object storage using HDFS, CephFS, HBASE, MongoDB, Cassandra, DynamoDB, S3, and Swift as case studies. Finally, students will study the MapReduce, Spark and GraphLab programming models. Students will work with Amazon Web Services and Microsoft Azure, to rent and provision compute resources and then program and deploy applications using these resources. Students will develop and evaluate scaling and load balancing solutions, work with cloud storage systems, and develop applications in several programming paradigms. 15619 students must complete an extra team project which entails designing and implementing a cost- and performance-sensitive web-service for querying big data. (CMU)

    15-330: Introduction to Computer Security (12) sys

    Security is becoming one of the core requirements in the design of critical systems. This course will introduce students to the intro-level fundamental knowledge of computer security and applied cryptography. Students will learn the basic concepts in computer security including software vulnerability analysis and defense, networking and wireless security, and applied cryptography. Students will also learn the fundamental methodology for how to design and analyze security critical systems. (CMU)

    15-346: Computer Architecture: Design and Simulation (12) sys

    This course will help students develop an understanding of basic microarchitectural principles and designs. Starting with creating benchmarks and simulators, students will learn the practice of computer architecture design. The emphasis will be on how processors exploit instruction-level parallelism for performance, as well as the supporting technologies such as caches and branch prediction that are required. Several frontiers of current research will be explored in energy efficiency and security threats. (CMU)

    15-348: Embedded Systems (9) sys

    This course is offered only at Carnegie Mellon's campus in Qatar. This course covers the broad range of foundational skills that apply across all embedded computer system application areas, from thermostats to self-driving vehicles. The emphasis is at the layer where hardware meets software. Topics include microcontroller hardware, assembly language, embedded C programming, analog I/O, timers, code optimization, interrupts, and concurrency. Real world engineering practices, constraints, and example applications are integrated throughout the course. Weekly hands-on hardware and software experiences with an industry-strength automotive embedded controller are coordinated with the lecture content to reinforce core skills. (CMU)

    15-349: Introduction to Computer and Network Security (9) sys

    This course is ONLY offered at Carnegie Mellon in Qatar. This course is meant to offer Computer Science undergraduate students in their junior or senior year a broad overview of the field of computer security. Students will learn the basic concepts in computer security including software vulnerability analysis and defense, networking and wireless security, applied cryptography, as well as ethical, legal, social and economic facets of security. Students will also learn the fundamental methodology for how to design and analyze security critical systems. (CMU)

    15-392: Special Topic: Secure Programming (9) sys

    This course provides a detailed explanation of common programming errors in C and C++ and describes how these errors can lead to software systems that are vulnerable to exploitation. The course concentrates on security issues intrinsic to the C and C++ programming languages and associated libraries. It does not emphasize security issues involving interactions with external systems such as databases and web servers, as these are rich topics on their own. Topics to be covered include the secure and insecure use of integers, arrays, strings, dynamic memory, formatted input/output functions, and file I/O. (CMU)

    15-405: Engineering Distributed Systems (9) sys

    This is a course for students with strong design and implementation skills who are likely to pursue careers as software architects and lead engineers. It may be taken by well-prepared undergraduates with excellent design and implementation skills in low-level systems programing. The course assumes a high level of proficiency in all aspects of operating system design and implementation. This course will help students prepare for leadership roles in creating and evolving the complex, large-scale computer systems that society will increasingly depend on in the future. The course will teach the organizing principles of such systems, identifying a core set of versatile techniques that are applicable across many system layers. Students will acquire the knowledge base, intellectual tools, hands-on skills and modes of thought needed to build well-engineered computer systems that withstand the test of time, growth in scale, and stresses of live use. Topics covered include: caching, prefetching, damage containment, scale reduction, hints, replication, hash-based techniques, and fragmentation reduction. A substantial project component is an integral part of the course. A high level of proficiency in systems programming is expected. If you do not have the 15-410 prerequisite you will need to get approval from the faculty. (CMU)

    15-410: Operating System Design and Implementation (15) sys

    Operating System Design and Implementation is a rigorous hands-on introduction to the principles and practice of operating systems. The core experience is writing a small Unix-inspired OS kernel, in C with some x86 assembly language, which runs on a PC hardware simulator (and on actual PC hardware if you wish). Work is done in two-person teams, and 'team programming' skills (source control, modularity, documentation) are emphasized. The size and scope of the programming assignments typically result in students significantly developing their design, implementation, and debugging abilities. Core concepts include the process model, virtual memory, threads, synchronization, and deadlock; the course also surveys higher-level OS topics including file systems, interprocess communication, networking, and security. Students, especially graduate students, who have not satisfied the prerequisite at Carnegie Mellon are strongly cautioned - to enter the class you must be able to write a storage allocator in C, use a debugger, understand 2's-complement arithmetic, and translate between C and x86 assembly language. The instructor may require you to complete a skills assessment exercise before the first week of the semester in order to remain registered in the class. Auditing: this course is usually full, and we generally receive many more requests to audit than we can accept. If you wish to audit, please have your advisor contact us before the semester begins to discuss your educational goals. (CMU)

    15-412: Operating System Practicum (912) sys

    The goal of this class is for students to acquire hands-on experience with operating-system code as it is developed and deployed in the real world. Groups of two to four students will select, build, install, and become familiar with an open-source operating system project; propose a significant extension or upgrade to that project; and develop a production-quality implementation meeting the coding standards of that project. Unless infeasible, the results will be submitted to the project for inclusion in the code base. Variations on this theme are possible at the discretion of the instructor. For example, it may be possible to work within the context of a non-operating-system software infrastructure project (window system, web server, or embedded network device kernel) or to extend a 15-410 student kernel. In some situations students may work alone. Group membership and unit count (9 units versus 12) will be decided by the third week of the semester. Contributing to a real-world project will involve engaging in some mixture of messy, potentially open-ended activities such as: learning a revision control system, writing a short design document, creating and updating a simple project plan, participating in an informal code review, synthesizing scattered information about hardware and software, classifying and/or reading large amounts of code written by various people over a long period of time, etc. (CMU)

    15-415: Database Applications (12) sys

    This course covers the fundamental topics for Database Management Systems: Database System Architectural Principles (ACID properties; data abstraction; external, conceptual, and internal schemata; data independence; data definition and data manipulation languages), Data models (entity-relationship and relational data models; data structures, integrity constraints, and operations for each data model; relational query languages: SQL, algebra, calculus), Theory of database design (functional dependencies; normal forms; dependency preservation; information loss), Query Optimization (equivalence of expressions, algebraic manipulation; optimization of selections and joins), Storage Strategies (indices, B-trees, hashing), Query Processing (execution of sort, join, and aggregation operators), and Transaction Processing (recovery and concurrency control). (CMU)

    15-418: Parallel Computer Architecture and Programming (12) sys

    The fundamental principles and engineering tradeoffs involved in designing modern parallel computers, as well as the programming techniques to effectively utilize these machines. Topics include naming shared data, synchronizing threads, and the latency and bandwidth associated with communication. Case studies on shared-memory, message-passing, data-parallel and dataflow machines will be used to illustrate these techniques and tradeoffs. Programming assignments will be performed on one or more commercial multiprocessors, and there will be a significant course project. (CMU)

    15-421: Information Security and Privacy (12) sys

    As layers upon layers of technology mediate our activities, issues of information security and privacy are becoming increasingly pervasive and complex. This course takes a multi-disciplinary perspective of information security and privacy, looking at technologies as well as business, legal, policy and usability issues. The objective is to prepare students to identify and address critical security and privacy issues involved in the design, development and deployment of robust computer and information systems. Examples used to introduce concepts covered in the class range from enterprise systems to mobile computing, the Internet of Things, social networking and digital currencies. (CMU)

    15-437: Web Application Development (12) sys

    This course will introduce concepts in programming web application servers. We will study the fundamental architectural elements of programming web sites that produce content dynamically. The primary technology introduced will be the Django framework for Python, but we will cover related topics as necessary so that students can build significant applications. Such topics include: HTTP, HTML, CSS, Javascript, XML, Design Patterns, Relational and Non-relational Databases, Object-Relation Mapping tools, Security, Web Services, Cloud Deployment, Internationalization, and Scalability and Performance Issues. Students must have programming and software design experience equivalent to about a typical Junior CS major and #8212;-a sequence of three college CS courses or more. Python-specific experience is not necessary. Students must provide their own computer hardware for this course. (CMU)

    15-440: Distributed Systems (12) sys

    The goals of this course are twofold: First, for students to gain an understanding of the principles and techniques behind the design of distributed systems, such as locking, concurrency, scheduling, and communication across the network. Second, for students to gain practical experience designing, implementing, and debugging real distributed systems. The major themes this course will teach include scarcity, scheduling, concurrency and concurrent programming, naming, abstraction and modularity, imperfect communication and other types of failure, protection from accidental and malicious harm, optimism, and the use of instrumentation and monitoring and debugging tools in problem solving. As the creation and management of software systems is a fundamental goal of any undergraduate systems course, students will design, implement, and debug large programming projects. As a consequence, competency in both the C and Java programming languages is required. (CMU)

    15-441: Networking and the Internet (12) sys

    The emphasis in this course will be on the basic performance and engineering trade-offs in the design and implementation of computer networks. To make the issues more concrete, the class includes several multi-week projects requiring significant design and implementation. The goal is for students to learn not only what computer networks are and how they work today, but also why they are designed the way they are and how they are likely to evolve in the future. We will draw examples primarily from the Internet. Topics to be covered include: network architecture, routing, congestion/flow/error control, naming and addressing, peer-to-peer and the web, internetworking, and network security. (CMU)

    15-445: Database Systems (12) sys

    This course is on the design and implementation of database management systems. Topics include data models (relational, document, key/value), storage models (n-ary, decomposition), query languages (SQL, stored procedures), storage architectures (heaps, log-structured), indexing (order preserving trees, hash tables), transaction processing (ACID, concurrency control), recovery (logging, checkpoints), query processing (joins, sorting, aggregation, optimization), and parallel architectures (multi-core, distributed). Case studies on open-source and commercial database systems will be used to illustrate these techniques and trade-offs. The course is appropriate for students with strong systems programming skills. (CMU)

    15-449: Engineering Distributed Systems (9) sys

    This is a course for students with strong design and implementation skills who are likely to pursue careers as software architects and lead engineers. It may be taken by well-prepared undergraduates with excellent design and implementation skills in low-level systems programing. The course assumes a high level of proficiency in all aspects of operating system design and implementation. This course will help students prepare for leadership roles in creating and evolving the complex, large-scale computer systems that society will increasingly depend on in the future. The course will teach the organizing principles of such systems, identifying a core set of versatile techniques that are applicable across many system layers. Students will acquire the knowledge base, intellectual tools, hands-on skills and modes of thought needed to build well-engineered computer systems that withstand the test of time, growth in scale, and stresses of live use. Topics covered include: caching, prefetching, damage containment, scale reduction, hints, replication, hash-based techniques, and fragmentation reduction. A substantial project component is an integral part of the course. A high level of proficiency in systems programming is expected. If you do not have the 15-410 prerequisite you will need to get approval from the faculty. (CMU)

    16-450: Robotics Systems Engineering (12) sys

    Systems engineering examines methods of specifying, designing, analyzing and testing complex systems. In this course, principles and processes of systems engineering are introduced and applied to the development of robotic devices. The focus is on robotic system engineered to perform complex behavior. Such systems embed computing elements, integrate sensors and actuators, operate in a reliable and robust fashion, and demand rigorous engineering from conception through production. The course is organized as a progression through the systems engineering process of conceptualization, specification, design, and prototyping with consideration of verification and validation. Students completing this course will engineer a robotic system through its compete design and initial prototype. The project concept and teams can continue into the Spring-semester (16-474 Robotics Capstone) for system refinement, testing and demonstration. (CMU)

    15-487: Introduction to Computer Security (12) sys

    This course will introduce students to the fundamentals of computer security and applied cryptography. Topics include software security, networking and wireless security, and applied cryptography. Students will also learn the fundamental methodology for how to design and analyze security critical systems. (CMU)

    CSDS 221: Full Stack Web Development (4) sys

    An introduction to full stack web development, the course provides foundations in HTML, CSS, and programming in JavaScript. The course introduces front-end technologies and APIs for creating interactive web applications such as Bootstrap, React.js, and Progressive Web Apps, back-end technologies and APIs for creating a web server such as Node.js and Express.js, and database integration technologies such as MySQL and MongoDB. Some background in algorithms, data structures, and databases is helpful but not required. (Case)

    CSDS 281: Logic Design and Computer Organization (4) sys

    Fundamentals of digital systems in terms of both computer organization and logic level design. Organization of digital computers; information representation; boolean algebra; analysis and synthesis of combinational and sequential circuits; datapaths and register transfers; instruction sets and assembly language; input/output and communication; memory. (Case)

    CSDS 285: Linux Tools and Scripting (3) sys

    A fast paced introduction to linux that brings the project-oriented student from little or no linux experience to be fully capable of using scripting languages as tools in a linux command-line environment. This includes systems administration and agile web services with server-side scripting and server-side management. This also involves data cleaning, scraping, wrangling, and processing user data with regular expressions. Current main languages include php, bash, awk, with some client-side javascript, and very brief looks at tcl/lua, powershell, and python. Tools include vim, make, grep/sed, and curl/wget. (Case)

    CSDS 305: Files, Indexes and Access Structures for Big Data (3) sys

    Database management become a central component of a modern computing environment, and, as a result, knowledge about database systems has become an essential part of education in computer science and data science. This course is an introduction to the nature and purpose of database systems, fundamental concepts for designing, implementing and querying a database and database architectures. Objectives: -An expert knowledge of basic data structures, basic searching, sorting, methods, algorithm techniques, (such as greedy and divide and conquer) -In-depth knowledge on Search and Index Structures for large, heterogeneous data including multidimensional data, high dimensional data and data in metric spaces (e.g., sequences, images), on different search methods (e.g. similarity searching, partial match, exact match), and on dimensionality reduction techniques. (Case)

    CSDS 312: Introduction to Data Science Systems (3) sys

    An introduction to the software and hardware architecture of data science systems, with an emphasis on Operating Systems and Computer Architecture that are relevant to Data Sciences systems. At the end of the course, the student should understand the principles and architecture of storage systems, file systems (especially, HDFS), memory hierarchy, and GPU. The student should have carried out projects in these areas, and should be able to critically compare various design decisions in terms of capability and performance. (Case)

    CSDS 314: Computer Architecture (3) sys

    This course provides students the opportunity to study and evaluate a modern computer architecture design. The course covers topics in fundamentals of computer design, performance, cost, instruction set design, processor implementation, control unit, pipelining, communication and network, memory hierarchy, computer arithmetic, input-output, and an introduction to RISC and super-scalar processors. Offered as CSDS 314 and ECSE 314. (Case)

    CSDS 325: Computer Networks I (3) sys

    An introduction to computer networks and the Internet. Applications: http, ftp, e-mail, DNS, socket programming. Transport: UDP, TCP, reliable data transfer, and congestion control. Network layer: IP, routing, and NAT. Link layer: taxonomy, Ethernet, 802.11. Offered as CSDS 325 and CSDS 325N. (Case)

    CSDS 325N: Computer Networks I (3) sys

    An introduction to computer networks and the Internet. Applications: http, ftp, e-mail, DNS, socket programming. Transport: UDP, TCP, reliable data transfer, and congestion control. Network layer: IP, routing, and NAT. Link layer: taxonomy, Ethernet, 802.11. Offered as CSDS 325 and CSDS 325N. (Case)

    CSDS 338: Intro to Operating Systems and Concurrent Programming (4) sys

    Intro to OS: OS Structures, processes, threads, CPU scheduling, deadlocks, memory management, file system implementations, virtual machines, cloud computing. Concurrent programming: fork, join, concurrent statement, critical section problem, safety and liveness properties of concurrent programs, process synchronization algorithms, semaphores, monitors. UNIX systems programming: system calls, UNIX System V IPCs, threads, RPCs, shell programming. Offered as CSDS 338, ECSE, 338, CSDS 338N and ECSE 338N. (Case)

    CSDS 338N: Intro to Operating Systems and Concurrent Programming (4) sys

    OS Structures, processes, threads, CPU scheduling, deadlocks, memory management, file system implementations, virtual machines, cloud computing. Concurrent programming: fork, join, concurrent statement, critical section problem, safety and liveness properties of concurrent programs, process synchronization algorithms, semaphores, monitors. UNIX systems programming: system calls, UNIX System V IPCs, threads, RPCs, shell programming. (Case)

    CSDS 341: Introduction to Database Systems (3) sys

    Relational model, ER model, relational algebra and calculus, SQL, OBE, security, views, files and physical database structures, query processing and query optimization, normalization theory, concurrency control, object relational systems, multimedia databases, Oracle SQL server, Microsoft SQL server. (Case)

    CSDS 341N: Introduction to Database Systems (3) sys

    Relational model, ER model, relational algebra and calculus, SQL, OBE, security, views, files and physical database structures, query processing and query optimization, normalization theory, concurrency control, object relational systems, multimedia databases, Oracle SQL server, Microsoft SQL server. (Case)

    CSDS 344: Computer Security (3) sys

    General types of security attacks; approaches to prevention; secret key and public key cryptography; message authentication and hash functions; digital signatures and authentication protocols; information gathering; password cracking; spoofing; session hijacking; denial of service attacks; buffer overruns; viruses, worms, etc., principles of secure software design, threat modeling; access control; least privilege; storing secrets; socket security; firewalls; intrusions; auditing; mobile security. (Case)

    CSDS 377: Introduction to Connected Devices (3) sys

    Introduction to Connected Devices (e.g., Internet of Things). Undergraduates work in pairs to build a complete connected-device system, an embedded device with wireless networking, cloud and web, and mobile, and then develop hands-on experience with systems-level aspects of the connected-device system, including analytics, remote firmware update, load testing, and essential security. (Case)

    CSDS 392: App Development for iOS (3) sys

    This course is an introduction to app development for iPhone and iPad using Cocoa Touch Framework and Xcode development environment. (Case)

    CSDS 425: Computer Networks I (3) sys

    An introduction to computer networks and the Internet. Applications: http, ftp, e-mail, DNS, socket programming. Transport: UDP, TCP, reliable data transfer, and congestion control. Network layer: IP, routing and NAT. Link layer: taxonomy, Ethernet, 802.11. (Case)

    CSDS 427: Internet Security and Privacy (3) sys

    This course introduces students to research on Internet security and privacy. Covered topics include denial of service attacks, attacks enabled by man-in-the-middle surveillance, communication hijacking, botnet and fast-flux networks, email and Web spam, threats to privacy on the Internet, and Internet censorship. The course will be based on a collection of research papers. Students will be required to attend lectures, read the materials, prepare written summaries of discussed papers, present a paper in class, complete a course project and take the final exam (in the form of the course project presentation). (Case)

    CSDS 428: Computer Communications Networks II (3) sys

    Introduction to topics and methodology in computer networks and middleware research. Traffic characterization, stochastic models, and self-similarity. Congestion control (Tahoe, Reno, Sack). Active Queue Management (RED, FQ) and explicit QoS. The Web: overview and components, HTTP, its interaction with TCP, caching. Overlay networks and CDN. Expected work includes a course-long project on network simulation, a final project, a paper presentation, midterm, and final test. (Case)

    CSDS 433: Database Systems (3) sys

    Basic issues in file processing and database management systems. Physical data organization. Relational databases. Database design. Relational Query Languages, SQL. Query languages. Query optimization. Database integrity and security. Object-oriented databases. Object-oriented Query Languages, OQL. (Case)

    CSDS 438: High Performance Data and Computing (3) sys

    High performance data and computing (HPDC) leverages parallel processing in order to maximize speed and throughput. This hands-on course will cover theoretical and practical aspects of HPDC. Theoretical concepts covered include computer architecture, parallel programming, and performance optimization. Practical applications will be discussed from various information and scientific fields. Practical considerations will include HPDC job management and Unix scripting. Weekly assessments and a course project will be required. (Case)

    CSDS 444: Computer Security (3) sys

    General types of security attacks; approaches to prevention; secret key and public key cryptography; message authentication and hash functions; digital signatures and authentication protocols; information gathering; password cracking; spoofing; session hijacking; denial of service attacks; buffer overruns; viruses, worms, etc., principles of secure software design, threat modeling; access control; least privilege; storing secrets; socket security; firewalls; intrusions; auditing; mobile security. (Case)

    CSDS 448: Smartphone Security (3) sys

    This course is designed to better prepare undergraduate and graduate students for researching and developing in the neighborhood of mobile and software security. Lectures, paper readings and presentations, in-class discussions, and projects are the main components. The course covers the basics of Android programming and a wide range of security issues and solutions concerning mobile platforms, including permission analysis, textual artifacts analysis, malware analysis, program analysis, and UI analysis. Students should expect one literature survey paper and one system-building or empirical study project on one selected security solution in mobile app security. (Case)

    CSDS 451: Designing High Performant Systems for AI (3) sys

    The objective of the course is to give a broad overview of the challenges and opportunities that exist in designing high performance AI systems. In addition, a course project will allow students to delve deeper into a topic of their interest. The course is designed to cater to two types of audiences: students working on data science projects who want to understand how to perform faster training or inference of their AI/ML models, or students working on parallel algorithms, or hardware acceleration, who want to understand modern techniques for accelerating data science applications. On the theory side, the course will cover basics and some recent advances in improving the performance of state-of-the-art AI/ML techniques including Convolutional Neural Networks (CNN), Graph Machine Learning (GML), and Transformer based Natural Language Models (NLM). Additionally, a high-level discussion of recently developed custom AI accelerators such as Microsoft's NPU, or Cerebras will be covered. On the practical side, the course will cover programming models and frameworks for accelerating these models. These will include parallel programming techniques in PyTorch (for CNN and NLM acceleration), Framework for Graph ML such as Deep Graph Library, and heterogeneous computing frameworks such as OpenMP, and DPC++. The focus will be primarily on algorithmic optimizations as opposed to device specific optimizations. While the course lectures will cover the breadth of the domain, students will be able to explore the depth of a single topic of their choice by a course project. (Case)

    CSDS 456: Data Privacy (3) sys

    Introduction to privacy, economics and incentives, crypto-based solution for privacy, hiding data from the database user, hiding access patterns from the database owner, anonymous routing and TOR, privacy in online social networks, privacy in cellular and Wi-Fi networks, location privacy, privacy in e-cash systems, privacy in e-voting, genomic privacy. (Case)

    CP275: Computer Organization (1) sys

    Exploration of the design and organization of computer processors, memory, and operating systems. Topics include processor architecture, digital circuits, memory management, scheduling, file systems, assembly language, and peripheral device control. (Colorado)

    CP342: Distributed Systems (1) sys

    Fundamentals of network design and interaction of computing systems. Topics include network protocols, security, synchronization, transactions, and network programming. Bredin. (Not offered 2024-25). (Colorado)

    CP344: Database Systems (1) sys

    Introduction to data base management systems including the design, implementation, and analysis of data bases. Topics include relational models, concurrent access, data mining, and SQL programming. (Not offered 2024-25). (Colorado)

    COMS W3157: Advanced Programming (4) sys

    C programming language and Unix systems programming. Also covers Git, Make, TCP/IP networking basics, C fundamentals (Columbia)

    CSEE W3827: Fundamentals of Computer Systs. (3) sys

    Fundamentals of computer organization and digital logic. Boolean algebra, Karnaugh maps, basic gates and components, flipflops and latches, counters and state machines, basics of combinational and sequential digital design. Assembly language, instruction sets, ALU’s, single-cycle and multi-cycle processor design, introduction to pipelined processors, caches, and virtual memory (Columbia)

    COMS W4111: Introduction to Databases (3) sys

    The fundamentals of database design and application development using databases: entity-relationship modeling, logical design of relational databases, relational data definition and manipulation languages, SQL, XML, query processing, physical database tuning, transaction processing, security. Programming projects are required (Columbia)

    COMS W4112: Database System Implementation (3) sys

    The principles and practice of building large-scale database management systems. Storage methods and indexing, query processing and optimization, materialized views, transaction processing and recovery, object-relational databases, parallel and distributed databases, performance considerations. Programming projects are required (Columbia)

    COMS W4113: Fund-Large-Scale Dist Systems (3) sys

    Design and implementation of large-scale distributed and cloud systems. Teaches abstractions, design and implementation techniques that enable the building of fast, scalable, fault-tolerant distributed systems. Topics include distributed communication models (e.g. sockets, remote procedure calls, distributed shared memory), distributed synchronization (clock synchronization, logical clocks, distributed mutex), distributed file systems, replication, consistency models, fault tolerance, distributed transactions, agreement and commitment, Paxos-based consensus, MapReduce infrastructures, scalable distributed databases. Combines concepts and algorithms with descriptions of real-world implementations at Google, Facebook, Yahoo, Microsoft, LinkedIn, etc (Columbia)

    COMS W4118: Operating Systems I (3) sys

    Design and implementation of operating systems. Topics include process management, process synchronization and interprocess communication, memory management, virtual memory, interrupt handling, processor scheduling, device management, I/O, and file systems. Case study of the UNIX operating system. A programming project is required (Columbia)

    COMS W4119: Computer Networks (3) sys

    Introduction to computer networks and the technical foundations of the internet, including applications, protocols, local area networks, algorithms for routing and congestion control, security, elementary performance evaluation. Several written and programming assignments required (Columbia)

    COMS W4121: Computer Systems for Data Science (3) sys

    An introduction to computer architecture and distributed systems with an emphasis on warehouse scale computing systems. Topics will include fundamental tradeoffs in computer systems, hardware and software techniques for exploiting instruction-level parallelism, data-level parallelism and task level parallelism, scheduling, caching, prefetching, network and memory architecture, latency and throughput optimizations, specialization, and an introduction to programming data center computers (Columbia)

    COMS W4181: Security I (3) sys

    Introduction to security. Threat models. Operating system security features. Vulnerabilities and tools. Firewalls, virtual private networks, viruses. Mobile and app security. Usable security. (Columbia)

    COMS W4182: Security II (3) sys

    Advanced security. Centralized, distributed, and cloud system security. Cryptographic protocol design choices. Hardware and software security techniques. Security testing and fuzzing. Blockchain. Human security issues. (Columbia)

    COMS W4186: Malware Analysis&reverse Engineering (3) sys

    Hands-on analysis of malware. How hackers package and hide malware and viruses to evade analysis. Disassemblers, debuggers, and other tools for reverse engineering. Deep study of Windows Internals and x86 assembly (Columbia)

    COMS W4419: Internet Technology, Economics, and Policy (3) sys

    Technology, economic and policy aspects of the Internet. Summarizes how the Internet works technically, including protocols, standards, radio spectrum, global infrastructure and interconnection. Micro-economics with a focus on media and telecommunication economic concerns, including competition and monopolies, platforms, and behavioral economics. US constitution, freedom of speech, administrative procedures act and regulatory process, universal service, role of FCC. Not a substitute for CSEE4119. Suitable for non-majors. May not be used as a track elective for the computer science major. (Columbia)

    COMS W4824: Computer Architecture (3) sys

    (Columbia)

    CSEE W4824: Computer Architecture (3) sys

    Focuses on advanced topics in computer architecture, illustrated by case studies from classic and modern processors. Fundamentals of quantitative analysis. Pipelining. Memory hierarchy design. Instruction-level and thread-level parallelism. Data-level parallelism and graphics processing units. Multiprocessors. Cache coherence. Interconnection networks. Multi-core processors and systems-on-chip. Platform architectures for embedded, mobile, and cloud computing (Columbia)

    COMS W4835: Computer Organization II (3) sys

    (Columbia)

    CSEE W4868: System-On-Chip Platforms (3) sys

    Design and programming of System-on-Chip (SoC) platforms. Topics include: overview of technology and economic trends, methodologies and supporting CAD tools for system-level design, models of computation, the SystemC language, transaction-level modeling, software simulation and virtual platforms, hardware-software partitioning, high-level synthesis, system programming and device drivers, on-chip communication, memory organization, power management and optimization, integration of programmable processor cores and specialized accelerators. Case studies of modern SoC platforms for various classes of applications. (Columbia)

    CS 2043: UNIX Tools and Scripting (2) sys

    Spring. 2 credits. S/U grades only. R. DiNapoli. UNIX and UNIX-like systems are increasingly being used on personal computers, mobile phones, web servers, and many other systems. They represent a wonderful family of programming environments useful both to computer scientists and to people in many other fields, such as computational biology and computational linguistics, in which data is naturally represented by strings. This course takes students from shell basics and piping, to regular-expression processing tools, to shell scripting and Python. Other topics to be covered include handling concurrent and remote resources, manipulating streams and files, and managing software installations. (Cornell)

    CS 3300: Data-Driven Web Applications (3) sys

    For description, see INFO 3300. (Cornell)

    CS 3410: Computer System Organization and Programming (4) sys

    Introduction to computer organization, systems programming and the hardware/ software interface. Topics include instruction sets, computer arithmetic, datapath design, data formats, addressing modes, memory hierarchies including caches and virtual memory, I/O devices, bus-based I/O systems, and multicore architectures. Students learn assembly language programming and design a pipelined RISC processor. (Cornell)

    CS 3420: Embedded Systems (4) sys

    For description, see ECE 3140. (Cornell)

    CS 4320: Introduction to Database Systems (3) sys

    Introduction to modern database and data storage systems. (Cornell)

    CS 4321: Practicum in Database Systems (2) sys

    Students build part of a database system in Java. (Cornell)

    CS 4410: Operating Systems (3) sys

    Introduction to the design of systems programs, with emphasis on multiprogrammed operating systems. (Cornell)

    CS 4411: Practicum in Operating Systems (2) sys

    Studies the practical aspects of operating systems through the design and implementation of an operating system kernel. (Cornell)

    CS 4414: Systems Programming (3) sys

    CS 4414 exposes students to programming applications at the systems level. (Cornell)

    CS 4420: Computer Architecture (4) sys

    For description, see ECE 4750. (Cornell)

    CS 4450: Introduction to Computer Networks (3) sys

    This course introduces the basic architectural and design principles of computer networking. (Cornell)

    CS 5412: Cloud Computing (4) sys

    Focuses on cloud computing, large-scale Internet applications, and other practical issues in designing and implementing trustworthy, scalable distributed software. (Cornell)

    CS 5414: Distributed Computing Principles (4) sys

    Studies the abstractions and algorithms that constitute the foundations for implementing concurrent and distributed computing, with emphasis on supporting fault-tolerance. (Cornell)

    COSC 51: Computer Architecture (1) sys

    The architecture and organization of a simple computer system is studied. Topics covered include how information is represented in memory, machine-language instructions and how they can be implemented at the digital logic level and microcode level, assembly language programming, and input/output operations. Speedup techniques, such as pipelining and caching, are also covered. (Dartmouth)

    COSC 52: Full-Stack Web Development (1) sys

    The Web is a powerful delivery tool for complex real-time applications. This is an introduction to full stack Web application development — the approach of integrating numerous techniques and technologies to build modern Web applications. Topics include: static pages, Internet protocols, layout, markup, event-driven asynchronous programming, deployment, security, scalability, and user experience. Projects include building real-time Web applications with front-end UIs and server-side APIs. (Dartmouth)

    COSC 55: Security and Privacy (1) sys

    The migration of important social processes to distributed, electronic systems raises critical security and privacy issues. Precisely defining security and privacy is difficult; designing and deploying systems that provide these properties is even harder. This course examines what security and privacy mean in these settings, the techniques that might help, and how to use these techniques effectively. Our intention is to equip computer professionals with the breadth of knowledge necessary to navigate this emerging area. (Dartmouth)

    COSC 56: Digital Electronics (1) sys

    This course teaches classical switching theory including Boolean algebra, logic minimization, algorithmic state machine abstractions, and synchronous system design. This theory is then applied to digital electronic design. Techniques of logic implementation, from Small Scale Integration (SSI) through Application-Specific Integrated Circuits (ASICs), are encountered. There are weekly laboratory exercises for the first part of the course followed by a digital design project in which the student designs and builds a large system of his or her choice. In the process, Computer-Aided Design (CAD) and construction techniques for digital systems are learned. (Dartmouth)

    COSC 58: Operating Systems (1) sys

    This course studies how computer operating systems allocate resources and create virtual machines for the execution of user jobs. Topics covered include storage management, scheduling, concurrent processing, shared access to files, synchronization, and data protection. Both abstract models and actual examples of operating systems will be studied. (Dartmouth)

    COSC 60: Computer Networks (1) sys

    This course focuses on the communications protocols used in computer networks: their functionality, specification, verification, implementation, and performance; and how protocols work together to provide more complex services. Aspects of network architectures are also considered. Laboratory projects are an integral part of the course in which networking concepts are explored in depth. (Dartmouth)

    COSC 61: Database Systems (1) sys

    This course studies the management of large bodies of data or information. This includes schemes for the representation, manipulation, and storage of complex information structures as well as algorithms for processing these structures efficiently and for retrieving the information they contain. This course will teach the student techniques for storage allocation and deallocation, retrieval (query formulation), and manipulation of large amounts of heterogeneous data. (Dartmouth)

    COSC 62: Applied Cryptography (1) sys

    Cryptography is the fundamental building block for establishing and maintaining trustworthy connections and communications in the Internet; it's the first line of defense for keeping adversaries from spying on credit card numbers being sent to Amazon or on whistleblower reports sent to journalists. This course will examine what's in this toolkit: symmetric ciphers, public-key cryptography, hash functions, pseudorandomness. (Dartmouth)

    COSC 63: Programming Parallel Systems (1) sys

    Multi-core processors are now ubiquitous in most personal computers. These are the fundamental computer-engineering building blocks for high-performance servers, blade farms, and cloud computing. In order to utilize these devices in large systems they must be interconnected through networking and collectively programmed. This hands-on system-engineering course offers students the opportunity to explore problem-solving techniques on a high-performance multi-computer containing quad-core processors. (Dartmouth)

    COSC 65: Smartphone Programming (1) sys

    This course teaches students how to design, implement, test, debug and publish smartphone applications. Topics include development environment, phone emulator, key programming paradigms, UI design including views and activities, data persistence, messaging and networking, embedded sensors, location based services (e.g., Google Maps), cloud programming, and publishing applications. Concepts are reinforced through a set of weekly programming assignments and group projects. (Dartmouth)

    COSC 68: Advanced Operating Systems (1) sys

    This course covers advanced topics in operating systems, including issues such as thehardware/software interface, operating-system structure, CPU scheduling, concurrency, virtual memory, interprocess communication, file systems, protection, security, fault tolerance, and transaction processing. The course also considers many of these topics in the context of distributed systems. (Dartmouth)

    COSC 19.02: Security Engineering (1) sys

    This course covers cybersecurity systems engineering principles of design. Topics include cybersecurity risk assessment, intrusion detection design, cybersecurity situational understanding, and more. Students learn to think like cyberattackers and design effective cybersecurity systems. (Dartmouth)

    COSC 69.08: All Things Wireless (1) sys

    This is a topics course about use and development of wireless devices. (Dartmouth)

    COSC 69.11: Mobile X (1) sys

    Mobile X is an upper-level course on mobile computing and ubiquitous systems, covering a broad range of advanced and interdisciplinary topics in mobile systems, networking, and applications. All these topics focus on tackling unique challenges faced on bringing computation, networking, and applications to the mobile computing platform -- a platform that is constrained in form factor, energy, and computation power. Example topics include mobile communication and networking, mobile human-to-computer interaction (HCI), mobile learning/AI, mobile health, and mobile security. (Dartmouth)

    COSC 69.16: Basics of Reverse Engineering (1) sys

    Frequently, the source code for an important operating system component, malware, or piece of commercial software is not available. This course explores the art and science of reverse engineering such systems to discover how they work, how they connect to other systems, and how they may be controlled. In this course, you will develop an understanding of how systems and development tool chains are built 'under the hood'. You will learn to read compiled binaries without available source code, to recover program logic, and to modify (de)compiled binaries. We will seek to understand the challenges of reverse engineering larger programs, and of automating reverse engineering. (Dartmouth)

    COSC 89.25: GPU Programming and High Performance Computing (1) sys

    The GPU Computing course introduces students to the basic programming and algorithmic techniques for developing the modern parallel computer code for high-performance computing applications. Course topics will cover the fundamentals for GPU (CUDA) and CPU (multi-threading) parallel programming, parallel computer architecture, parallel data structures, parallelizable linear algebra, conjugate gradient and multigrid solvers, particle systems and N-body problems, and vectorization. The materials will be illustrated using large-scale computing examples and applications from computer graphics, computational physics, and machine learning. (Dartmouth)

    COSC 89.26: Security and Privacy in the Lifecycle of IoT for Consumer Environments (1) sys

    We are entering an era of Smart Things, in which everyday objects become imbued with computational capabilities and the ability to communicate with each other and with services across the Internet. Indeed, the Internet of Things now involves the deployment of Smart Things in everyday residential environments – houses, apartments, hotels, senior-living facilities – resulting in Smart Homes. Although Smart Things offer many potential benefits, they can also create unsafe conditions and increase risk of harm to persons and property. This course explores the key security and privacy challenges required for the vision of Smart Homes to be safely realized, with an explicit focus on consumer-facing “things” where end-user privacy and usability are essential. It will take a holistic approach to the entire lifecycle of security, privacy, and usability challenges from the perspective of the everyday consumer who interacts with Smart Things (intentionally or unintentionally) in a residential setting. Students will read, present, and discuss papers from the research literature; write a survey paper about a subset of the research literature; and conduct a security analysis of a current commercial “smart thing”. Guest lecturers will join the class, weekly, to share expertise from both industry and research. (Dartmouth)

    CPS 242: Computer Organization (1) sys

    This course covers the basic instruction set, architecture, and organization of a modern computer. Fundamentals of translating higher-level languages into assembly language, and interpretation of machine languages by hardware are studied. A model of computer hardware organization is developed from the gate level upward. Topics include logic circuits, micro-architectures and microprogramming, machine architectures, and software-hardware interface issues. (F&M)

    CPS 340: Mobile Application Development (1) sys

    This course will introduce you to writing applications for the Android platform. The purpose of this course is not to narrowly teach proficiency of Android “App” development, but rather to teach proficiency in learning how to develop applications on a platform that is new to you. Mobile applications on Android will merely serve as a vehicle to achieve this. Throughout the course we will strive to achieve several goals: (a) refine your programming skills in general by solving practical problems that are apt for a mobile platform like Android, (b) learn the fundamentals of Android application development (c) refine your knowledge of the java programming language, and (d) prepare you for the job market after graduation. (F&M)

    CPS 342: Operating Systems (1) sys

    Operating systems is the natural extension of the material covered in CPS 242 Computer Organization. Fundamental computing is performed using transistors and digital logic gates. Operating systems explores how we make those basic principles function in a practical, intuitive, and efficient way for general purpose use. The primary functionality of the operating system is to provide a layer between the hardware and software so that the hardware resources can be shared between multiple pieces of software at once. This class will explore this functionality in depth separated into five pillars: (1) Bare Metal Programming, (2) Processes and Threads, (3) Memory Management, (4) File Systems, and (5) Input / Output Devices. (F&M)

    CPS 344: Computer Networks (1) sys

    This course provides an in-depth understanding of how computer networks operate, enabling global communication between billions of computers. Students will learn about the layered network architecture, which separates concerns for effective functioning. Beginning with higher-level topics such as website operation, the course progresses to the lower-level details of data transportation in the physical world. The course textbook follows a top-down approach and will be used extensively. Overall, this course will provide a comprehensive understanding of computer networks and their functioning. (F&M)

    CS 2110: Computer Organization and Programming (4) sys

    An introduction to basic computer hardware, machine language, assembly language, and C programming. (Georgia Tech)

    CS 2200: Computer Systems and Networks (4) sys

    A broad exposure to computer system structure and networking including software abstractions in operating systems for orchestrating the usage of the computing resources. (Georgia Tech)

    CS 2261: Media Device Architectures (4) sys

    Controlling the interface between hardware and software in media devices. Machine-level programming (e.g., in C) to create graphics, generate sound, and support user interaction. (Georgia Tech)

    CS 3210: Design of Operating Systems (3) sys

    Operating systems concepts, including multi-threading, scheduling, synchronization, communication, and access control. Projects will cover design and implementation of several operating systems components. (Georgia Tech)

    CS 3220: Computer Structures: Hardware/Software Codesign of a Processor (3) sys

    Principles in pipelined processor design, with emphasis on the need for a close interaction between code generation and architecture. (Georgia Tech)

    CS 3235: Introduction to Information Security (3) sys

    Terms/concepts for threats; controls; problem definition; comprehensive information security model; security for operating systems, databases, network/distributed systems; administering security. (Georgia Tech)

    CS 3237: Human Dimension of Cybersecurity: People, Organizations, Societies (3) sys

    This course will illuminate the human dimension of cybersecurity, and explore the attitudes, behaviors and perceptions associated with different stakeholders in cybersecurity. (Georgia Tech)

    CS 3251: Computer Networking I (3) sys

    Introduction to problems in computer networking, including error recovery, medium access, routing, flow control, and transport. Emphasis on current best practice. Includes programming of networked applications. (Georgia Tech)

    CS 4117: Introduction to Malware Reverse Engineering (4) sys

    This course exposes students to an immersive, hands-on experience in the dissection and analysis of the code, structure, and functionality of malicious software. (Georgia Tech)

    CS 4210: Advanced Operating Systems (3) sys

    Operating system abstractions and their implementations, multi-threading, efficient inter-address communication, high-level synchronization, introduction to multi-processor and distributed operating systems, real-time systems. Credit is not awarded for both CS 4210 and CS 6210. (Georgia Tech)

    CS 4220: Programming Embedded Systems (3) sys

    Design principles, programming techniques, and case studies of embedded real-time systems. Interface techniques and devices. Representations and reasoning about physical processes.Credit not awarded for both CS 4220 and CS 6235. (Georgia Tech)

    CS 4233: Parallel Computer Architecture (3) sys

    The objective of this course is to develop an in-depth understanding of the design, implementation, and evaluation of modern parallel computers. Credit not allowed for both CS 4233 and CS 7110. (Georgia Tech)

    CS 4235: Introduction to Information Security (3) sys

    Terms/concepts, threats, controls; problem definition; comprehensive information security model; security for operating systems, databases, network/distributed systems; administering security; legal/ethical/policy issues. Credit not allowed for both CS 4235 and CS 6035. (Georgia Tech)

    CS 4237: Computer and Network Security (3) sys

    Fundamental concepts and principles of computer security, operating system and database security, secret key and public key cryptographic algorithms, hash functions, authentication, firewalls and intrusion detection systems, IPSec ad VPN, and wireless security. (Georgia Tech)

    CS 4238: Computer Systems Security (3) sys

    Trusted computing base, hardware support for protection and virtualization, authentication, access control and authorization, discretionary and mandatory security policies, secure kernel design, and secure databases. Students cannot receive credit for CS 4238 and CS 6238. (Georgia Tech)

    CS 4239: Enterprise Cybersecurity Management (3) sys

    The duties and concerns of an enterprise Chief Information Security Officer including strategy, cybersecurity operations, risk management, and governance. (Georgia Tech)

    CS 4251: Computer Networking II (3) sys

    Principles of computer networks, including medium access, ARQ protocols, routing, congestion avoidance, and control. Emphasis on design options and tradeoffs. Includes significant network application programming. (Georgia Tech)

    CS 4255: Introduction to Network Management (3) sys

    Introduction to SNMP-based network management. Practical application to network and system management including hands-on lab practice. (Georgia Tech)

    CS 4261: Mobile Applications and Services for Converged Networks (3) sys

    This course provides an introduction to mobile applications and services with an emphasis on voice and data service integration in modern commercial networks. (Georgia Tech)

    CS 4262: Network Security (3) sys

    Fundamental concepts of network information security, including applied cryptography, secure access methods, and vulnerabilities in network protocols and network applications. Students cannot receive credit for CS 4262 and CS 6262. (Georgia Tech)

    CS 4263: Psychology of Cybersecurity (3) sys

    This course will explore psychological processes relevant to cybersecurity. Students will gain an appreciation for psychological influence factors inherent in the current cyberspace environment. (Georgia Tech)

    CS 4265: Technical Introduction to Blockchain and Cryptocurrencies (3) sys

    Undergraduate Introduction to Blockchain and cryptocurrencies, building on formal crypto and distributed systems. Cover fundamental and practical aspects. Includes programming projects and a report. (Georgia Tech)

    CS 4267: Critical Infrastructures Security and Resilience (3) sys

    Critical infrastructures are large cyber-physical networks essential to the well-being of the societies they serve. We study their resilience and security against a range of disruptions. (Georgia Tech)

    CS 4270: Data Communications Laboratory (3) sys

    Detailed study of the principles of data transmission systems and their performance, reinforced by laboratory exercises. (Georgia Tech)

    CS 4290: Advanced Computer Organization (3) sys

    Topics concerning the hardware design of computer systems. Advanced techniques in high-performance pipelined central processing units. Memory and I/O systems. Parallel processors including shared-memory multiprocessors and cluster computers. (Georgia Tech)

    CS 4365: Introduction to Enterprise Computing (3) sys

    A survey of basic software tools and techniques used in mission-critical systems and applications, combined with in-depth study of fundamental principles underlying enterprise computing. (Georgia Tech)

    CS 4400: Introduction to Database Systems (3) sys

    Comprehensive coverage of mainstream database concepts such as the entity-relationship model, relational databases, query languages, and database design methodology. Includes a project. (Georgia Tech)

    CS 4420: Database System Implementation (3) sys

    Study of fundamental software components/algorithms of a database system, including the file manager, query engine, lock manager, and recovery manager. Includes a project component. (Georgia Tech)

    CS 4440: Emerging Database Technologies and Applications (3) sys

    The course will cover current developments including distributed, object-oriented, temporal-spatial, Web-based, mobile, and active database technologies, and data warehousing and mining applications. (Georgia Tech)

    CS 4560: Verification of Systems (3) sys

    Technique for verifying, validating and testing software and hardware systems. Topics covered will include modeling, abstraction methods, evaluation and certification, and computer-aided verification methods. (Georgia Tech)

    CS 4605: Mobile and Ubiquitous Computing (3) sys

    Investigates the infrastructure required to develop mobile and ubiquitous computing applications and establishes major research themes and experimental practices. (Georgia Tech)

    CS 4675: Internet Computing Systems, Services and Applications (3) sys

    Focusing on fundamental issues, concepts, techniques, and technical challenges that are critical for designing and developing Internet systems, services and applications. (Georgia Tech)

    CS 4685: Pervasive Systems and Networking (3) sys

    In-depth study of systems and wireless networking issues in enabling pervasive computing environments and applications using a hand-on approach. (Georgia Tech)

    CS 4725: Information Security Strategies and Policies (3) sys

    Information security vulnerabilities and risks; legal, cost, privacy, and technology constraints; derivation of strategies; technical and procedural means of achieving desired results. (Georgia Tech)

    COMPSCI 61: Systems Programming and Machine Organization (4) sys

    Fundamentals of computer systems programming, machine organization, and performance tuning. This course provides a solid background in systems programming and a deep understanding of low-level machine organization and design. Topics include C and assembly language programming, program optimization, memory hierarchy and caching, virtual memory and dynamic memory management, concurrency, threads, and synchronization. (Harvard)

    COMPSCI 1410: Computing Hardware (4) sys

    This course delves into the design principles and practices of high performance digital computing systems that are cost effectively and reliably manufactured with billions of near atomic scale semiconductor components. Key abstractions and foundational concepts are emphasized as the course covers the basic operation of CMOS transistors and logic gates, combinational and sequential logic including Finite State Machines (FSMs), digital memory subsystems, and machine code culminating with the implementation of a MIPS processor. Lab assignments will focus on the practical aspects of digital hardware design by utilizing Field Programmable Gate Arrays (FPGAs), Verliog (Hardware Description Language) and advanced CAD tools for the design, simulation and verification of digital computing hardware. (Harvard)

    COMPSCI 1411: Computer Architecture (4) sys

    Review of the fundamental structures in modern processor design. Topics include computer organization, memory system design, pipelining, and other techniques to exploit parallelism. Discussion of modern topics including GPU architectures, datacenter architecture, mobile/embedded SoC architectures, and machine learning acceleration as time permits. Emphasis on a quantitative evaluation of design alternatives and an understanding of performance and energy consumption issues. (Harvard)

    COMPSCI 1430: Computer Networks (4) sys

    Computer networking has enabled the emergence of mobile and cloud computing, creating two of the most significant technological breakthroughs in computing. Computer networks have become even more critical these days since remote activities have become a new norm. We expect several focuses in the coming years. First, we will witness the emergence of 5G wireless mobile networks, which have already begun to replace the current 4G networks. Second, cybersecurity and privacy will receive unprecedented attention from the industry. Third, blockchain technology, which underlies Bitcoin, creates a new trusted network infrastructure for many new distributed applications. Fourth, distance learning and virtual meetings will push the limits of current multicast and network management technologies. In this course, students will learn basic networking protocols as well as these timely topics. (Harvard)

    COMPSCI 1450: Networking at Scale (4) sys

    This course studies computer network topics including Layer 2/Layer 3 topology, routing, transport protocols, traffic engineering, network functions, programmable switches, and software-defined networking. Modern networks have grown to large scale (connecting millions of servers) and high speed (terabits per second) to meet the needs of cloud applications in business and society. Thus, in addition to learning the conventional concepts in networking, we will also discuss how to adapt these concepts to large-scale networks. These discussions will hopefully help deepen our understanding of networking technologies. This course includes lectures and system programming projects. (Harvard)

    COMPSCI 1610: Operating Systems (4) sys

    This course focuses on the design and implementation of modern operating systems. The course discusses threads, processes, virtual memory, schedulers, and the other fundamental primitives that an OS uses to represent active computations. An exploration of the system call interface explains how applications interact with hardware and other programs which are concurrently executing. Case studies of popular file systems reveal how an OS makes IO efficient and robust in the midst of crashes and unexpected reboots. Students also learn how virtualization allows a physical machine to partition its resources across multiple virtual machines. Class topics are reinforced through a series of intensive programming assignments which use a real operating system. (Harvard)

    COMPSCI 1650: Data Systems (4) sys

    We are in the big data era and data systems sit in the critical path of everything we do. We are going through major transformations in businesses, sciences, as well as everyday life - collecting and analyzing data changes everything and data systems provide the means to store and analyze a massive amount of data. This course is a comprehensive introduction to modern data systems. The primary focus of the course is on the modern trends that are shaping the data management industry right now: column-store and hybrid systems, shared nothing architectures, cache conscious algorithms, hardware/software co-design, main-memory systems, adaptive indexing, stream processing, scientific data management, and key-value stores. We also study the history of data systems, traditional and seminal concepts and ideas such as the relational model, row-store database systems, optimization, indexing, concurrency control, recovery and SQL. In this way, we discuss both how and why data systems evolved over the years, as well as how these concepts apply today and how data systems might evolve in the future. We focus on understanding concepts and trends rather than specific techniques that will soon be outdated - as such the class relies largely on recent research material and on a semi-flipped class model with a lot of hands-on interaction in each class. (Harvard)

    COMPSCI 2050: High Performance Computing for Science and Engineering (4) sys

    With manufacturing processes reaching the limits in terms of transistor density on today’s computing architectures, efficient modern code must exploit parallel execution to maintain scaling of available hardware resources. The use of computers in academia, industry and society is a fundamental tool for solving (scientific) problems while the 'think parallel' mindset of code developers is still lagging behind. The aim of this course is to introduce the student to the fundamentals of parallel programming and its relationship on computer architectures. Various forms of parallelism are discussed and exploited through different programming models with focus on shared and distributed memory programming. The learned techniques are tried out by means of homework, lab sessions and a term project. (Harvard)

    COMPSCI 2411: Advanced Computer Architecture (4) sys

    Review of the fundamental structures in modern processor design. Topics include computer organization, memory system design, pipelining, and other techniques to exploit parallelism. Discussion of modern topics including GPU architectures, datacenter architecture, mobile/embedded SoC architectures, and machine learning acceleration as time permits. Emphasis on a quantitative evaluation of design alternatives and an understanding of performance and energy consumption issues. (Harvard)

    COMPSCI 2430: Advanced Computer Networks (4) sys

    This is a graduate-level course on computer networks. This course offers an in-depth exploration of a subset of advanced topics in networked systems. We will discuss the latest developments in the entire networking stack, the interactions between networks and high-level applications, and their connections with other system components such as compute and storage. In this year's edition, we will use machine learning as a prime example to understand its unique requirements and challenges in the context of networking. As machine learning applications increasingly rely on larger models and faster accelerators, the demand for enhanced networking capabilities becomes imperative. Throughout this course, we will study cutting edge networking solutions and principles for co-designing networks with compute and storage, to meet the evolving needs of machine learning applications. The course will include lectures, in-class presentations, paper discussions, and a research project. (Harvard)

    COMPSCI 2470R: Advanced Topics in Computer Architecture (4) sys

    Seminar course exploring recent research in computer architecture. Topics vary from year to year and will include subjects such as multi-core architectures, energy-efficient computing, reliable computing, and the interactions of these issues with system software. Students read and present research papers, undertake a research project. (Harvard)

    COMPSCI 2610: Research Topics in Operating Systems (4) sys

    An introduction to operating systems research. Paper-based seminar course that introduces students to the state of the art in systems research through historical and quantitative lenses. Students will read and discuss research papers and complete a final research project. (Harvard)

    COMPSCI 2620: Introduction to Distributed Computing (4) sys

    An examination of the special problems associated with distributed computing such as partial failure, lack of global knowledge, asynchrony and coordination of time, and protocols that function in the face of these problems. Emphasis on both the theory that grounds thinking about these systems and in the ways to design and build such systems. (Harvard)

    COMPSCI 2630: Systems Security (4) sys

    This course explores practical attacks on modern computer systems, explaining how those attacks can be mitigated using careful system design and the judicious application of cryptography. The course discusses topics like buffer overflows, web security, information flow control, and anonymous communication mechanisms such as Tor. The course includes several small projects which give students hands-on experience with various offensive and defensive techniques; the final, larger project is open-ended and driven by student interests. (Harvard)

    COMPSCI 2650: Big Data Systems (4) sys

    Big data is everywhere. A fundamental goal across numerous modern businesses and sciences is to be able to utilize as many machines as possible, to consume as much information as possible and as fast as possible. The big challenge is how to turn data into useful knowledge. This is a moving target as both the underlying hardware and our ability to collect data evolve. In this class, we discuss how to design data systems, data structures, and algorithms for key data-driven areas, including relational systems, distributed systems, graph systems, noSQL, newSQL, machine learning, and neural networks. We see how they all rely on the same set of very basic concepts and we learn how to synthesize efficient solutions for any problem across these areas using those basic concepts. (Harvard)

    MIT 6.5660: Computer Systems Security (4) sys

    Design and implementation of secure computer systems. Lectures cover attacks that compromise security as well as techniques for achieving security, based on recent research papers. Topics include operating system security, privilege separation, capabilities, language-based security, cryptographic network protocols, trusted hardware, and security in web applications and mobile phones. Labs involve implementing and compromising a web application that sandboxes arbitrary code, and a group final project. (Harvard)

    6.1600: Foundations of Computer Security (12) sys

    Fundamental notions and big ideas for achieving security in computer systems. Topics include cryptographic foundations (pseudorandomness, collision-resistant hash functions, authentication codes, signatures, authenticated encryption, public-key encryption), systems ideas (isolation, non-interference, authentication, access control, delegation, trust), and implementation techniques (privilege separation, fuzzing, symbolic execution, runtime defenses, side-channel attacks). Case studies of how these ideas are realized in deployed systems. Lab assignments apply ideas from lectures to learn how to build secure systems and how they can be attacked. (MIT)

    6.1800: Computer Systems Engineering (12) sys

    Topics on the engineering of computer software and hardware systems: techniques for controlling complexity; strong modularity using client-server design, operating systems; performance, networks; naming; security and privacy; fault-tolerant systems, atomicity and coordination of concurrent activities, and recovery; impact of computer systems on society. Case studies of working systems and readings from the current literature provide comparisons and contrasts. Includes a single, semester-long design project. Students engage in extensive written communication exercises. (MIT)

    6.1810: Operating System Engineering (12) sys

    Design and implementation of operating systems, and their use as a foundation for systems programming. Topics include virtual memory, file systems, threads, context switches, kernels, interrupts, system calls, interprocess communication, coordination, and interaction between software and hardware. A multi-processor operating system for RISC-V, xv6, is used to illustrate these topics. Individual laboratory assignments involve extending the xv6 operating system, for example to support sophisticated virtual memory features and networking. (MIT)

    6.1820: Mobile and Sensor Computing (12) sys

    Focuses on 'Internet of Things' (IoT) systems and technologies, sensing, computing, and communication. Explores fundamental design and implementation issues in the engineering of mobile and sensor computing systems. Topics include battery-free sensors, seeing through wall, robotic sensors, vital sign sensors (breathing, heartbeats, emotions), sensing in cars and autonomous vehicles, subsea IoT, sensor security, positioning technologies (including GPS and indoor WiFi), inertial sensing (accelerometers, gyroscopes, inertial measurement units, dead-reckoning), embedded and distributed system architectures, sensing with radio signals, sensing with microphones and cameras, wireless sensor networks, embedded and distributed system architectures, mobile libraries and APIs to sensors, and application case studies. Includes readings from research literature, as well as laboratory assignments and a significant term project. (MIT)

    6.1903: Introduction to Low-level Programming in C and Assembly (6) sys

    Introduction to C and assembly language for students coming from a Python background (6.100A). Studies the C language, focusing on memory and associated topics including pointers, and how different data structures are stored in memory, the stack, and the heap in order to build a strong understanding of the constraints involved in manipulating complex data structures in modern computational systems. Studies assembly language to facilitate a firm understanding of how high-level languages are translated to machine-level instructions. (MIT)

    6.1904: Introduction to Low-level Programming in C and Assembly (6) sys

    Introduction to C and assembly language for students coming from a Python background (6.100A). Studies the C language, focusing on memory and associated topics including pointers, and how different data structures are stored in memory, the stack, and the heap in order to build a strong understanding of the constraints involved in manipulating complex data structures in modern computational systems. Studies assembly language to facilitate a firm understanding of how high-level languages are translated to machine-level instructions. (MIT)

    6.1910: Computation Structures (12) sys

    Provides an introduction to the design of digital systems and computer architecture. Emphasizes expressing all hardware designs in a high-level hardware language and synthesizing the designs. Topics include combinational and sequential circuits, instruction set abstraction for programmable hardware, single-cycle and pipelined processor implementations, multi-level memory hierarchies, virtual memory, exceptions and I/O, and parallel systems. (MIT)

    6.3100: Dynamical System Modeling and Control Design (12) sys

    A learn-by-design introduction to modeling and control of discrete- and continuous-time systems, from intuition-building analytical techniques to more computational and data-centric strategies. Topics include: linear difference/differential equations (natural frequencies, transfer functions); controller metrics (stability, tracking, disturbance rejection); analytical techniques (PID, root-loci, lead-lag, phase margin); computational strategies (state-space, eigen-placement, LQR); and data-centric approaches (state estimation, regression, and identification). Concepts are introduced with lectures and online problems, and then mastered during weekly labs. In lab, students model, design, test, and explain systems and controllers involving sensors, actuators, and a microcontroller (e.g., optimizing thrust-driven positioners or stabilizing magnetic levitators). Students taking graduate version complete additional problems and labs. (MIT)

    6.3260: Networks (12) sys

    Highlights common principles that permeate the functioning of diverse technological, economic and social networks. Utilizes three sets of tools for analyzing networks -- random graph models, optimization, and game theory -- to study informational and learning cascades; economic and financial networks; social influence networks; formation of social groups; communication networks and the Internet; consensus and gossiping; spread and control of epidemics; control and use of energy networks; and biological networks. (MIT)

    6.5080: Multicore Programming (12) sys

    Introduces principles and core techniques for programming multicore machines. Topics include locking, scalability, concurrent data structures, multiprocessor scheduling, load balancing, and state-of-the-art synchronization techniques, such as transactional memory. (MIT)

    6.5081: Multicore Programming (12) sys

    Introduces principles and core techniques for programming multicore machines. Topics include locking, scalability, concurrent data structures, multiprocessor scheduling, load balancing, and state-of-the-art synchronization techniques, such as transactional memory. Includes sequence of programming assignments on a large multicore machine, culminating with the design of a highly concurrent application. Students taking graduate version complete additional assignments. (MIT)

    6.5660: Computer Systems Security (6) sys

    Design and implementation of secure computer systems. Lectures cover attacks that compromise security as well as techniques for achieving security, based on recent research papers. Topics include operating system security, privilege separation, capabilities, language-based security, cryptographic network protocols, trusted hardware, and security in web applications and mobile phones. Labs involve implementing and compromising a web application that sandboxes arbitrary code, and a group final project. (MIT)

    6.5810: Operating System Engineering (9) sys

    Fundamental design and implementation issues in the engineering of operating systems. Lectures based on the study of a symmetric multiprocessor version of UNIX version 6 and research papers. Topics include virtual memory; file system; threads; context switches; kernels; interrupts; system calls; interprocess communication; coordination, and interaction between software and hardware. Individual laboratory assignments accumulate in the construction of a minimal operating system (for an x86-based personal computer) that implements the basic operating system abstractions and a shell. Knowledge of programming in the C language is a prerequisite. (MIT)

    6.5820: Computer Networks (12) sys

    Topics on the engineering and analysis of network protocols and architecture, including architectural principles for designing heterogeneous networks; transport protocols; Internet routing; router design; congestion control and network resource management; wireless networks; network security; naming; overlay and peer-to-peer networks. Readings from original research papers. Semester-long project and paper. (MIT)

    6.5830: Database Systems (12) sys

    Topics related to the engineering and design of database systems, including data models; database and schema design; schema normalization and integrity constraints; query processing; query optimization and cost estimation; transactions; recovery; concurrency control; isolation and consistency; distributed, parallel and heterogeneous databases; adaptive databases; trigger systems; pub-sub systems; semi structured data and XML querying. Lecture and readings from original research papers. Semester-long project and paper. Students taking graduate version complete different assignments. (MIT)

    6.5831: Database Systems (12) sys

    Topics related to the engineering and design of database systems, including data models; database and schema design; schema normalization and integrity constraints; query processing; query optimization and cost estimation; transactions; recovery; concurrency control; isolation and consistency; distributed, parallel and heterogeneous databases; adaptive databases; trigger systems; pub-sub systems; semi structured data and XML querying. Lecture and readings from original research papers. Semester-long project and paper. Students taking graduate version complete different assignments. (MIT)

    6.5840: Distributed Computer Systems Engineering (12) sys

    Abstractions and implementation techniques for engineering distributed systems: remote procedure call, threads and locking, client/server, peer-to-peer, consistency, fault tolerance, and security. Readings from current literature. Individual laboratory assignments culminate in the construction of a fault-tolerant and scalable network file system. Programming experience with C/C++ required. (MIT)

    IS 2000: Principles of Information Science (4) sys

    Introduces information science. Examines how information is used to solve problems both for individuals and organizations and how information systems interface with their users. Considers the technical, economic, social, and ethical issues that arise when working with information. Discusses how to collect, manage, classify, store, encode, transmit, retrieve, and evaluate data and information with appropriate security and privacy. Storage models include lists, tables, and trees (hierarchies). Examines applications of information: visualization, presentation, categorization, decision making, and predictive modeling. Introduces key concepts in probability. Explains Bayesian analysis for information classification and modeling. Teaches intensive programming in Excel, including VBA macro development. Introduces programming in R. (Northeastern)

    CY 2550: Foundations of Cybersecurity (4) sys

    Presents an overview of basic principles and security concepts related to information systems, including workstation security, system security, and communications security. Discusses legal, ethical, and human factors and professional issues associated with cybersecurity, including the ability to differentiate between laws and ethics. Offers students an opportunity to use a substantial variety of existing software tools to probe both computer systems and networks in order to learn how these systems function, how data moves within these systems, and how these systems might be vulnerable. Covers security methods, controls, procedures, economics of cybercrime, criminal procedure, and forensics. (Northeastern)

    CS 3200: Database Design (4) sys

    Studies the design of a database for use in a relational database management system. The entity-relationship model and normalization are used in problems. Relational algebra and then the SQL (structured query language) are presented. Advanced topics include triggers, stored procedures, indexing, elementary query optimization, and fundamentals of concurrency and recovery. Students implement a database schema and short application programs on one or more commercial relational database management systems. (Northeastern)

    CS 3520: Programming in C++ (4) sys

    Examines how to program in C++ in a robust and safe manner. Reviews basics, including scoping, typing, and primitive data structures. Discusses data types (primitive, array, structure, class, string); addressing/parameter mechanisms (value, pointer, reference); stacks; queues; linked lists; binary trees; hash tables; and the design of classes and class inheritance, emphasizing single inheritance. Considers the instantiation of objects, the trade-offs of stack vs. heap allocation, and the design of constructors and destructors. Emphasizes the need for a strategy for dynamic memory management. Addresses function and operator overloading; templates, the Standard Template Library (STL), and the STL components (containers, generic algorithms, iterators, adaptors, allocators, function objects); streams; exception handling; and system calls for processes and threads. (Northeastern)

    CS 3650: Computer Systems (4) sys

    Introduces the basic design of computing systems, computer operating systems, and assembly language using a RISC architecture. Describes caches and virtual memory. Covers the interface between assembly language and high-level languages, including call frames and pointers. Covers the use of system calls and systems programming to show the interaction with the operating system. Covers the basic structures of an operating system, including application interfaces, processes, threads, synchronization, interprocess communication, deadlock, memory management, file systems, and input/output control. (Northeastern)

    CS 3700: Networks and Distributed Systems (4) sys

    Introduces the fundamentals of computer networks, including network architectures, network topologies, network protocols, layering concepts (for example, ISO/OSI, TCP/IP reference models), communication paradigms (point-to-point vs. multicast/broadcast, connectionless vs. connection oriented), and networking APIs (sockets). Also covers the construction of distributed programs, with an emphasis on high-level protocols and distributed state sharing. Topics include design patterns, transactions, performance trade-offs, security implications, and reliability. Uses examples from real networks (TCP/IP, Ethernet, 802.11) and distributed systems (Web, BitTorrent, DNS) to reinforce concepts. (Northeastern)

    CY 3740: Systems Security (4) sys

    Introduces the fundamental principles of designing and implementing secure programs and systems. Presents and analyzes prevalent classes of attacks against systems. Discusses techniques for identifying the presence of vulnerabilities in system design and implementation, preventing the introduction of or successful completion of attacks, limiting the damage incurred by attacks, and strategies for recovering from system compromises. Offers opportunities for hands-on practice of real-world attack and defense in several domains, including systems administration, the Web, and mobile devices. Presents the ethical considerations of security research and practice. (Northeastern)

    CS 4200: Database Internals (4) sys

    Explores the internal workings of database management systems. Explains how database systems store data on disks. Studies how to improve query efficiency using index techniques such as B+-tree, hash indices, and multidimensional indices. Describes how queries are executed internally and how database systems perform query optimizations. Introduces concurrency control schemes implemented by locking, such as hierarchical locking and key range locking. Describes lock table structure. Discusses how database systems can perform logging and recovery to avoid loss of data in case of system crashes. (Northeastern)

    IS 4200: Information Retrieval (4) sys

    Introduces information retrieval (IR) systems and different approaches to IR. Topics covered include evaluation of IR systems; retrieval, language, and indexing models; file organization; compression; relevance feedback; clustering; distributed retrieval and metasearch; probabilistic approaches to IR; Web retrieval; filtering, collaborative filtering, and recommendation systems; cross-language IR; multimedia IR; and machine learning for IR. (Northeastern)

    DS 4300: Large-Scale Information Storage and Retrieval (4) sys

    Introduces data and information storage approaches for structured and unstructured data. Covers how to build large-scale information storage structures using distributed storage facilities. Explores data quality assurance, storage reliability, and challenges of working with very large data volumes. Studies how to model multidimensional data. Implements distributed databases. Considers multitier storage design, storage area networks, and distributed data stores. Applies algorithms, including graph traversal, hashing, and sorting, to complex data storage systems. Considers complexity theory and hardness of large-scale data storage and retrieval. Requires use of nonrelational, document, key-column, key-value, and graph databases and programming in R, Python, and C++. (Northeastern)

    CS 4520: Mobile Application Development (4) sys

    Focuses on mobile application development on a mobile phone or related platform. Discusses memory management; user interface building, including both MVC principles and specific tools; touch events; data handling, including core data, SQL, XML, and JSON; network techniques and URL loading; and, finally, specifics such as GPS and motion sensing that may be dependent on the particular mobile platform. Students are expected to work on a project that produces a professional-quality mobile application. The instructor chooses a modern mobile platform to be used in the course. (Northeastern)

    CS 4550: Web Development (4) sys

    Discusses Web development for sites that are dynamic, data driven, and interactive. Focuses on the software development issues of integrating multiple languages, assorted data technologies, and Web interaction. Considers ASP.NET, C#, HTTP, HTML, CSS, XML, XSLT, JavaScript, AJAX, RSS/Atom, SQL, and Web services. Requires each student to deploy individually designed Web experiments that illustrate the Web technologies and at least one major integrative Web site project. Students may work as a team with the permission of the instructor. Each student or team must also create extensive documentation of their goals, plans, design decisions, accomplishments, and user guidelines. All source files must be open and be automatically served by a sources server. (Northeastern)

    CS 4610: Robotic Science and Systems (4) sys

    Introduces autonomous mobile robots, with a focus on algorithms and software development, including closed-loop control, robot software architecture, wheeled locomotion and navigation, tactile and basic visual sensing, obstacle detection and avoidance, and grasping and manipulation of objects. Offers students an opportunity to progressively construct mobile robots from a predesigned electromechanical kit. The robots are controlled wirelessly by software of the students' own design, built within a provided robotics software framework. The course culminates in a grand challenge competition using all features of the robots. (Northeastern)

    CS 4700: Network Fundamentals (4) sys

    Introduces the fundamental concepts of network protocols and network architectures. Presents the different harmonizing functions needed for the communication and effective operation of computer networks. Provides in-depth coverage of data link control, medium access control, routing, end-to-end transport protocols, congestion and flow control, multicasting, naming, auto configuration, quality of service, and network management. Studies the abstract mechanisms and algorithms as implemented in real-world Internet protocols. Also covers the most common application protocols (e-mail, Web, and ftp). (Northeastern)

    CS 4710: Mobile and Wireless Systems (4) sys

    Covers both theoretical foundations of wireless/mobile networking and practical aspects of wireless/mobile systems, including current standards, mobile development platforms, and emerging technologies. Incorporates a strong practical component; requires students to work in teams on several practical assignments (e.g., based on Wi-Fi sensing, mobile applications, Internet-of-Things devices, and software-defined radio applications) and a final project. The final project integrates knowledge about several wireless communication technologies and mechanisms. (Northeastern)

    CS 4730: Distributed Systems (4) sys

    Introduces distributed systems, covering fundamental concepts and showing how they are applied to build reliable distributed services. Examines several existing distributed applications, such as file systems, databases, lock services, digital currencies, smart contracts, and machine learning, and how these applications must coordinate to function and overcome failures, network partitions, or compromised parties. Distributed systems, such as databases, cloud services, and blockchains, are omnipresent in the services and applications that serve society on a daily basis. (Northeastern)

    CY 4740: Network Security (4) sys

    Studies topics related to Internet architecture and cryptographic schemes in the context of security. Provides advanced coverage of the major Internet protocols including IP and DNS. Examines denial of service, viruses, and worms, and discusses techniques for protection. Covers cryptographic paradigms and algorithms such as RSA and Diffie-Hellman in sufficient mathematical detail. The advanced topics address the design and implementation of authentication protocols and existing standardized security protocols. Explores the security of commonly used applications like the Web and e-mail. (Northeastern)

    CY 4760: Security of Wireless and Mobile Systems (4) sys

    Presents the foundations to understand security and privacy threats as well as defenses in wireless and mobile systems, especially in the era of softwarization of wireless networks. Studies the proliferation of wireless systems within a wide variety of contexts such as telephony, navigation, sensor networks, and critical infrastructures. Examines the security challenges inherent in the broadcast nature of wireless technologies and the increased availability of software-defined radios. Offers students an opportunity to obtain experience in describing and classifying security goals and attacks in modern wireless networks, to identify the unique security implications of these effects, and how to mitigate security issues associated with them. (Northeastern)

    CY 5001: Cyberspace Technology and Applications (4) sys

    Seeks to provide a systematic understanding of cyberspace technology and applications deployed in the global digital infrastructure. Covers topics in computer networks, server architectures, operating systems, and scripting. All the techniques and tools included in the course are oriented to serve as instruments of security administrators and cybersecurity professionals. Uses practical hands-on labs running on virtual machines and containers hosted in the cloud computing environment to train students. For that reason, a practical overview of virtualization technologies, containerization, and cloud computing models is provided. (Northeastern)

    CY 5010: Foundations of Information Assurance (4) sys

    Introduces information security via concepts of confidentiality, integrity, and availability. Discusses ethical, legal, and privacy ramifications while reviewing various laws, such as the Patriot Act, the Gramm-Leach-Bliley Act, and the General Data Protection Regulation. Covers security methods, controls, procedures, economics of cybercrime, criminal procedure, and forensics. (Northeastern)

    CY 5061: Cloud Security (2) sys

    Introduces the fundamentals of cloud computing while segueing into understanding its various security challenges, threat models, and data privacy issues in regard to compliance and legal decisions. Examines the strategies to implement security controls, perform risk assessments, handle incident detection and response, while emphasizing maintaining a business-minded security life cycle for cloud-based environments. (Northeastern)

    CY 5062: Introduction to IoT Security (2) sys

    Aims to provide a foundation for understanding the main issues associated with information security in a widely connected world in the context of Internet of Things (IoT). Emphasizes the vulnerabilities and threats of the IoT-based systems. Offers students an opportunity to learn the essentials of the IoT technologies and the underlying mechanisms for protecting information. (Northeastern)

    CY 5065: Cloud Security Practices (4) sys

    Introduces the fundamentals of cloud computing. Examines the strategies to implement security controls, perform risk assessments, and handle incident detection and response. Emphasizes maintenance of a business-minded security life cycle for cloud-based environments. Offers students an opportunity to obtain an understanding of various security challenges, threat models, and data privacy issues in regard to compliance and legal implications. (Northeastern)

    CY 5120: Applied Cryptography (4) sys

    Surveys the principles and the practices of cryptography. Overviews the core cryptographic algorithms: symmetric encryption schemes (e.g., DES and AES); public key cryptosystems (e.g., RSA and discrete logarithm); and hash functions (e.g., the SHA family). Discusses core information assurance building blocks, such as authentication, digital signatures, key management, and digital certificates. Finally, applies these concepts to important security architectures, including the IP network stack (e.g., IPsec and SSL/TLS), the cellular system, and broadcast media. Restricted to students in the College of Computer and Information Science and in the College of Engineering or by permission of instructor. (Northeastern)

    CY 5130: Computer System Security (4) sys

    Offers a practical overview of enterprise computer security, operating systems security, and related topics. Applies concepts such as authentication, access control, integrity, and audit to the modern operating system. Discusses and demonstrates system, process, memory, and file system-level defenses—and the attacks against them. Also discusses topics in data security and virtualization. Uses hands-on labs to reinforce skills and provide practical experience. (Northeastern)

    CY 5150: Network Security Practices (4) sys

    Explores issues involved in the security of computer networks. Topics include firewalls, viruses, virtual private networks, Internet security, and wireless security. Includes case studies and laboratory exercises. Restricted to students in the College of Computer and Information Science or by permission of instructor. (Northeastern)

    CY 5200: Security Risk Management and Assessment (4) sys

    Creates the opportunity for competency in the development of information security policies and plans including controls for physical, software, and networks. Discusses different malicious attacks, such as viruses and Trojan horses, detection strategies, countermeasures, damage assessment, and control. Covers information system risk analysis and management, audits, and log files. Uses case studies, site visits, and works with commercial products. (Northeastern)

    CY 5210: Information System Forensics (4) sys

    Designed to allow students to explore the techniques used in computer forensic examinations. Examines computer hardware, physical and logical disk structure, and computer forensic techniques. Conducts hands-on experiences on DOS, Windows operating systems, Macintosh, Novell, and Unix/Linux platforms. Builds on basic computer skills and affords hands-on experience with the tools and techniques to investigate, seize, and analyze computer-based evidence using a variety of specialized forensic software in an IBM-PC environment. (Northeastern)

    COMP_SCI 130-0: Tools and Technology of the World-Wide Web (1) sys

    Introduction to the theory and practice of developing sites on and technology for the web. Basics of HTML, JavaScript, ASP, and CGI programming. (Northwestern)

    COMP_SCI 213-0: Introduction to Computer Systems (1) sys

    The hierarchy of abstractions and implementations that make up a modern computer system; demystifying the machine and the tools used to program it; systems programming in C in the UNIX environment. Preparation for upper-level systems courses. (Northwestern)

    COMP_SCI 217-0: Data Management & Information Processing (1) sys

    This class offers a hands-on introduction to data representation, data modelling, and the SQL language for accessing and analyzing data in relational databases. Students access and analyze data in real-world large-scale databases from the public domain. Not for computer science or computer engineering degree candidates. (Northwestern)

    COMP_SCI 339-0: Introduction to Database Systems (1) sys

    Data models and database design. Modeling the real world: structures, constraints, and operations. The entity relationship to data modeling (including network hierarchical and object-oriented), emphasis on the relational model. Use of existing database systems for the implementation of information systems. (Northwestern)

    COMP_SCI 340-0: Introduction to Networking (1) sys

    A top-down exploration of networking using the five-layer model and the TCP/IP stack, covering each layer in depth. Students build web clients, servers, and a TCP implementation and implement routing algorithms. (Northwestern)

    COMP_SCI 343-0: Operating Systems (1) sys

    Fundamental overview of operating systems, including: concurrency (processes, synchronization, semaphores, monitors, deadlock); memory management (segmentation, paging virtual memory policies); software system architectures (level structures, microkernals); file systems (directory structures, file organization, RAID); protection (access control, capabilities, encryption, signatures, authentication). Requires substantial programming projects. (Northwestern)

    COMP_SCI 345-0: Distributed Systems (1) sys

    Basic principles behind distributed systems (collections of independent components that appear to users as a single coherent system) and main paradigms used to organize them. (Northwestern)

    COMP_SCI 350-0: Introduction to Computer Security (1) sys

    Basic principles and practices of computer and information security. Software, operating system, and network security techniques, with detailed analysis of real-world examples. Topics include cryptography, authentication, software and operating system security (e.g., buffer overflow), Internet vulnerability (DoS attacks, viruses/worms, etc.), intrusion detection systems, firewalls, VPN, and web and wireless security. (Northwestern)

    COMP_SCI 354-0: Computer System Security (1) sys

    The past decade has seen an explosion in the concern for the security of information. This course introduces students to the basic principles and practices of computer system and networking security, with detailed analysis of real-world examples and hands-on practice. Topics include the basic crypto, authentication, reverse engineering, buffer overflow attacks, vulnerability scanning, web attacks, firewalls, intrusion detection/prevention systems, etc. We will first introduce the basic theory for each type of attack; then we will actually carry them out in 'real-world' settings. The goal is to learn security by learning how to view your machine from a hacker's perspective. In addition, we encourage students to participate in the UCSB International Capture the Flag Competition. Capture the Flag is a network security exercise where the goal is to exploit other machines while defending your own. In fact, this course should prepare you for any one of many capture the flag competitions that take place year-round. We will learn about different types of hacks and perform them. After learning how to execute such exploits and penetrate a network, we will discuss ways to protect a network from others exploiting the same vulnerabilities. Understanding security is essential in all fields of software development and computing. For major or minors in Computer Science, this course can satisfy the system breadth. (Northwestern)

    COMP_SCI 355-0: Digital Forensics and Incident Response (1) sys

    This course aims to teach students the concepts of Digital Forensics and Incident Response. The technical content taught in the class consists of deep knowledge of filesystems and operating systems so that students know which digital artifacts to investigate in data breach scenarios. Labs and assignments are a sanitized version of real-world intrusions by nation-state actors and cybercriminals. (Northwestern)

    COMP_SCI 367-0: Wireless and Mobile Health: Passive Sensing Data Analytics (1) sys

    A hands-on introduction and experience to the growing field of mobile Health. Students work together on a project with clinicians and faculty in medicine, building a unique mHealth system while testing their system on a small population. Theory-driven project hypothesis, technology selection and development, passive sensing data analytic chain understanding and implementation, and project management. (Northwestern)

    COMP_SCI 368-0: Programming Massively Parallel Processors with CUDA (1) sys

    This course focuses on developing and optimizing applications software on massively parallel graphics processing units (GPUs). Such processing units routinely come with hundreds to thousands of cores per chip and sell for a few hundred to a few thousand dollars. The massive parallelism they offer allows applications to run 2x-450x faster than on conventional multicores. However, to reach this performance improvement, the application must fully utilize the computational, storage and communication resources provided by the device. This course discusses state-of-the-art parallel programming optimization methods to achieve this goal. (Northwestern)

    COMP_SCI 440-0: Advanced Networking (1) sys

    This course will cover a broad range of topics including Internet evolution and architectures; analysis and design of network protocols (both wired and wireless); networking issues for Web and gaming applications; analysis and performance of content distribution networks; network security, vulnerability, and defenses. (Northwestern)

    COMP_SCI 441-0: Resource Virtualization (1) sys

    The bulk of the time in this class examining a virtual machine monitor (VMM) in depth, at the source code level. The course explains the hardware/software interface of a modern x86 computer in detail. A VMM is an operating system that is implemented directly on top of the hardware interface, and itself presents a hardware interface to higher-level software. Students will also acquire valuable kernel development skills. (Northwestern)

    COMP_SCI 443-0: Advanced Operating Systems (1) sys

    Advanced concepts in operating systems and distributed computing from historical perspectives to current themes such as peer-to-peer computing and mobile systems. (Northwestern)

    COMP_SCI 446-0: Kernel and Other Low-level Software Development (1) sys

    The development of low-level systems software such as drivers, kernels, etc is very different from the development of applications. This class teaches how such development is done: how to design, implement, debug, and optimize low-level software and use available tools. (Northwestern)

    COMP_SCI 450-0: Internet Security (1) sys

    Through measurement-based approaches, students analyze the complexity of the Internet, and develop countermeasures against various vulnerabilities of the Internet such as viruses, worms, and denial of service attacks. (Northwestern)

    COMP_ENG 303-0: Advanced Digital Design (1) sys

    Overview of digital logic design. Technology review. Delays, timing in combinational and sequential circuits, CAD tools, arithmetic units such as ALUs and multipliers. Introduction to VHDL. (Northwestern)

    COMP_ENG 346-0: Microprocessor System Design (1) sys

    Structure and timing of typical microprocessors. Sample microprocessor families. Memories, UARTS, timer/counters, serial devices, and related devices. MUX and related control structures for building systems. Standard bus structures. Interrupt programming. Hardware/software design tradeoffs. (Northwestern)

    COMP_ENG 358-0: Introduction to Parallel Computing (1) sys

    Introduction to parallel computing for scientists and engineers. Shared-memory parallel architectures and programming, distributed memory, message-passing data-parallel architectures, and programming. (Northwestern)

    COMP_ENG 361-0: Computer Architecture I (1) sys

    Design and understanding of the computer system as a whole unit. Performance evaluation and its role in computer system design; instruction set architecture design, data-path design and optimizations (e.g., ALU); control design; single cycle, multiple cycle, and pipeline implementations of processor. Hazard detection and forwarding; memory hierarchy design; cache memories, virtual memory, peripheral devices, and I/O. (Northwestern)

    CSCI 105: Computer Systems (1) sys

    Data representations, machine level representation of programs, processor architecture, program optimizations, the memory hierarchy, linking, exceptional control flow, performance measurement, virtual memory, system-level I/O and basic concurrent programming. These concepts are supported by a series of hands-on lab assignments. (Pomona)

    CSCI 133: Database Systems (1) sys

    Fundamental and cutting-edge concepts in database design: entity-relationship model, relational and semi-structured models. Query languages: relational algebra, relational calculus, SQL, XPath and SPARQL. Mechanism and design of database management systems: storage model, indexing, key algorithms such as sorting and joins, query evaluation and optimization, and concurrency control. (Pomona)

    CSCI 134: Operating Systems Principles (1) sys

    This course will provide an introduction to the design and structure of operating systems, to the services they provide, and to key issues that have confronted them, and broadly applicable approaches that have been developed to address them. Projects in the accompanying lab will focus on the exploitation of Operating System services, and practical experience with synchronization, file systems and security. (Pomona)

    CSCI 181S: System Security (1) sys

    This course provides an introduction to system security. It focuses on principles and techniques for designing and implementing secure networked information systems. Topics include mechanisms for authentication, authorization, and audit, as well as cryptographic protocols and policy issues. (Pomona)

    CSCI 181ORPO: Computer Organization and Design (1) sys

    An exploration of the fundamentals of computer architecture. From the C programming language down to the microprocessor, understand the abstraction layers between software and hardware. Topics covered include: abstraction, locality, parallelism, machine-level code, memory hierarchy, logic design, CPU design, and parallel programming. (Pomona)

    COS 316: Principles of Computer System Design (1) sys

    This course teaches students the design, implementation, and evaluation of computer systems, including operating systems, networking, and distributed systems.The course will teach students to evaluate the performance and study the design choices of existing systems. Students will also learn general systems concepts that support design goals of modularity, performance, and security. Students will apply materials learned in lectures and readings to design and build new systems components. A. Levy, R. Netravali (Princeton)

    COS 318: Operating Systems (1) sys

    A study of the design and analysis of operating systems. Topics include: processes, mutual exclusion, synchronization, semaphores, monitors, deadlock prevention and detection, memory management, virtual memory, processor scheduling, disk management, file systems, security, protection, distributed systems. Two 90-minute lectures. (Princeton)

    COS 375: Computer Architecture and Organization (1) sys

    An introduction to computer architecture and organization. Instruction set design; basic processor implementation techniques; performance measurement; caches and virtual memory; pipelined processor design; design trade-offs among cost, performance, and complexity. Two 90-minute classes, one self-scheduled hardware laboratory. (Princeton)

    COS 381: Networks: Friends, Money and Bytes (1) sys

    This course is oriented around 20 practical questions in the social, economic, and technological networks in our daily lives. How does Google sell ad spaces and rank webpages? How does Netflix recommend movies and Amazon rank products? How do I influence people on Facebook and Twitter? Why doesn’t the Internet collapse under congestion, and does it have an Achilles heel? Why does each gigabyte of mobile data cost $10, but Skype is free? How come Wi-Fi is slower at hotspots than at home, and what is inside the cloud of iCloud? In formulating and addressing these questions, we introduce the fundamental concepts behind the networking industry. (Princeton)

    COS 418: Distributed Systems (1) sys

    This course covers the design and implementation of distributed systems. Students will gain an understanding of the principles and techniques behind the design of modern, reliable, and high-performance distributed systems. Topics include server design, network programming, naming, concurrency and locking, consistency models and techniques, security, and fault tolerance. Modern techniques and systems employed at some of the largest Internet sites (e.g., Google, Facebook, Amazon) will also be covered. Through programming assignments, students will gain practical experience designing, implementing, and debugging real distributed systems. (Princeton)

    COS 432: Information Security (1) sys

    Security issues in computing, communications, and electronic commerce. Goals and vulnerabilities; legal and ethical issues; basic cryptology; private and authenticated communication; electronic commerce; software security; viruses and other malicious code; operating system protection; trusted systems design; network security; firewalls; policy, administration and procedures; auditing; physical security; disaster recovery; reliability; content protection; privacy. (Princeton)

    COS 461: Computer Networks (1) sys

    This course studies computer networks and the services built on top of them. Topics include packet-switch and multi-access networks, routing and flow control, congestion control and quality-of-service, Internet protocols (IP, TCP, BGP), the client-server model and RPC, elements of distributed systems (naming, security, caching) and the design of network services (multimedia, peer-to-peer networks, file and Web servers, content distribution networks). (Princeton)

    COS 462: Design of Very Large-Scale Integrated (VLSI) Systems (1) sys

    (Princeton)

    COS 475: Computer Architecture (1) sys

    (Princeton)

    CS 25200: Systems Programming (4) sys

    Low-level programming; review of addresses, pointers, memory layout, and data representation; text, data, and bss segments; debugging and hex dumps; concurrent execution with threads and processes; address spaces; file names; descriptors and file pointers; inheritance; system calls and library functions; standard I/O and string libraries; simplified socket programming; building tools to help programmers; make and make files; shell scripts and quoting; Unix tools including sed, echo, test, and find; scripting languages such as awk; version control; object and executable files (.o and a.out); symbol tables; pointers to functions; hierarchical directories; and DNS hierarchy; programming embedded systems. (Purdue)

    CS 34800: Information Systems (3) sys

    File organization and index structures; object-oriented database languages; the relational database model with introductions to SQL and DBMS; hierarchical models and network models with introductions to HDDL, HDML, and DBTG Codasyl; data mining; data warehousing; database connectivity; distributed databases; the client/server paradigm; middleware, including ODBC, JDBC, CORBA, and MOM. (Purdue)

    CS 35100: Cloud Computing (3) sys

    Introduction to cloud computing. Cloud data center infrastructure, public and private clouds, servers and virtualized servers, data center networks and virtualized networks, virtualized disk, file, and object storage, the concept of scale-out, algorithms and programming systems used in the design and implementation of cloud-native software, especially using containers and orchestration systems, microservices, serverless designs, controller-based designs, edge and fog computing, security in a cloud environment, programming models. (Purdue)

    CS 35300: Principles Of Concurrency And Parallelism (3) sys

    Important concepts, models, algorithms, abstractions, and implementation aspects of concurrent and parallel programs. Topics include: techniques used to describe concurrent programs (e.g., threads, events, co-routines, continuations), abstractions for shared-memory and message-passing programs, relaxed memory models, livelock and deadlock detection, lock-free algorithms, data races and atomicity, scheduling techniques, process calculi, and software transactions. (Purdue)

    CS 35400: Operating Systems (3) sys

    Introduction to operating systems. Computer system and operating system architectures, processes, inter-process communication, inter-process synchronization, mutual exclusion, deadlocks, memory hierarchy, virtual memory, CPU scheduling, file systems, I/O device management, security. (Purdue)

    CS 42200: Computer Networks (3) sys

    Undergraduate-level introduction to computer networks and data communication. Low-level details of media, signals, and bits: time division and frequency division multiplexing; encoding; modulation; bandwidth, throughput, and noise. Packet transmission: Local Area Network (Ethernet, FDDI) and Wide Area Network technologies (ATM); wireless networks; network interconnection with repeaters, bridges, and switches; DSU/CSU; xDSL and cable modems. Internetworking: router-based architecture; IP addressing; address binding with ARP; datagram encapsulation and fragmentation; UDP and TCP, retransmission; protocol ports; ICMP and error handling. Network applications: client/server concept; port demultiplexing; program interface to protocols (API); use by clients and servers; domain name system; TELNET; Web technologies including HTTP, CGI, Java; RPC and middleware; network management. (Purdue)

    CS 42600: Computer Security (3) sys

    A survey of the fundamentals of information security. Risks and vulnerabilities, policy formation, controls and protection methods, database security, encryption, authentication technologies, host-based and network-based security issues, personnel and physical security issues, issues of law and privacy. (Purdue)

    CS 43900: Introduction To Data Visualization (3) sys

    The course offers an introduction to the fundamentals principles, design strategies, and techniques needed to visually communicate, explore, and analyze data. The course focuses primarily on the visual representation of inherently non-spatial data (e.g., tables and spreadsheets, graphs and networks, trees, text, and time series), but also considers the visualization of maps and of data in geospatial context. (Purdue)

    CS 44800: Introduction To Relational Database Systems (3) sys

    An in-depth examination of relational database systems including theory and concepts as well as practical issues in relational databases. Modern database technologies such as object-relational and Web-based access to relational databases. Conceptual design and entity relationship modeling, relational algebra and calculus, data definition and manipulation languages using SQL, schema and view management, query processing and optimization, transaction management, security, privacy, integrity management. (Purdue)

    CS 47300: Web Information Search And Management (3) sys

    This course teaches important concepts and knowledge of information retrieval for managing unstructured data such as text data on Web or in emails. At the same time, students will be exposed to a large number of important applications. Students in the course will get hands on experience from homework and a course project. The first part of the course focuses on general concepts/techniques such as stemming, indexing, vector space model, and feedback procedure. The second part of the course shows how to apply the set of techniques on different applications such as Web search, text categorization, and information recommendation. (Purdue)

    CS 48900: Embedded Systems (3) sys

    Software for embedded systems; programming with extreme constraints on memory, storage, and processing power; programming models, including synchronous, asynchronous, and concurrent; programming systems that run forever; use of Finite State Machines (FSMs); review of embedded hardware and available boards; asynchronous and synchronous serial connections (e.g., RS232 and SPI); General Purpose I/O (GPIO) pins; relays, servos, and other peripherals; design for low power; battery characteristics; systems that communicate over computer networks and the Internet; current industry practices; design of embedded projects; working in teams. (Purdue)

    CS 50010: Foundational Principles Of Information Security (3) sys

    This course covers foundational principles relevant to information security including data structures, algorithm design, computational complexity, probability theory, number theory, and basics of cryptography. (Purdue)

    CS 50011: Introduction To Systems For Information Security (3) sys

    The course covers computer systems principles relevant to information security and it serves as a prerequisite for the later courses in the MS in IS program. The material includes features in the C/C++ programming languages for understanding security-critical software vulnerabilities, basic knowledge in computer architecture and assembly languages, knowledge of the compiling process, operating systems, networking, databases, and web applications relevant to information security. (Purdue)

    CS 50023: Data Engineering I (1) sys

    The course introduces students to the fundamentals of Data Engineering with a focus on tools and computational techniques to gather, construct, manipulate, summarize, and visualize data sets as a means to extract knowledge from the underlying data. Python and Python libraries are used. Completion of the course will allow learners to perform basic data analysis on data sets. (Purdue)

    CS 50024: Data Engineering II (1) sys

    This course introduces students to the fundamentals of database management systems (DBMS) from a user’s perspective. The principles of modeling an enterprise using Entity-Relationship diagrams and transforming the model into a relational or NoSQL database are illustrated through a range of examples. The SQL language is used to create, query, aggregate, and update a relational database. NOSQL databases and the related data models (column, graph, and document-based) are introduced. Experience in Python Programming is required. (Purdue)

    CS 50300: Operating Systems (3) sys

    Basic principles of operating systems: addressing modes, indexing, relative addressing, indirect addressing, stack maintenance; implementation of multitask systems; control and coordination of tasks, deadlocks, synchronization, mutual exclusion; storage management, segmentation, paging, virtual memory; protection, sharing, access control; file systems; resource management; evaluation and prediction of performance. Students are expected to spend at least three hours per week gaining hands-on experience in using and modifying a small operating system. Typically offered Fall Spring. (Purdue)

    CS 50500: Distributed Systems (3) sys

    Foundations for building reliable distributed systems, including failure and system models, and basic communication and agreement problems; crash failures, recovery, partition, Byzantine failures; asynchronous systems, failure detectors, communication channels, wireless and sensor networks; software clocks, causality, and cuts. Examples of problems include reliable broadcast consensus, leader election, group communication, and replication. Permission of department required. Typically offered Spring. (Purdue)

    CS 51520: Operating Systems (3) sys

    This course is about the concepts and principles of modern operation systems. It includes: design and implementation of multi-process systems; process synchronization, mutual exclusion; CPU scheduling, deadlock, memory management, segmentation, paging, virtual memory; storage management, file system management, protection and security, evaluation and prediction of performance. Reading the latest paper about operation systems and presentations are required. Every student should participate in debates based on the case studies of Linux System and Windows 7. (Purdue)

    CS 52500: Parallel Computing (3) sys

    Parallel computing for science and engineering applications: parallel programming and performance evaluation, parallel libraries and problem-solving environments, models of parallel computing and run-time support systems, and selected applications. (Purdue)

    CS 52600: Information Security (3) sys

    (CSCI 52600) Basic notions of confidentiality, integrity, availability; authentication models; protection models; security kernels; secure programming; audit; intrusion detection and response; operational security issues; physical security issues; personnel security; policy formation and enforcement; access controls; information flow; legal and social issues; identification and authentication in local and distributed systems; classification and trust modeling; and risk assessment. (Purdue)

    CS 52700: Software Security (3) sys

    This course focuses on software security fundamentals, secure coding guidelines and principles, and advanced software security concepts. Students will learn to assess and understand threats, learn how to design and implement secure software systems, and get hands-on experience with common security pitfalls. (Purdue)

    CS 52800: Network Security (3) sys

    The course focuses on the principles and foundations of building secure network systems and on security and privacy challenges in existing and emerging networks. The course compares and analyzes network architectures and network protocols from the physical layer to the access control, network, transport and application layer from an adversarial standpoint to understand how to build more secure protocols that can withstand attacks. Restricted to CS MS and CS PHD students. Significant programming experience and skills are required to complete the projects. Typically offered Spring. (Purdue)

    CS 52900: Security Analytics (3) sys

    This course focuses on applied data mining, machine learning, data analytics techniques, and their application and relevance in information security. The course covers basic concepts of data mining and machine learning, computation platforms in support of big data analytics including Map-Reduce and Spark, machine learning algorithms such as classification trees, logistic regression, naive Bayes, k Nearest Neighbors, Support Vector Machines, Artificial Neural Networks (including Feed Forward, Convolutional, and Recurrence), the application of these algorithms to security tasks such as Spam/Phishing detection, malware detection, intrusion detection, and situational awareness. The future and potential role of applying machine learning techniques in information and data security is explored. (Purdue)

    COMP 222: Intro to Computer Organization (4) sys

    This course introduces students to the organization of computer systems in order that they gain an understanding of how a computer system executes their programs. Students will learn how to write small-scale programs in C, how to read the translation of those programs into assembly language, and how those programs are executed at the machine level. Specific topics covered will include data representation at the machine level, static versus dynamic memory allocation, instruction set architecture and the encoding of instructions in memory, linking relocatable object files to create executable files, pipelining within the processor, and caching within the memory system. (Rice)

    COMP 321: Introduction to Computer Systems (4) sys

    This course introduces computer systems from the programmer's perspective. Topics include data representation, the compilation process, and system-level programming concepts such as interrupts and concurrency. Formerly COMP 221. (Rice)

    COMP 322: Principles of Parallel Programming (4) sys

    Fundamentals of parallel programming: abstract models of parallel computers, parallel algorithms and data structures, and common parallel programming patterns including task parallelism, undirected and directed synchronization, data parallelism, divide-and-conquer parallelism, and map-reduce. Laboratory assignments will explore these topics through the use of parallel extensions to the Java language. (Rice)

    COMP 326: Digital Logic Design (3) sys

    Study of gates, flip-flops, combinational and sequential switching circuits, registers, logical and arithmetic operations, introduction to the Verilog hardware description language (Rice)

    COMP 327: Introduction to Computer Security (3) sys

    This elective course covers a wide variety of topics in computer security, including hands-on experience with breaking software and engineering software to be harder to break. For example, students will perform buffer overflow attacks and exploit web application vulnerabilities, while also learning how to defend against them. Grades will be based on a series of in-class projects (Rice)

    COMP 413: Distributed Program Construction (4) sys

    This course focuses on modern principles for the construction of distributed programs, with an emphasis on design patterns, modern programming tools, and distributed object systems. The material will be applied in a substantial software design/construction project. (Rice)

    COMP 417: Advanced Operating Systems and Security (3) sys

    In this seminar, we will investigate advanced topics in the design and implementation of operating systems, including: OS structure (including Web Browsers), concurrency and synchronization, memory management, file systems and storage, virtual machines, and information protection. We will explore both fundamental and hot topics through reading, discussing, and presenting key research findings. This course will also cover methods for critiquing, writing, and presenting research findings through a course long project. (Rice)

    COMP 418: IoT Programming And Data Analysis (4) sys

    This course is an introduction to the Internet of Things (IoT). It will present the tools and techniques needed to develop complex IoT applications that encompass interaction with the physical world and data analysis across the IoT computing infrastructure. The topics range from programming microcontrollers (e.g., Arduino) and single-board computers (e.g., Raspberry Pi) to IoT automation and the efficient analysis of real-time IoT data. (Rice)

    COMP 420: Introduction to Distributed Computer Systems (4) sys

    Introduction to distributed computer systems. The course covers concepts, architecture, algorithms, protocols, and implementation, focusing on distribution, scale, robustness in the face of failure, and security. (Rice)

    COMP 421: Operating Systems and Concurrent Programming (4) sys

    Introduction to the design, construction, and analysis of concurrent programs with an emphasis on operating systems, including filing systems, schedulers, and memory allocators. Specific attention is devoted to process synchronization and communication within concurrent programs. (Rice)

    COMP 422: Parallel Computing (4) sys

    COMP 422 is an undergraduate version of this course. COMP 422 students will have four programming assignments. COMP 534 students will have five. As part of their assignments, both COMP 422 and COMP 534 students will analyze the scalability and parallel efficiency of parallel programs they write. COMP 534 students will additionally use tools to qualify the root causes of scaling losses in their programs and document their findings. (Rice)

    COMP 424: Mobile and Embedded System Design and Application (4) sys

    ELEC 424 introduces mobile and embedded system design and applications to undergraduate students and provides them hands-on design experience. It consists of three interlearning parts: lectures, student project, and student presentations. (Rice)

    COMP 425: Computer Systems Architecture (4) sys

    Evolution of key architecture concepts found in advanced uniprocessor systems. Fundamental and advanced pipelining techniques and associated issues for improving processor performance. (Rice)

    COMP 427: Introduction to Computer Security (3) sys

    This elective course covers a wide variety of topics in computer security, including hands-on experience w/breaking software & engineering software to be harder to break. (Rice)

    COMP 429: Introduction to Computer Networks (4) sys

    Network architectures, algorithms, and protocols. Local- and Wide-area networking. Intra- and inter-domain routing. Transmission reliability. Flow and congestion control. TCP/IP. Multicast. Quality of Service. Network Security - Networked applications. (Rice)

    COMP 430: Introduction to Database Systems (3) sys

    Introduction to relational and other database systems, SQL programming, Database application programming, and Database design. (Rice)

    COMP 431: Web Development (3) sys

    In this project-based course, students create multi-user Web applications involving all aspects of application development from front-end and back-end programming to interfacing client-server communications technologies. Class time includes discussions of topics in Web development, structural frameworks, test driven development, and time for students to develop their Web applications. (Rice)

    COMP 432: Database System Implementation (34) sys

    This course covers database management system architecture, query processing and optimization, transaction processing, concurrent control and recover, storage, indexing structures and related topics. Students will build a database system from the ground up. Students who have not had an introductory database course should enroll for 4 credits: all others should enroll for 3 credits. (Rice)

    COMP 436: Secure and Cloud Computing (3) sys

    What is “cloud computing?” How do we build cloud-scale systems and components that are secure against malicious attacks, and scale to millions of users? Many of today’s services run inside the cloud – a set of geographically distributed data centers running heterogeneous software stacks. (Rice)

    COMP 446: Mobile Device Applications (4) sys

    Connected mobile devices require updated programming models and design concepts to take advantage of their capabilities. We will explore applications primarily on the Apple iPhone and iPad but will also cover smart watches, Google Android and intelligent voice assistants like Amazon Echo and Google Home. We will briefly touch on the development of web services to support mobile applications. The course culminates with a large project taking up most of the second half of the semester. Although the curriculum centers around and teaches iOS and Xcode, final projects may be completed in any major mobile system including Android and Alexa, etc. (Rice)

    COMP 451: Design and Analysis of Cyber-Physical Systems (4) sys

    This course is an introduction to cyber-physical systems, engineering artifacts in which computational components interact with and typically control physical components. Some common examples of cyber-physical systems include robots, Segways and lane-departure warning, LDW, systems in automobiles. (Rice)

    CSSE 132: Introduction to Systems Programming (4) sys

    Provides students with understanding of computer system level issues and their impact on the design and use of computer systems. Students will study low-level programming (assembly) and memory operations, representation of various types of data and programs in memory, and resource/efficiency trade-offs. System requirements such as resource management, security, communication and synchronization are studied and basic systems tools for these tasks are implemented. Course topics will be explored using a variety of hands-on assignments and projects. (Rose-Hulman)

    CSSE 140: Practical Security I (1) sys

    This is an entry-level introduction to exploiting and securing computer systems, networks, and web sites. This shallow introduction exposes students to various applied cybersecurity topics including Firewalls, SSH, passwords, web security, and basic unix system administration. Through a series of hands-on exercises, students will relate these topics to practical ways to secure computers. (Rose-Hulman)

    CSSE 141: Practical Security II (1) sys

    A second-level introduction to exploiting and securing computer systems, networks, and web sites. This class continues the introduction to applied cybersecurity topics including basic Cryptography, network protocol analysis, reverse engineering, steganography, forensics, and more unix system administration. Students are also introduced to capture-the-flag exercises, which are widely practiced cybersecurity skill competitions. (Rose-Hulman)

    CSSE 142: Practical Security III (2) sys

    A third-level class on exploiting and securing computer systems, networks, and web sites. This class continues the introduction to applied cybersecurity topics and focus on applying concepts learned in CSSE 140/141 to security competitions such as capture-the-flag events. This class exposes students to strategy used in security competitions, teamwork skills for effective competition, and construction of set of exercises used for running a CTF event. Students will work in teams to solve security-oriented problems, apply their skills to create competition challenges/exercises for use in CSSE 141 and for competition training, practice for security competitions, and participate in or run a few security competitions. (Rose-Hulman)

    CSSE 212: Hardware-oriented Programming (4) sys

    Simple computer architecture. Special hardware-oriented programming. Introduction to the C programming language, especially the use of pointers. Interrupt programming. This course is taught as part of the International Computer Science dual degree program at Hochschule Ulm, Germany. (Rose-Hulman)

    CSSE 232: Computer Architecture I (4) sys

    Computer instruction set architecture and implementation. Specific topics include historical perspectives, performance evaluation, computer organization, instruction formats, addressing modes, computer arithmetic, single-cycle and multi-cycle data paths, and processor control. Assembly language programming is used as a means of exploring instruction set architectures. The final project involves the complete design and implementation of a miniscule instruction set processor. (Rose-Hulman)

    CSSE 240: Principles of Cybersecurity (4) sys

    This course introduces ethical, theoretical, and practical issues of information security in interconnected systems of computers. Implications of relevant professional codes of ethics are a recurring theme of the course, as are societal and human impacts on computer system security. Foundational topics include access control matrices and standard system models, as well as policies for security, confidentiality, and integrity. Implementation issues include key management, cipher techniques, authentication, principles of secure design, representation of identity, access control mechanisms, information flow, life cycle issues, and formal evaluation and certification techniques. Additional topics include malicious logic, vulnerability analysis, and auditing. Computer system attack techniques are observed and evaluated in a closed environment to motivate and inform discussion and exploration of computer network defense techniques. (Rose-Hulman)

    CSSE 280: Introduction to Web Programming (4) sys

    Introduction to the client-side and server-side mechanisms for creating dynamic web applications with persistent data storage. Browser-server interaction via HTTP. Static web page creation using current markup and styling languages. Client-side programming with modern scripting languages and the DOM. Server-side programming with emerging web programming languages and frameworks. Persistent data storage with a state-of-the-art database management system. Asynchronous client-server communication via HTTP requests. Development and consumption of REST APIs. Deployment of web applications to cloud platforms or platform as a service providers. Security considerations. This course provides breadth of knowledge of many tools/technologies rather than deep knowledge of any particular tool/technology. No previous experience with Web development is required. (Rose-Hulman)

    CSSE 332: Operating Systems (4) sys

    Students learn fundamental concepts of modern operating systems by studying how and why operating systems have evolved. Topics include CPU scheduling, process synchronization, memory management, file systems, I/O systems, privacy and security, and performance evaluation. Students implement parts of an operating system as a means of exploring the details of some of these topics. (Rose-Hulman)

    CSSE 333: Database Systems (4) sys

    Relational database systems, with emphasis on entity relationship diagrams for data modeling. Properties and roles of transactions. SQL for data definition and data manipulation. Use of contemporary API's for access to the database. Enterprise examples provided from several application domains. The influence of design on the use of indexes, views, sequences, joins, and triggers. Physical level data structures: B+ trees and RAID. Survey of object databases. (Rose-Hulman)

    CSSE 335: Introduction to Parallel Computing (4) sys

    Principles of scientific computation on parallel computers. Algorithms for the solution of linear systems and other scientific computing problems on parallel machines. Course includes a major project on RHIT's parallel cluster. Same as MA 335. (Rose-Hulman)

    CSSE 340: Foundations of Cybersecurity (4) sys

    This course introduces ethical, theoretical, and practical issues of information security in interconnected systems of computers. Implications of relevant professional codes of ethics are a recurring theme of the course, as are societal and human impacts on computer system security. Foundational topics include access control matrices and standard system models, as well as policies for security, confidentiality, and integrity. (Rose-Hulman)

    CSSE 343: Cybercrime and Digital Forensics (4) sys

    This course introduces students to “cybercrime,” how police investigate these crimes, and what forensics techs use to uncover digital evidence. Students will examine the laws, technologies, tools, and procedures used in the investigation and prosecution of computer crimes through case studies, discussions, ethical debates, and hands-on laboratory exercises that uncover and analyze digital evidence. (Rose-Hulman)

    CSSE 432: Computer Networks (4) sys

    Organization, design, and implementation of computer networks, especially the Internet. Network protocols, protocol layering, flow control, congestion control, error control, packet organization, routing, gateways, connection establishment and maintenance, machine and domain naming, security. Each of the top four layers of the Internet protocol stack: application (FTP, HTTP, SMTP), transport (TCP, UDP), network (IP), link (Ethernet). (Rose-Hulman)

    CSSE 433: Advanced Database Systems (4) sys

    This course covers advanced topics in the design and development of database management systems and their modern applications. Topics to be covered include query processing and, in relational databases, transaction management and concurrency control, eventual consistency, and distributed data models. This course introduces students to NoSQL databases and provides students with experience in determining the right database system for the right feature. Students are also exposed to polyglot persistence and developing modern applications that keep the data consistent across many distributed database systems. (Rose-Hulman)

    CSSE 434: Introduction to the Hadoop Ecosystem (4) sys

    This advanced course examines emergent Big Data techniques through hands-on introductions to the various technologies and tools that make up the Hadoop ecosystem. Topics covered include internals of MapReduce and the Hadoop Distributed File system (HDFS), internals of the YARN distributed operating system, MapReduce for data processing, transformation & analysis tools for data at scale (processing terabytes and petabytes of information quickly), scheduling jobs using workflow engines, data transfer tools & real time engines for data processing. (Rose-Hulman)

    CSSE 443: Distributed Systems & IT Security (4) sys

    Building complex distributed information systems requires a systematic approach. This course covers the analysis of existing distributed information systems and provides the ability to model simple new distributed applications with special attention to the trustworthiness, reliability and security of information systems. Topics covered include the main architectural models of distributed systems, describing simple distributed applications according to architecture and function, defining simple communication protocols, the benefits of using middleware, the risks of using distributed systems, and safety measures. This course is taught as part of the International Computer Science dual degree program at Hochschule Ulm, Germany. (Rose-Hulman)

    CSSE 444: Real-time Systems (4) sys

    Students will learn the features and specifications of real-time systems. Topics covered include real-time operating systems and programming languages, design patterns for real-time systems, scheduling, synchronization, hybrid task sets, and applications of real-time systems. This course is taught as part of the International Computer Science dual degree program at Hochschule Ulm, Germany. (Rose-Hulman)

    CSSE 480: Cross-Platform Development (4) sys

    Programming cross-platform mobile applications that target Android, iOS, and web mobile devices using programmatic UIs, layouts, reusable components, and data persistence via cloud backends. Emphasis is on hands-on use of these components in application development. (Rose-Hulman)

    CSSE 481: Web-Based Information Systems (4) sys

    In this course, students learn about several aspects of research: thinking creatively about interesting research problems, researching existing work in a chosen area, and keeping current in a field. Students are exposed to the process of research by writing a pre-proposal for a project that advances the web. (Rose-Hulman)

    CSSE 483: Android Application Development (4) sys

    An introduction to programming mobile applications using the Android stack. Topics include the activity lifecycle, resources, layouts, intents for multiple activities, menus, fragments and dialogs, adapters, data persistence via shared preferences, SQLite, and web backends. Emphasis is on hands-on use of these components in application development. (Rose-Hulman)

    CSSE 484: iOS Application Development (4) sys

    An introduction to programming mobile applications using the iOS stack. Topics include using X-Code for Swift and Objective-C app development, UI components, Storyboards, view controller actions and outlets, table views, navigation controllers, Core Data, and APIs for backend communication. Emphasis is on hands-on use of these components in application development. Includes a substantial team project (UI mockups, user stories, development, testing, and presentation). (Rose-Hulman)

    CS 40: Cloud Infrastructure and Scalable Application Deployment (3) sys

    Trying to launch your next viral programming project and anticipating substantial user growth? This course will help you learn to implement your ideas in the cloud in a scalable, cost-effective manner. Topics will include cloud AI/ML pipelines, virtual machines, containers, basic networking, expressing infrastructure as code (IaC), data management, security and observability, and continuous integration and deployment (CI/CD). Through hands-on learning and practical examples, you'll learn to effectively deploy and manage cloud infrastructure. There is no out-of-pocket cost associated with this class and cloud credits will be provided for all students. (Stanford)

    CS 45: Software Tools Every Programmer Should Know (2) sys

    Classes teach you all about advanced topics within CS, from operating systems to machine learning, but there's one critical subject that's rarely covered, and is instead left to students to figure out on their own: proficiency with their tools. This course will teach you how to master the key tools necessary for being a successful computer scientist, such as the command line, version control systems, debuggers and linters, and many more. In addition, we will cover other key topics that are left out of standard CS classes, but that are essential to being a proficient computer scientist, including: security and cryptography, containers and virtual machines, and cloud computing. (Stanford)

    CS 47: Cross-Platform Mobile Development (2) sys

    The fundamentals of cross-platform mobile application development using the React Native framework (RN). The Primary focus is on enabling students to build apps for both iOS and Android using RN. Students will explore the unique aspects that made RN a primary tool for mobile development within Facebook, Instagram, Walmart, Tesla, and UberEats, SpaceX, Coinbase and many more. (Stanford)

    CS 49N: Using Bits to Control Atoms (3) sys

    This is a crash course in how to use a stripped-down computer system about the size of a credit card (the rasberry pi computer) to control as many different sensors as we can implement in ten weeks, including LEDs, motion sensors, light controllers, and accelerometers. The ability to fearlessly grab a set of hardware devices, examine the data sheet to see how to use it, and stitch them together using simple code is a secret weapon that software-only people lack, and allows you to build many interesting gadgets. We will start with a 'bare metal' system --- no operating system, no support --- and teach you how to read device data sheets describing sensors and write the minimal code needed to control them (including how to debug when things go wrong, as they always do). This course differs from most in that it is deliberately mostly about what and why rather than how --- our hope is that the things you are able at the end will inspire you to follow the rest of the CS curriculum to understand better how things you've used work. (Stanford)

    CS 80E: Dissecting The Modern Computer (2) sys

    In this course, students will be given a high-level, accessible introduction to computer architecture through the use of the RISC-V ISA. Through a series of interactive units, students will learn about the inner-workings of computers, from the execution of our programs all the way down to the hardware that runs them. Topics include simple digital circuits, assembly, simple processors, memory systems (Cache, DRAM, Disk), and bonus topics like GPU's. After completing this class, students should have a newfound appreciation for how incredible computational technology is, as well as direction to fantastic classes that delve into some of these topics in more detail, like CS 149, EE 108, and EE 180. (Stanford)

    CS 104: Introduction to Essential Software Systems and Tools (3) sys

    Concepts that are prerequisites to many different CS classes, such as version control, debugging, and basic cryptography and networking, are either left for students to figure out on their own or are taught in 'crash course' form on-the-fly during other, unrelated classes. We propose to develop a course that will teach students the skills necessary to be successful computer scientists, such as the command line, source code management and debugging, security and cryptography, containers and virtual machines, and cloud computing. In this course, students will both become proficient with practical tools and develop a deeper, intuitive understanding of the involved software systems and computer science concepts. With this deeper understanding, students can leverage critical thinking skills to intelligently and efficiently configure and troubleshoot software systems, assess the security and efficiency of particular tool usages, and synthesize new automation pipelines that integrate multiple tools. To summarize, instead of having just a cursory understanding of how to use these tools, students will learn how to most effectively use these tools to become proficient programmers and computer scientists. In addition, this course can provide a gentle introduction to potentially challenging computer science concepts (e.g., networking) that become a focus in subsequent courses and also help motivate some of the tool usages they will see later in the degree program. (Stanford)

    CS 107: Computer Organization and Systems (35) sys

    Introduction to the fundamental concepts of computer systems. Explores how computer systems execute programs and manipulate data, working from the C programming language down to the microprocessor. Topics covered include: the C programming language, data representation, machine-level code, computer arithmetic, elements of code compilation, memory organization and management, and performance evaluation and optimization. (Stanford)

    CS 107ACE: Problem-solving Lab for CS 107 (1) sys

    Additional problem solving practice for the introductory CS course CS 107. Sections are designed to allow students to acquire a deeper understanding of CS and its applications, work collaboratively, and develop a mastery of the material. (Stanford)

    CS 107E: Computer Systems from the Ground Up (35) sys

    Introduction to the fundamental concepts of computer systems through bare metal programming on the Raspberry Pi. Explores how five concepts come together in computer systems: hardware, architecture, assembly code, the C language, and software development tools. Students do all programming with a Raspberry Pi kit and several add-ons (LEDs, buttons). Topics covered include: the C programming language, data representation, machine-level code, computer arithmetic, compilation, memory organization and management, debugging, hardware, and I/O. (Stanford)

    CS 110: Principles of Computer Systems (35) sys

    Principles and practice of engineering of computer software and hardware systems. Topics include: techniques for controlling complexity; strong modularity using client-server design, virtual memory, and threads; networks; atomicity and coordination of parallel activities. (Stanford)

    CS 110A: Problem Solving Lab for CS 110 (1) sys

    Additional design and implementation problems to complement the material taught in CS 110. In-class participation is required. (Stanford)

    CS 110L: Safety in Systems Programming (2) sys

    Supplemental lab to CS 110. Explores how program analysis tools can find common bugs in programs and demonstrates how we can use the Rust programming language to build robust systems software. Course is project-based and will examine additional topics in concurrency and networking through the lens of Rust. (Stanford)

    CS 111: Operating Systems Principles (35) sys

    Explores operating system concepts including concurrency, synchronization, scheduling, processes, virtual memory, I/O, file systems, and protection. Available as a substitute for CS 110 that fulfills any requirement satisfied by CS 110. (Stanford)

    CS 111ACE: Problem Solving Lab for CS 111 (1) sys

    Additional design and implementation problems to complement the material taught in CS 111. In-class participation is required. (Stanford)

    CS 112: Operating systems kernel implementation project (3) sys

    Students will learn the details of how operating systems work through four implementation projects in the Pintos operating system. The projects center around threads, processes, virtual memory, and file systems. (Stanford)

    CS 140: Operating Systems and Systems Programming (35) sys

    Covers key concepts in computer systems through the lens of operating system design and implementation. Topics include threads, scheduling, processes, virtual memory, synchronization, multi-core architectures, memory consistency, hardware atomics, memory allocators, linking, I/O, file systems, and virtual machines. Concepts are reinforced with four kernel programming projects in the Pintos operating system. This class may be taken as an accelerated single-class alternative to the CS 111, CS 112 sequence; conversely, the class should not be taken by students who have already taken CS 111 or CS 112. (Stanford)

    CS 140E: Operating systems design and implementation (34) sys

    Students will implement a simple, clean operating system (virtual memory, processes, file system) in the C programming language, on a rasberry pi computer and use the result to run a variety of devices and implement a final project. All hardware is supplied by the instructor, and no previous experience with operating systems, raspberry pi, or embedded programming is required. (Stanford)

    CS 142: Web Applications (3) sys

    Concepts and techniques used in constructing interactive web applications. Browser-side web facilities such as HTML, cascading stylesheets, the document object model, and JavaScript frameworks and Server-side technologies such as server-side JavaScript, sessions, and object-oriented databases. Issues in web security and application scalability. New models of web application deployment. (Stanford)

    CS 144: Introduction to Computer Networking (34) sys

    Principles and practice. Structure and components of computer networks, with focus on the Internet. Packet switching, layering, and routing. Transport and TCP: reliable delivery over an unreliable network, flow control, congestion control. Network names, addresses and ethernet switching. Includes significant programming component in C/C++; students build portions of the internet TCP/IP software. (Stanford)

    CS 145: Data Management and Data Systems (34) sys

    Introduction to the use, design, and implementation of database and data-intensive systems, including data models; schema design; data storage; query processing, query optimization, and cost estimation; concurrency control, transactions, and failure recovery; distributed and parallel execution; semi-structured databases; and data system support for advanced analytics and machine learning. (Stanford)

    CS 147L: Cross-platform Mobile App Development (3) sys

    The fundamentals of cross-platform mobile application development with a focus on the React Native framework (RN). Primary focus on developing best practices in creating apps for both iOS and Android by using Javascript and existing web + mobile development paradigms. Students will explore the unique aspects that made RN a primary tool for mobile development within Facebook, Instagram, Airbnb, Walmart, Tesla, and UberEats. Skills developed over the course will be consolidated by the completion of a final project. (Stanford)

    CS 149: Parallel Computing (34) sys

    This course is an introduction to parallelism and parallel programming. Most new computer architectures are parallel; programming these machines requires knowledge of the basic issues of and techniques for writing parallel software. Topics: varieties of parallelism in current hardware (e.g., fast networks, multicore, accelerators such as GPUs, vector instruction sets), importance of locality, implicit vs. explicit parallelism, shared vs. non-shared memory, synchronization mechanisms (locking, atomicity, transactions, barriers), and parallel programming models (threads, data parallel/streaming, MapReduce, Apache Spark, SPMD, message passing, SIMT, transactions, and nested parallelism). Significant parallel programming assignments will be given as homework. The course is open to students who have completed the introductory CS course sequence through 111. (Stanford)

    CS 152: Trust and Safety (COMM 122, INTLPOL 267) (3) sys

    Trust and Safety is an emerging field of professional and academic effort to build technologies that allow people to positively use the internet while being safe from harm. This course provides an introduction to the ways online services are abused to cause real human harm and the potential social, operational, product, legal and engineering responses. Students will learn about fraud, account takeovers, the use of social media by terrorists, misinformation, child exploitation, harassment, bullying and self-harm. This will include studying both the technical and sociological roots of these harms and the ways various online providers have responded. The class is taught by a practitioner, a professor of communication, a political scientist, and supplemented by guest lecturers from tech companies and nonprofits. Cross-disciplinary teams of students will spend the quarter building a technical and policy solution to a real trust and safety challenge, which will include the application of AI technologies to detecting and stopping abuse. For those taking this course for CS credit, the prerequisite is CS 106B or equivalent programming experience and this course fulfills the Technology in Society requirement. Content note: This class will cover real-world harmful behavior and expose students to potentially upsetting material. (Stanford)

    CS 153: Applied Security at Scale (3) sys

    This course is designed to help students understand the unique challenges of solving security problems at scale, and is taught by senior technology leaders from companies tackling hardware and software security for hundreds of millions of people. The course is split into six parts covering major themes: Basics, Confidential Computing, Privacy, Trust, Safety and Real World. The format of the class will include guest lectures from experts in each theme, covering a blend of both theory and real world scenarios. (Stanford)

    CS 155: Computer and Network Security (3) sys

    For juniors, seniors, and first-year graduate students. Principles of computer systems security. Attack techniques and how to defend against them. Topics include: network attacks and defenses, operating system security, application security (web, apps, databases), malware, privacy, and security for mobile devices. Course projects focus on building reliable software. (Stanford)

    CS 193C: Client-Side Internet Technologies (3) sys

    Client-side technologies used to create web sites such as Google maps or Gmail. Includes HTML5, CSS, JavaScript, the Document Object Model (DOM), and Ajax. (Stanford)

    CS 193X: Web Programming Fundamentals (3) sys

    Introduction to full-stack web development with an emphasis on fundamentals. Client-side topics include layout and rendering through HTML and CSS, event-driven programming through JavaScript, and single-threaded asynchronous programming techniques including Promises. Focus on modern standardized APIs and best practices. Server-side topics include the development of RESTful APIs, JSON services, and basic server-side storage techniques. Covers desktop and mobile web development. (Stanford)

    CS 212: Operating Systems and Systems Programming (35) sys

    Covers key concepts in computer systems through the lens of operating system design and implementation. Topics include threads, scheduling, processes, virtual memory, synchronization, multi-core architectures, memory consistency, hardware atomics, memory allocators, linking, I/O, file systems, and virtual machines. Concepts are reinforced with four kernel programming projects in the Pintos operating system. This class may be taken as an accelerated single-class alternative to the CS 111, CS 112 sequence; conversely, the class should not be taken by students who have already taken CS 111 or CS 112. (Stanford)

    CS 217: Hardware Accelerators for Machine Learning (34) sys

    This course provides in-depth coverage of the architectural techniques used to design accelerators for training and inference in machine learning systems. This course will cover classical ML algorithms such as linear regression and support vector machines as well as DNN models such as convolutional neural nets, and recurrent neural nets. We will consider both training and inference for these models and discuss the impact of parameters such as batch size, precision, sparsity and compression on the accuracy of these models. We will cover the design of accelerators for ML model inference and training. Students will become familiar with hardware implementation techniques for using parallelism, locality, and low precision to implement the core computational kernels used in ML. To design energy-efficient accelerators, students will develop the intuition to make trade-offs between ML model parameters and hardware implementation techniques. Students will read recent research papers and complete a design project. (Stanford)

    CS 229S: Systems for Machine Learning (3) sys

    Deep learning and neural networks are being increasingly adopted across industries. They are now used to serve billions of users across applications such as search, knowledge discovery, and productivity assistants. As models become more capable and intelligent, this trend of large-scale adoption will continue to grow rapidly. Due to the widespread application, there is an increasing need to achieve high performance for both training and serving deep-learning models. However, performance is hindered by a multitude of infrastructure and lifecycle hurdles - the increasing complexity of the models, massive sizes of training and inference data, heterogeneity of the available accelerators and multi-node platforms, and diverse network properties. The slow adaptation of systems to new algorithms creates a bottleneck for the rapid evolution of deep-learning models and their applications. This course will cover systems approaches for improving the efficiency of machine learning pipelines - comprising data preparation, model training, and model deployment & inference -at each level of the systems stack spanning software and hardware. (Stanford)

    CS 240: Advanced Topics in Operating Systems (3) sys

    Recent research. Classic and new papers. Topics: virtual memory management, synchronization and communication, file systems, protection and security, operating system extension techniques, fault tolerance, and the history and experience of systems programming. (Stanford)

    CS 240LX: Advanced Systems Laboratory, Accelerated (3) sys

    This is an implementation-heavy, lab-based class that covers similar topics as CS 240, but by writing code versus discussing papers. Our code will run 'bare-metal' (without an operating system) on the widely-used ARM-based raspberry pi. Bare-metal lets us do interesting tricks without constantly fighting a lumbering, general-purpose OS that cannot get out of its own way. We will do ten projects, one per week, where each project covers two labs of (at a minimum) several hours each and a non-trivial amount of outside work. The workload is significant, but I will aim to not waste your time. (Stanford)

    CS 241: Embedded Systems Workshop (3) sys

    Project-centric building hardware and software for embedded computing systems. This year the course projects are on a large interactive light sculpture to be installed in Packard. Syllabus topics will be determined by the needs of the enrolled students and projects. Examples of topics include: interrupts and concurrent programming, mechanical control, state-based programming models, signaling and frequency response, mechanical design, power budgets, software, firmware, and PCB design. Interested students can help lead community workshops to begin building the installation. (Stanford)

    CS 244: Advanced Topics in Networking (34) sys

    Classic papers, new ideas, and research papers in networking. Architectural principles: why the Internet was designed this way? Congestion control. Wireless and mobility; software-defined networks (SDN) and network virtualization; content distribution networks; packet switching; data-center networks. (Stanford)

    CS 244B: Distributed Systems (3) sys

    Distributed operating systems and applications issues, emphasizing high-level protocols and distributed state sharing as the key technologies. Topics: distributed shared memory, object-oriented distributed system design, distributed directory services, atomic transactions and time synchronization, application-sufficient consistency, file access, process scheduling, process migration, and storage/communication abstractions on distribution, scale, robustness in the face of failure, and security. (Stanford)

    CS 245: Principles of Data-Intensive Systems (34) sys

    Most important computer applications have to reliably manage and manipulate datasets. This course covers the architecture of modern data storage and processing systems, including relational databases, cluster computing frameworks, streaming systems and machine learning systems. Topics include storage management, query optimization, transactions, concurrency, fault recovery, and parallel processing, with a focus on the key design ideas shared across many types of data-intensive systems. (Stanford)

    CS 249I: The Modern Internet (3) sys

    Advanced networking course that covers how the Internet has evolved and operates today. Topics include modern Internet topology and routing practices, recently introduced network protocols, popular content delivery strategies, and pressing privacy, security, and abuse challenges. The course consists of a mixture of lecture, guest talks, and investigative projects where students will analyze how Internet operates in practice. (Stanford)

    CS 251: Cryptocurrencies and blockchain technologies (3) sys

    For advanced undergraduates and for graduate students. The potential applications for Bitcoin-like technologies is enormous. The course will cover the technical aspects of cryptocurrencies, blockchain technologies, and distributed consensus. Students will learn how these systems work, and how to engineer secure software that interacts with Blockchains like Bitcoin, Ethereum, and others. (Stanford)

    CS 253: Web Security (3) sys

    Principles of web security. The fundamentals and state-of-the-art in web security. Attacks and countermeasures. Topics include: the browser security model, web app vulnerabilities, injection, denial-of-service, TLS attacks, privacy, fingerprinting, same-origin policy, cross site scripting, authentication, JavaScript security, emerging threats, defense-in-depth, and techniques for writing secure code. Course projects include writing security exploits, defending insecure web apps, and implementing emerging web standards. (Stanford)

    CS 255: Introduction to Cryptography (3) sys

    For advanced undergraduates and graduate students. Theory and practice of cryptographic techniques used in computer security. Topics: encryption (symmetric and public key), digital signatures, data integrity, authentication, key management, PKI, zero-knowledge protocols, and real-world applications. (Stanford)

    CS 273C: Cloud Computing for Biology and Healthcare (BIOMEDIN 222, GENE 222) (3) sys

    Big Data is radically transforming healthcare. To provide real-time personalized healthcare, we need hardware and software solutions that can efficiently store and process large-scale biomedical datasets. In this class, students will learn the concepts of cloud computing and parallel systems' architecture. (Stanford)

    CS 309A: Cloud Computing Seminar (1) sys

    For science, engineering, computer science, business, education, medicine, and law students. Cloud computing is bringing information systems out of the back office and making it core to the entire economy. Furthermore with the advent of smarter machines cloud computing will be integral to building a more precision planet. This class is intended for all students who want to begin to understand the implications of this technology. Guest industry experts are public company CEOs who are either delivering cloud services or using cloud services to transform their businesses. (Stanford)

    CS 315B: Parallel Computing Research Project (3) sys

    Advanced topics and new paradigms in parallel computing including parallel algorithms, programming languages, runtime environments, library debugging/tuning tools, and scalable architectures. Research project. (Stanford)

    CS 340LX: Advanced Operating System Lab: Accelerated (II) (2) sys

    This is an implementation-heavy, lab-based class that continues the topics from CS 240LX. The labs will be more specialized, with an emphasis on research-worthy topics and techniques. The class format will follow CS 240LX: two labs, twice a week, along with a set of research papers for context. Enrollment requires instructor permission. (Stanford)

    CS 342: Building for Digital Health (34) sys

    This project-based course will provide a comprehensive overview of key requirements in the design and full-stack implementation of a digital health research application. Several pre-vetted and approved projects from the Stanford School of Medicine will be available for students to select from and build. Student teams learn about all necessary approval processes to deploy a digital health solution (data privacy clearance/I RB approval, etc.) and be guided in the development of front-end and back-end infrastructure using best practices. The final project will be the presentation and deployment of a fully approved digital health research application. (Stanford)

    CS 344: Topics in Computer Networks (3) sys

    This class could also be called 'Build an Internet Router': Students work in teams of two to build a fully functioning Internet router, gaining hands-on experience building the hardware and software of a high-performance network system. Students design the control plane in C on a linux host and design the data plane in the new P4 language on both a software switch and a high-speed hardware switch (e.g., Intel Tofino). For the midterm milestone, teams must demonstrate that their routers can interoperate with the other teams by building a small scale datacenter topology. In the final 3-4 weeks of the class, teams will participate in an open-ended design challenge. (Stanford)

    CS 349D: Cloud Computing Technology (3) sys

    The largest change in the computer industry over the past twenty years has arguably been the emergence of cloud computing: organizations are increasingly developing their workloads to be cloud native, using global-scale compute, storage, and communication services that were simply not possible with private infrastructure. This research seminar covers the latest technical advances and open issues in cloud computing, including cloud infrastructure for AI inference and training, cloud databases and data lakes, resource management, serverless computing, confidential computing, multi-cloud computing, and AI for cloud management. Students will propose and develop an original research project in cloud computing. (Stanford)

    CS 349F: Technology for Financial Systems (2) sys

    Financial systems have spurred technological innovation and, in turn, are driven by cutting-edge technological developments. This course explores the synergy. Students will learn from faculty and industry experts how to build faster and fairer financial systems. Topics include network infrastructure: data center fabrics, ultra-low latency trading systems; cloud computing infrastructure: building large-scale risk computation platforms using virtual machines, containers and serverless computing. A particular focus will be on challenges and opportunities presented by cloud-native financial exchanges: the course will provide such an exchange and student groups will write programs for high-frequency and algorithmic trading. (Stanford)

    CS 349H: Software Techniques for Emerging Hardware Platforms (EE 292Y) (3) sys

    Research seminar on software techniques for emerging computational substrates with guest lectures from hardware designers from research and industry. This seminar explores the benefits of novel hardware technologies, the challenges gating broad adoption of these technologies, and how software techniques can help mitigate these challenges and improve the usability of these hardware platforms. Note that the computational substrates discussed vary depending on the semester. Topics covered include: In-memory computing platforms, dynamical system-solving mixed-signal devices, flexible and bendable electronics, neuromorphic computers, intermittent computing platforms, ReRAMs, DNA-based storage, and optical computing platforms. (Stanford)

    CS 349M: Machine Learning for Software Engineering (34) sys

    In recent years, tools based on machine learning have become increasingly prevalent in the software engineering field. The ubiquity of machine learning is an important factor, but just as important is the availability of software engineering data: there are billions of lines of code available in public repositories (e.g. on GitHub), there is the change history of that code, there are discussion fora (e.g. Stack Overflow) that contain a wealth of information for developers, companies have access to telemetry on their apps from millions of users, and so on. The scale of software engineering data has permitted machine learning and statistical approaches to imagine tools that are beyond the capabilities of traditional, semantics-based approaches. In this graduate seminar, students will learn the various ways in which code and related artifacts can be treated as data, and how various developer tools can be built by applying machine learning over this data. The course will consist of discussion of a selection of research papers, as well as a hands-on project that can be done in small groups. (Stanford)

    CS 349T: Project Lab: Video and Audio Technology for Live Theater in the Age of COVID (3) sys

    This class is part of a multi-disciplinary collaboration between researchers in the CS, EE, and TAPS departments to design and develop a system to host a live theatrical production that will take place over the Internet in the winter quarter. The performing arts have been greatly affected by a transition to theater over Zoom and its competitors, none of which are great at delivering low-latency audio to actors, or high-quality audio and video to the audience, or feedback from the audience back to actors. These are big technical challenges. During the fall, we'll build a system that improves on current systems in certain areas: audio quality and latency over spotty Internet connections, video quality and realistic composited scenes with multiple actors, audience feedback, and perhaps digital puppetry. Students will learn to be part of a deadline-driven software development effort working to meet the needs of a theater director and creative specialists -- while communicating the effect of resource limits and constraints to a nontechnical audience. This is an experimental hands-on laboratory class, and our direction may shift as the creative needs of the theatrical production evolve. Based on the success of class projects and subsequent needs, some students may be invited to continue in the winter term with a research appointment (for pay or credit) to operate the system you have built and instruct actors and creative professionals how to work with the system through rehearsals and the final performance before spring break. (Stanford)

    CS 352B: Blockchain Governance (3) sys

    This course offers an overview of blockchain governance and Decentralized Autonomous Organizations (DAOs), with topics including DAO tooling, on-chain and off-chain voting, delegation, constitutional design, alternative governance mechanisms, identity, and privacy. We will cover these topics and others from technical, social science, and legal perspectives, and we will include a range of guests from the web3 space as well as several speakers who are on the frontiers of DAO research. (Stanford)

    CS 356: Topics in Computer and Network Security (3) sys

    Research seminar covering foundational work and current topics in computer and network security. Students will read and discuss published research papers as well as complete an original research project in small groups. Open to Ph.D. and masters students as well as advanced undergraduate students. (Stanford)

    CPSC 031: Introduction to Computer Systems (1) sys

    This course is a broad introduction to computer science that focuses on how a computer works and how programs run on computers. We examine the hardware and software components required to go from a program expressed in a high-level programming language like C or Python to the computer actually running the program. This course takes a bottom-up approach to discovering how a computer works. Topics include theoretical models of computation, data representation, machine organization, assembly and machine code, memory, I/O, the stack, the operating system, compilers and interpreters, processes and threads, and synchronization. This course also introduces parallel and distributed computing with a specific focus on shared memory parallelism for multicore and SMP systems. (Swarthmore)

    CPSC 043: Computer Networks (1) sys

    This course covers the design, implementation and applications of computer networks, primarily focused on the protocols that enable the Internet and network applications. Additionally, this course will cover network security, such as viruses, worms, and botnets. Topics will include: data communication theory; packet-switched routing; the Internet and its protocols; socket and network application programming; overlays and P2P networks; and network security. (Swarthmore)

    CPSC 044: Database Systems (1) sys

    This course provides an introduction to relational database management systems. Topics covered include data models (ER and relational model); data storage and access methods (files, indices); query languages (SQL, relational algebra, relational calculus, QBE); query evaluation; query optimization; transaction management; concurrency control; crash recovery; and some advanced topics (distributed databases, object relational databases). A project that involves implementing and testing components of a relational database management system is a large component of the course. (Swarthmore)

    CPSC 045: Operating Systems (1) sys

    This course is an introduction to the theory, design, and implementation of operating systems. An operating system is the software layer between user programs and the computer hardware. It provides abstractions of the underlying hardware that are easier to program, and it manages the machine's resources. The following topics will be covered: processes (including synchronization, communication, and scheduling); memory (main memory allocation strategies, virtual memory, and page replacement policies); file systems (including naming and implementation issues); I/O (including devices, drivers, disks, and disk scheduling); and security. (Swarthmore)

    CPSC 052: Principles of Computer Architecture (1) sys

    This course covers the physical and logical design of a computer. Topics include current microprocessors, CPU design, RISC and CISC, pipelining, superscalar processing, caching, virtual memory, assembly and machine language, and multiprocessors. Labs cover performance analysis via simulation and microprocessor design using CAD tools. (Swarthmore)

    CPSC 087: Parallel and Distributed Computing (1) sys

    This course covers a broad range of topics related to parallel and distributed computing, including parallel and distributed architectures and systems, parallel and distributed programming paradigms, parallel algorithms, and scientific and other applications of parallel and distributed computing. In lecture/discussion sections, students examine both classic results as well as recent research in the field. The lab portion of the course includes programming projects using different programming paradigms, and students will have the opportunity to examine one course topic in depth through an open-ended project of their own choosing. Course topics may include: multi-core, SMP, MPP, client-server, clusters, clouds, grids, peer-to-peer systems, GPU computing, scheduling, scalability, resource discovery and allocation, fault tolerance, security, parallel I/0, sockets, threads, message passing, MPI, RPC, distributed shared memory, data parallel languages, MapReduce, parallel debugging, and parallel and distributed applications. (Swarthmore)

    CPSC 088: Security and Privacy (1) sys

    This course will cover the breadth of security and privacy topics in Computer Systems including software system security, applied cryptography, denial-of-service, and privacy-preserving mechanisms. This course will also include applied aspects of security and privacy including public policy and legal frameworks of censorship and anonymity. Course topics may include: Buffer overflows and defences, cryptography, symmetric encryption, hash functions, web security, certificates, authentication, denial of service attacks, internet crime - ransomware, botnets, and spam, privacy preserving mechanisms, and internet censorship. (Swarthmore)

    CPSC 089: Cloud Systems and Data Center Networks (1) sys

    On the Internet today, popular services like Google, Facebook, and many others are too large to be hosted by just a few servers. Instead, service providers “scale out” across a coordinated set of hundreds to thousands of machines. Such clusters yield an interesting operating environment, the data center, in which a single administrative entity owns a network at the scale that resembles the Internet. To meet customer demands, administrators often face stringent inter-machine coordination constraints. In this course, we'll examine the current state of the art in providing cloud-based services, including many interesting problems in distributed systems, networking, failure recovery, and OS virtualization. (Swarthmore)

    CPSC 091S: Special Topics: Game Systems (1) sys

    This course studies games using the lens of computing systems; exploring the design and implementation of historic and modern computing systems for games, including the hardware, software, and their interface. This course will go beyond only creating games, and will challenge students to critically reflect on how the architectural and programming choices in games can encode inequality and particular worldviews procedurally, as much as other game elements like visuals, audio and narrative. We will cover the low-level aspects of games platforms: graphics programming, networking, and peripherals; mid-level concerns: software engineering, design patterns, concurrency, and interfaces; and higher-level issues related to emulation, ethics, platform studies and media archaeology. (Swarthmore)

    CSCE 310: Database Systems (3) sys

    File structures and access methods; database modeling, design and user interface; components of database management systems; information storage and retrieval, query languages, high-level language interface with database systems. (Texas A&M)

    CSCE 312: Computer Organization (4) sys

    Computer systems from programmer's perspective including simple logic design, data representation and processor architecture, programming of processors, memory, control flow, input/output, and performance measurements; hands-on lab assignments. (Texas A&M)

    CSCE 313: Introduction to Computer Systems (4) sys

    Introduction to system support for application programs, both on single node and over network including OS application interface, inter-process communication, introduction to system and network programming, and simple computer security concepts; hands-on lab assignments. (Texas A&M)

    CSCE 350: Computer Architecture and Design (4) sys

    Computer architecture and design; use of register transfer languages and simulation tools to describe and simulate computer operation; central processing unit organization, microprogramming, input/output and memory system architectures. (Texas A&M)

    CSCE 410: Operating Systems (3) sys

    Hardware/software evolution leading to contemporary operating systems; basic operating systems concepts; methods of operating systems design and construction including algorithms for CPU scheduling, memory and general resource allocation, process coordination and management; case studies of several operating systems. (Texas A&M)

    CSCE 412: Cloud Computing (3) sys

    Operating system and distributed systems fields that form the basis of cloud computing such as virtualization, key-value storage solutions, group membership, failure detection, peer to peer systems, datacenter networking, resource management and scalability; popular frameworks such as MapReduce and HDFS and case studies on failure determination. (Texas A&M)

    CSCE 413: Software Security (3) sys

    Basic principles of design and implementation of defect-free software, code reviews including tool-assisted review by static and dynamic analysis, risk analysis and management and methods for software security testing. (Texas A&M)

    CSCE 416: Hardware Design Verification (3) sys

    Hardware functional verification; case studies on verification in integrated circuit design; introduction to industry best practices; introduction to logic functional verification. (Texas A&M)

    CSCE 426: Security of Embedded Systems (3) sys

    Security principles; common security features and flaws in day-to-day embedded systems; security analysis, vulnerability exploits and security fixes for embedded systems. (Texas A&M)

    CSCE 435: Parallel Computing (3) sys

    Overview of parallel computing technology and programming methods; includes multiprocessor architectures, programming tools, parallel performance, parallel algorithms, and applications of parallel computing. (Texas A&M)

    CSCE 438: Distributed Systems (3) sys

    Principles and techniques for engineering distributed systems with topics including communication, concurrency, programming paradigms, naming, managing shared state, caching, synchronization, reaching agreement, fault tolerance, security, middleware and distributed applications; design, implement and debug large software systems. (Texas A&M)

    CSCE 449: Applied Cryptography (3) sys

    Applied cryptography; secure multi-party computations; zero knowledge proofs; blockchain and machine learning. (Texas A&M)

    CSCE 451: Software Reverse Engineering (3) sys

    Overview of the compilation mechanism to generate executable files and raw binary codes from source codes; executable file formats for an operating system to run the binary code; disassembly algorithms and control graph analysis; static and dynamic analyses; case studies on code obfuscation, codebreaking, malware analysis. (Texas A&M)

    CSCE 461: Embedded Systems for Medical Applications (3) sys

    Principles of embedded system architecture and programming; fundamentals and theoretical foundations of wireless communication systems; hands-on experiences of how an embedded system could be used to solve problems in biomedical engineering; projects on wireless sensors and imaging for medical devices. (Texas A&M)

    CSCE 462: Microcomputer Systems (3) sys

    Microcomputers as components of systems; VLSI processor and coprocessor architectures, addressing and instruction sets; I/O interfaces and supervisory control; VLSI architectures for signal processing; integrating special purpose processors into a system. (Texas A&M)

    CSCE 463: Networks and Distributed Processing (3) sys

    Basic hardware/software, architectural components for computer communications; computer networks, switching, routing, protocols and security; multiprocessing and distributed processing; interfacing operating systems and networks; case studies of existing networks and network architectures. (Texas A&M)

    CSCE 464: Wireless and Mobile Systems (3) sys

    Introduction to wireless and mobile systems; wireless communication fundamentals; wireless medium access control design; transmission scheduling, network and transport protocols over wireless design, simulation and evaluation; wireless capacity; telecommunication systems; vehicular, adhoc, and sensor network systems; wireless security; mobile applications. (Texas A&M)

    CSCE 465: Computer and Network Security (3) sys

    Fundamental concepts and principles of computer security, operating system and network security, secret key and public key cryptographic algorithms, hash functions, authentication, firewalls and intrusion detection systems, IPSec and VPN, wireless and web security. (Texas A&M)

    CSCE 469: Advanced Computer Architecture (3) sys

    Advanced computer architectures including memory designs, pipeline techniques, and parallel structures such as vector computers and multiprocessors. (Texas A&M)

    CSCE 470: Information Storage and Retrieval (3) sys

    Representation of, storage of and access to very large multimedia document collections; fundamental data structures and algorithms of current information storage and retrieval systems and relates various techniques to design and evaluation of complete retrieval systems. (Texas A&M)

    CSCE 477: Cybersecurity Risk (3) sys

    Risks in cybersecurity; avoidance, acceptance, mitigation, or transference strategies; developing reliable cybersecurity risk assessments to include analysis, categorization, and evaluation; cybersecurity risk audit frameworks. (Texas A&M)

    CS 40: Machine Structure & Assembly-Language Programming (4) sys

    In CS 40, you will learn about both high-level programming design principles and the low-level structure of computing machines. Design strategies will focus on modularity, abstraction, and separation of interface from implementation. The following topics on machine structure are covered: memory, caches, registers, machine arithmetic, and bitwise operations. We will also investigate the structure of assembly code, relocatable object code, binary machine code, and the translations between them. You will gain a deep understanding of all of these concepts via large-scale, realistic programming projects. (Tufts)

    CY305: Cyber Foundations (3) sys

    This course builds on the foundations acquired during the first two years of cadet experiences to ensure graduates have the capacity and confidence to employ information technology--hardware, software, and networks--to empower people and organizations to acquire, manage, communicate and defend information, solve problems, and adapt to change. It provides a deeper understanding of sensor and communications technologies; computer processing, storage, and networks; cyberspace operations, planning and management; interaction of components in Cyberspace; data-driven decision making; and the evolving legal and ethical framework surrounding use of IT and operating in the cyber domain. Cybersecurity issues are addressed throughout the course. Cadets complete projects throughout the course using specified information systems to meet given requirements. (West Point)

    CY350: Computer Networks (3) sys

    This course provides cadets with an introduction to computer networks by breaking the subject into comprehensible parts and building a survey of the state of the art. The goal of the course is to provide each cadet with basic concepts necessary to understand the design and operation of computer networks. Taking a layered approach, it examines the Internet with an emphasis on the TCP/IP protocol suite. Additionally, basic principles including multiplexing, switching, flow control, and error control are covered. Internetworking and its application to both local and wide area networks are also investigated. The course offers an understanding of the current status and future directions of technology and how technology relates to standards. (West Point)

    CY355: Cyber Foundations - Computing (3) sys

    Provides a more in-depth study of computing for cadets who have demonstrated ability beyond the level of CY305. The course covers material presented in CY305 at an accelerated pace to provide cadets additional opportunities for application and hands-on experience with cyber principles and concepts such as encryption and machine learning, with less emphasis on networking. (West Point)

    CS380: Computer Systems & Organizatn (3.5) sys

    This course provides an introduction to computer systems, computer organization and related concepts. Emphasis is placed on understanding the implications of computer hardware and architecture on the performance and security of written code. Students learn basic C programming and assembly language. Topics covered include basic computer organization, architecture, reverse engineering and parallel computing. In addition to theory, students gain practical real-world experience using tools for profiling and debugging. By the end of this programming-intensive course, students will understand how the fundamental principles of computer systems impact their ability to write efficient code. (West Point)

    CY384: Network Systems Programming (3) sys

    This course applies fundamental programming skills to automate interactions with a computer, a local operating system, or the Internet and so use and manage resources and services. Examples of the resources and services that the programming in this course will address include file systems, web servers, mail servers, database servers, image and audio files, compressed and encrypted files and files used in common office environments (documents, presentations, spreadsheets). (West Point)

    CY392: Network Services Management (3) sys

    SCOPE Cadets study network services in terms of design, implementation, maintenance and security of computer servers. The learning process in this course builds on earlier coursework and assumes a functional network with basic connectivity. This course first covers the design and selection of hardware and software to provide network services based on identified user requirements. Cadets then learn to support the Army Enterprise through the implementation and maintenance of network services, including naming, addressing, resource management, voice over IP, and web services. Security is a pervasive theme throughout the course. While this course focuses on the practical aspect of network services, it also gives cadets a foundational understanding of the theories behind those services. (West Point)

    CS393: Database Systems (3) sys

    This course addresses the analysis, design implementation, and management of relational databases. Structured query language (SQL) is covered in depth along with standard problem domain and data modeling techniques. Implementation techniques and considerations are discussed and practiced extensively. Key concepts include analysis and design using a standardized notation, data model to logical schema conversion techniques, normalization, data security, client-server architectures and web-based access to database systems. Students are exposed to user and privilege management, database backup and recovery, and security vulnerabilities such as SQL injection. (West Point)

    CS394: Distrib Application Engrng (3) sys

    Building on the foundations of algorithm implementation, data structures, data representation, and object oriented programming this course focuses on the principles of designing, implementing, and testing a modern distributed application. Cadets study the construction and interaction of user interface, network, web server, database, and other components to produce an integrated working secure system. Cadets will learn new tools and skills working as a team to analyze, design, and implement a system that solves a given problem. This is one of the courses that a Computer Science major can choose from a list of elective courses and the focus is on data structure concepts and object oriented programming. (West Point)

    CY394: Cloud Computing (3) sys

    SCOPE This course provides a solid background in cloud computing principles and applications. It includes understanding cloud computing fundamentals, cloud architecture considerations, cloud technology service selection, and cloud computing security controls. The course does not focus on vendor specific cloud solutions like Amazon Web Services or Microsoft Azure, but instead focuses on the tools and management of cloud computing systems that could be deployed on these vendor specific platforms. Cadets will examine various cloud services and recommend solutions to problems utilizing cloud services. They will also learn how to take existing distributed applications and configure and deploy them to cloud environments. The culmination of the course is a group project that solves a problem utilizing cloud services and technologies (West Point)

    CY450: Cyber Security Engineering (3) sys

    SCOPE The focus for this course is to design, build and test secure networked computer systems. Topics covered include operating system and network security, secure network architecture, and offensive and defensive information operations. Practical exercises that give students hands-on experience with current network security tools and techniques complement a series of laboratory exercises that have small groups of cadets secure their own small network. In a culminating exercise, cadets design, build and test defensive measures to protect a production network from intrusions. (West Point)

    CY465: Organizational Security (3) sys

    SCOPE This course focuses on techniques and considerations related to protecting organizations from cybersecurity threats and managing risk to support successful accomplishment of the organization's mission. Topics include cyber governance and policy, personnel security, security operations, systems administration, cybersecurity planning, procurement, and business continuity. (West Point)

    CS481: Operating Systems (3) sys

    The operating system controls the computer itself and provides a secure and useful interface for users and application programs. The operating system controls all the computer resources: processors, main storage, secondary storage, I/O devices, and files. It determines which programs will be in memory at any given time and the order in which programs will run. The operating system should resolve conflicts between processes, attempt to optimize the performance of the computer, allow the computer to communicate with other computers, and maintain a record of actions performed as it goes about its system tasks. This course investigates the basic design issues encountered in order to produce an operating system that can address the above problems in an efficient manner. These concepts are reinforced by a series of programming projects that include both design and implementation. (West Point)

    CS483: Digital Forensics (3) sys

    Digital Forensics will explore the evidence left behind when malicious activity occurs on an information system. The material in this course will build on your knowledge of Operating Systems, file formats, file system structure, computer architecture, and networking. The course begins with an overview of these areas, then examines how to find and extract digital evidence. During the course, you will be challenged with three projects (subjects to be chosen by you) and in class challenges that will allow you to demonstrate your understanding of the material. (West Point)

    CS484: Advanced Computer Networks (3) sys

    This course builds on an understanding of basic networking topics and provides cadets with an advanced understanding of computer networks. This course explores more deeply the problems facing modern computer networks. It covers advanced networking techniques that are enabling rapid innovation to solve challenges in routing, congestion control, traffic engineering, mobility, and reliability. Specific topics covered will vary but may include software-defined networking and programmable network devices. (West Point)

    CS 152: Computer Architecture and Engineering (4) sys

    Instruction set architecture, microcoding, pipelining (simple and complex). Memory hierarchies and virtual memory. Processor parallelism: VLIW, vectors, multithreading. Multiprocessors. (Berkeley)

    CS 161: Computer Security (4) sys

    Introduction to computer security. Cryptography, including encryption, authentication, hash functions, cryptographic protocols, and applications. Operating system security, access control. Network security, firewalls, viruses, and worms. Software security, defensive programming, and language-based security. Case studies from real-world systems. (Berkeley)

    CS 162: Operating Systems and System Programming (4) sys

    Basic concepts of operating systems and system programming. Utility programs, subsystems, multiple-program systems. Processes, interprocess communication, and synchronization. Memory allocation, segmentation, paging. Loading and linking, libraries. Resource allocation, scheduling, performance evaluation. File systems, storage devices, I/O systems. Protection, security, and privacy. (Berkeley)

    CS 168: Introduction to the Internet: Architecture and Protocols (4) sys

    This course is an introduction to the Internet architecture. We will focus on the concepts and fundamental design principles that have contributed to the Internet's scalability and robustness and survey the various protocols and algorithms used within this architecture. Topics include layering, addressing, intradomain routing, interdomain routing, reliable delivery, congestion control, and the core protocols (e.g., TCP, UDP, IP, DNS, and HTTP) and network technologies (e.g., Ethernet, wireless). (Berkeley)

    CS 186: Introduction to Database Systems (4) sys

    Access methods and file systems to facilitate data access. Hierarchical, network, relational, and object-oriented data models. Query languages for models. Embedding query languages in programming languages. Database services including protection, integrity control, and alternative views of data. High-level interfaces including application generators, browsers, and report writers. Introduction to transaction processing. Database system implementation to be done as term project. (Berkeley)

    CSE 29: Systems Programming and Software Tools (4) sys

    A programmer's view of how computer systems execute programs, store information, and communicate. Emphasis on understanding the details of how a single computer program executes on a computer. Hands-on systems programming using the C programming language and software tools (e.g., gdb, valgrind, make) in the UNIX environment. Builds foundation for courses on computer organization, operating systems, networks, and compilers. (UCSD)

    CSE 30: Computer Organization and Systems Programming (4) sys

    Introduction to organization of modern digital computers—understanding the various components of a computer and their interrelationships. Study of a specific architecture/machine with emphasis on systems programming in C and Assembly languages in a UNIX environment. (UCSD)

    CSE 118: Ubiquitous Computing (4) sys

    Explores emerging opportunities enabled by cheap sensors and networked computing devices. Small research projects will be conducted in teams, culminating in project presentations at the end of the term. Section will cover material relevant to the project, such as research methods, software engineering, teamwork, and project management. (UCSD)

    CSE 120: Principles of Computer Operating Systems (4) sys

    Basic functions of operating systems; basic kernel structure, concurrency, memory management, virtual memory, file systems, process scheduling, security and protection. (UCSD)

    CSE 121: Real-World Operating Systems (4) sys

    Case study of architecture and implementation of a modern operating system or parts of multiple operating systems. In-depth analysis through detailed study of deployed source code. Topics vary based on OS understudy each term. Emphasis on emerging concerns and the new techniques and technologies used to address them. (UCSD)

    CSE 122: Wireless Networks (4) sys

    This course covers the design, operation, and use of wireless technologies, with emphasis on how physical resource constraints and application constraints meet to affect link, network, system, and application design, with hands-on experience in multiple technologies. (UCSD)

    CSE 123: Computer Networks (4) sys

    Introduction to concepts, principles, and practice of computer communication networks with examples from existing architectures, protocols, and standards with special emphasis on the internet protocols. (UCSD)

    CSE 124: Networked Services (4) sys

    The architecture of modern networked services, including data center design, enterprise storage, fault tolerance, and load balancing. Protocol software structuring, the Transmission Control Protocol (TCP), remote procedure calls, protocols for digital audio and video communication, overlay and peer-to-peer systems, secure communication. (UCSD)

    CSE 127: Introduction to Computer Security (4) sys

    Topics include basic cryptography, security/threat analysis, access control, auditing, security models, distributed systems security, and theory behind common attack and defense techniques. The class will go over formal models as well as the bits and bytes of security exploits. (UCSD)

    CSE 132A: Database System Principles (4) sys

    Basic concepts of databases, including data modeling, relational databases, query languages, optimization, dependencies, schema design, and concurrency control. Exposure to one or several commercial database systems. Advanced topics such as deductive and object-oriented databases, time allowing. (UCSD)

    CSE 132B: Database Systems Applications (4) sys

    Design of databases, transactions, use of trigger facilities and datablades. Performance measuring, organization of index structures. (UCSD)

    CSE 132C: Database System Implementation (4) sys

    This is a systems-focused course on the internals of a relational database management system (RDBMS). RDBMSs power large-scale structured data management in most digital applications. The topics span data storage, buffer management, indexing, sorting, relational operator implementations, query processing and optimization, parallel RDBMSs, and “Big Data” systems. Two C++ programming projects require implementation of a buffer manager and a B+ tree index using a given RDBMS skeleton. Recommended preparation: C++ programming knowledge is required; CSE 132B is recommended. (UCSD)

    CSE 134B: Web Client Languages (4) sys

    Design and implementation of interactive World Wide Web clients using helper applications and plug-ins. The main language covered will be Java. (UCSD)

    CSE 135: Online Database Analytics Applications (4) sys

    Database, data warehouse, and data cube design; SQL programming and querying with emphasis on analytics; online analytics applications, visualizations, and data exploration; performance tuning. (UCSD)

    CSE 136: Enterprise-Class Web Applications (4) sys

    Design and implementation of very large-scale, web-based applications. Topics covered typically include modeling organizational needs, design and revision management, J2EE or similar software platforms, web server and application server functionality, reuse of object-oriented components, model-view-controller and other design patterns, clustering, load-balancing, fault-tolerance, authentication, and usage accounting. (UCSD)

    CSE 140: Components and Design Techniques for Digital Systems (4) sys

    Design of Boolean logic and finite state machines; two-level, multilevel combinational logic design, combinational modules and modular networks, Mealy and Moore machines, analysis and synthesis of canonical forms, sequential modules. (UCSD)

    CSE 140L: Digital Systems Laboratory (2) sys

    Implementation with computer-aided design tools for combinational logic minimization and state machine synthesis. Hardware construction of a small digital system. (UCSD)

    CSE 141: Introduction to Computer Architecture (4) sys

    Introduction to computer architecture. Computer system design. Processor design. Control design. Memory systems. (UCSD)

    CSE 141L: Project in Computer Architecture (2) sys

    Hands-on computer architecture project aiming to familiarize students with instruction set architecture, and design of process. Control and memory systems. (UCSD)

    CSE 142: Introduction to Computer Architecture: A Software Perspective (4) sys

    This course covers the operation, structure, and programming interfaces of modern CPUs with an emphasis on exploiting processor features to improve software performance and efficiency. (UCSD)

    CSE 142L: Software Project for Computer Architecture (2) sys

    This course provides hands-on experience in using the features of modern CPUs to increase the performance and efficiency of programs. (UCSD)

    CSE 143: Microelectronic System Design (4) sys

    VLSI process technologies; circuit characterization; logic design styles; clocking strategies; computer-aided design tools; subsystem design; design case studies. (UCSD)

    CSE 145: Embedded System Design Project (4) sys

    Project class building an embedded computing system. Learn fundamental knowledge of microcontrollers, sensors, and actuators. (UCSD)

    CSE 147: Introduction to Embedded Systems (4) sys

    This course introduces the breadth of embedded systems, including hardware, software and modeling techniques. (UCSD)

    CSE 148: Advanced Processor Architecture Design Project (4) sys

    Students will use hardware description language tools to add advanced architectural features to a basic processor design. (UCSD)

    CSE 160: Introduction to Parallel Computing (4) sys

    Introduction to high performance parallel computing: parallel architecture, algorithms, software, and problem-solving techniques. Areas covered: Flynn’s taxonomy, processor-memory organizations, shared and nonshared memory models: message passing and multithreading, data parallelism; speedup, efficiency and Amdahl’s law, communication and synchronization, isoefficiency and scalability. Assignments given to provide practical experience. (UCSD)

    CSE 176E: Robot Systems Design and Implementation (4) sys

    End-to-end system design of embedded electronic systems including PCB design and fabrication, software control system development, and system integration. (UCSD)

    CSE 182: Biological Databases (4) sys

    This course provides an introduction to the features of biological data, how those data are organized efficiently in databases, and how existing data resources can be utilized to solve a variety of biological problems. Object oriented databases, data modeling and description. (UCSD)

    CMPSC 64: Computer Organization and Logic Design (4) sys

    Assembly language programming and advanced computer organization; Digital logic design topics including gates, combinational circuits, flip-flops, and the design and analysis of sequential circuits. (UCSB)

    CMPSC 123: Overview of Computer Systems: Hardware and Software (4) sys

    Basic computer architecture: CPU, memory, I/O. Basic operating systemsConcepts: processes, synchronization, memory management, virtual memory, file systems. (UCSB)

    CMPSC 140: Parallel Scientific Computing (4) sys

    Fundamentals of high performance computing and parallel algorithm design for numerical computation. Topics include parallel architectures and clusters, parallel programming with message-passing libraries and threads, program parallelization methodologies, parallel performance evaluation and optimization, parallel numerical algorithms and applications with different performance tradeoffs. (UCSB)

    CMPSC 154: Computer Architecture (4) sys

    Introduction to the architecture of computer systems. Topics include: central processing units, memory systems, channels and controllers, peripheral devices, interrupt systems, software versus hardware tradeoffs. (UCSB)

    CMPSC 170: Operating Systems (4) sys

    Basic concepts of operating systems. The notion of a process; interprocess communication and synchronization; input-output, file systems, memory management. (UCSB)

    CMPSC 171: Distributed Systems (4) sys

    Distributed systems architecture, distributed programming, network of computers, message passing, remote procedure calls, group communication, naming and membership problems, asynchrony, logical time, consistency, fault-tolerance, and recovery. (UCSB)

    CMPSC 174A: Fundamentals of Database Systems (4) sys

    Database system architectures, relational data model, relational algebra, relational calculus, SQL, QBE, query processing, integrity constraints (key constraints, referential integrity), database design, ER and object-oriented data model, functional dependence, lossless join and dependency preserving decompositions, Boyce-Codd and Third Normal Forms. (UCSB)

    CMPSC 174B: Design and Implementation Techniques of Database Systems (4) sys

    Queries and processing, optimizer, cost models, execution plans, rewriting rules, access methods, spatial indexing; transactions, ACID properties, concurrency control, serializability, two-phase locking, timestamping, logging, checkpointing, transaction abort and commit, crash recovery; distributed databases. (UCSB)

    CMPSC 176A: Introduction to Computer Communication Networks (4) sys

    Basic concepts in networking, the OSI model, error detection codes, flow control, routing, medium access control, and high-speed networks. (UCSB)

    CMPSC 176B: Network Computing (4) sys

    Focus on networking and web technologies used in the Internet. The class covers socket programming and web-based techniques that are used to build distributed applications. (UCSB)

    CMPSC 176C: Advanced Topics in Internet Computing (4) sys

    General overview of wireless and mobile networking, multimedia, security, multicast, quality of service, IPv6, and web caching. During the second half of the course, one or more of the above are studied in greater detail. (UCSB)

    CMPSC 177: Computer Security (4) sys

    Introduction to the basics of computer security and privacy. Analysis of technical difficulties of producing secure computer information systems that provide guaranteed controlled sharing. Examination and critique of current systems, methods, certification. (UCSB)

    CMPSC 182: Multimedia Computing (4) sys

    Introduction to multimedia and applications. Topics include streaming media, conferencing, webcasting, digital libraries, multimedia system architectures, standards (including JPEG and MPEG), and multimedia storage and retrieval. A key emphasis is on using the internet for delivery of multimedia data. (First offered 2003-2004) (UCSB)

    CMPSC 184: Mobile Application Development (4) sys

    An introduction to programming mobile computing devices. Students will learn about and study the shift in software development from desktop to mobile device applications. Topics will include software engineering and design practices, advances in programming practice, and support tools for mobile application development and testing. Students will develop and deploy mobile applications as part of their course work. (UCSB)

    CS 233: Computer Architecture (4) sys

    Fundamentals of computer architecture: digital logic design, machine-level programming, performance models of modern computer architectures, hardware primitives for parallelism and security. (Illinois)

    CS 340: Introduction to Computer Systems (3) sys

    Basics of computer systems. Number representations, assembly/machine language, abstract models of processors, processes/process control, simple memory management, file I/O and directories, network programming, usage of cloud services. (Illinois)

    CS 341: System Programming (4) sys

    Basics of system programming, including POSIX processes, process control, inter-process communication, synchronization, signals, simple memory management, file I/O and directories, shell programming, socket network programming, RPC programming in distributed systems, basic security mechanisms, and standard tools for systems programming. (Illinois)

    CS 409: The Art of Web Programming (3) sys

    Client- and server-side technologies that enable modern Web applications. Topics include the building blocks of the Web (browsers, HTML, CSS, JavaScript) and data exchange (HTTP, AJAX, JSON, REST). Assignments expose students to full-stack web development, and JavaScript frameworks that scaffold MVC architectures and event-driven, asynchronous programming. The course culminates in a final project, where students work in teams to design and develop an original, database-backed web application. (Illinois)

    CS 410: Text Information Systems (3) sys

    Theory, design, and implementation of text-based information systems. Text analysis, retrieval models (e.g., Boolean, vector space, probabilistic), text categorization, text filtering, clustering, retrieval system design and implementation, and applications to web information management. (Illinois)

    CS 411: Database Systems (3) sys

    Examination of the logical organization of databases: the entity-relationship model; the hierarchical, network, and relational data models and their languages. Functional dependencies and normal forms. Design, implementation, and optimization of query languages; security and integrity; concurrency control, and distributed database systems. (Illinois)

    CS 414: Multimedia Systems (3) sys

    Organization and structure of modern multimedia systems; audio and video encoding; quality of service concepts; scheduling algorithms for multimedia within OS and networks multimedia protocols over high-speed networks; synchronization schemes, user-interface design; multimedia teleservices. (Illinois)

    CS 420: Parallel Progrmg: Sci & Engrg (3) sys

    Fundamental issues in design and development of parallel programs for various types of parallel computers. Various programming models according to both machine type and application area. Cost models, debugging, and performance evaluation of parallel programs with actual application examples. Same as CSE 402 and ECE 492. (Illinois)

    CS 423: Operating Systems Design (3) sys

    Organization and structure of modern operating systems and concurrent programming concepts. Deadlock, virtual memory, processor scheduling, and disk systems. Performance, security, and protection. Same as CSE 423. (Illinois)

    CS 424: Real-Time Systems (3) sys

    Supervisory control aspects of Cyber Physical Systems (CPS): fundamentals of reliability analysis, real-time scheduling, simple feedback control, software fault tolerance architecture, wireless networking and energy saving, principles of safety critical system engineering. Student groups design and demonstrate supervisory control architecture for a robot. (Illinois)

    CS 425: Distributed Systems (3) sys

    Protocols, specification techniques, global states and their determination, reliable broadcast, transactions and commitment, security, and real-time systems. Same as ECE 428. (Illinois)

    CS 431: Embedded Systems (3) sys

    Students will learn embedded system architecture, Real-Time Operating Systems, and real-time software design and development techniques. (Illinois)

    CS 433: Computer System Organization (3) sys

    Computer hardware design and analysis and interface with software. Advanced processor design, memory hierarchy design, principles of multiprocessor design. (Illinois)

    CS 435: Cloud Networking (3) sys

    Provides a foundational view of computer networks with a focus on enabling modern large-scale cloud computing. (Illinois)

    CS 436: Computer Networking Laboratory (3) sys

    Design, application, analysis, and deployment of communication protocols and system software behind modern cloud/compute/network infrastructures. (Illinois)

    CS 437: Topics in Internet of Things (3) sys

    Topics of networked embedded computing technology, known as the Internet of Things, in application, distributed, human-centric, or social contexts. (Illinois)

    CS 438: Communication Networks (3) sys

    Layered architectures and the OSI Reference Model; design issues and protocols in the transport, network, and data link layers. (Illinois)

    CS 460: Security Laboratory (3) sys

    Operating systems security: access control, least privilege mechanism and malware techniques. Network security: firewalls, sniffing, tunnels, intrusion detection, AAA and worm structure. System security: forensics security architectures, and attack/defend exercises. (Illinois)

    CS 461: Computer Security I (4) sys

    Fundamental principles of computer and communications security and information assurance: ethics, privacy, notions of threat, vulnerabilities, and risk in systems, information warfare, malicious software, data secrecy and integrity issues, network security, trusted computing, mandatory and discretionary access controls, certification and accreditation of systems against security standards. (Illinois)

    CS 463: Computer Security II (3) sys

    Program security, trusted base, privacy, anonymity, non-interference, information flow, confinement, advanced auditing, forensics, intrusion detection, key management and distribution, policy composition and analysis, formal approaches to specification and verification of secure systems and protocols, and topics in applied cryptography. (Illinois)

    CS 484: Parallel Programming (3) sys

    Techniques for the programming of all classes of parallel computers and devices including shared memory and distributed memory multiprocessors, SIMD processors and co-processors, and special purpose devices. Key concepts in parallel programming such as reactive and transformational programming, speculation, speedup, isoefficiency, and load balancing. Synchronization primitives, libraries and languages for parallel programming such as OpenMP and MPI, performance monitoring, program tuning, analysis and programming of numerical and symbolic parallel algorithms. (Illinois)

    CS 314: Computer Organization (4) sys

    Introduction to computer organization and instruction-set architecture -- digital logic design, binary arithmetic, design of central processing unit and memory, machine-level programming. (UO)

    CS 330: C/C++ and Unix (4) sys

    Practical software design and programming activities in a C/C++ and Unix environment, with emphasis on the details of C/C++ and good programming style and practices. (UO)

    CS 332: System and Security Administration Lab (4) sys

    (UO)

    CS 333: Applied Cryptography (4) sys

    This course provides a systematic study of cryptography and its application. It covers cryptographic algorithms, including symmetric-key cryptography, public-key cryptography, cryptanalysis, cryptographic hash functions, and their usage toward message authentication codes, digital signatures, key management and distribution, and user authentication protocols. (UO)

    CS 415: Operating Systems (4) sys

    Principles of operating system design. Process and memory management, concurrency, scheduling, input-output and file systems, security. (UO)

    CS 429: Computer Architecture (4) sys

    RISC (reduced instruction-set computer) and CISC (complex instruction-set computer) design, storage hierarchies, high-performance processor design, pipelining, vector processing, networks, performance analysis. (UO)

    CS 431: Introduction to Parallel Computing (4) sys

    Parallel architecture, theory, algorithms, and programming with emphasis on parallel programming, focusing on models, languages, libraries, and runtime systems. (UO)

    CS 432: Introduction to Networks (4) sys

    Principles of computer network design. Link technologies, packet switching, routing, inter-networking, reliability. Internet protocols. Programming assignments focus on protocol design. (UO)

    CS 433: Computer and Network Security (4) sys

    Security for various aspects of computers and networks. Elementary cryptography, program security, trusted operating systems, network security, privacy, and legal and ethical issues. (UO)

    CS 434: Computer and Network Security II (4) sys

    This course covers security threats and solutions for distributed systems and networks, particularly the Internet, the Internet of Things, and distributed systems based on them. (UO)

    CS 436: Secure Software Development (4) sys

    This course establishes a foundation for applying security principles to the lifecycle of software development in order to minimize software vulnerabilities and counter cyber threats. (UO)

    CS 437: Computer and Network Security Practicum (4) sys

    (UO)

    CS 451: Database Processing (4) sys

    Fundamental concepts of DBMS. Data modeling, relational models and normal forms. File organization and index structures. SQL, embedded SQL, and concurrency control. (UO)

    CIS 2400: Introduction to Computer Systems (1) sys

    You know how to program, but do you know how computers really work? How do millions of transistors come together to form a complete computing system? This bottom-up course begins with transistors and simple computer hardware structures, continues with low-level programming using primitive machine instructions, and finishes with an introduction to the C programming language. This course is a broad introduction to all aspects of computer systems architecture and serves as the foundation for subsequent computer systems courses, such as Computer Organization and Design (CIS 4710), Computer Operating Systems (CIS 3800), and Compilers and Interpreters (CIS 3410). (Penn)

    CIS 4410: Embedded Software for Life-Critical Applications (1) sys

    The goal of this course is to give students greater design and implementation experience in embedded software development and to teach them how to model, design, verify, and validate safety critical systems in a principled manner. Students will learn the principles, methods, and techniques for building life-critical embedded systems, ranging from requirements and models to design, analysis, optimization, implementation, and validation. Topics will include modeling and analysis methods and tools, real-time programming paradigms and languages, distributed real-time systems, global time, time-triggered communications, assurance case, software architecture, evidence-based certification, testing, verification, and validation. The course will include a series of projects that implements life-critical embedded systems (e.g., pacemaker, infusion pumps, closed-loop medical devices). (Penn)

    CIS 4480: Operating Systems Design and Implementation (1) sys

    The purpose of this course is to teach the design and implementation of operating systems and operating systems concepts that appear in other advanced systems. The course divides into three major sections. The first part of the course discusses concurrency: how to manage multiple tasks that execute at the same time and share resources. Topics in this section include processes and threads, context switching, synchronization, scheduling, and deadlock. The second part of the course addresses the problem of memory management; it will cover topics such as linking, dynamic memory allocation, dynamic address translation, virtual memory, and demand paging. The third major part of the course concerns file systems, including topics such as storage devices, disk management and scheduling, directories, protection, and crash recovery. After these three major topics, the class will conclude with specialized topics such as virtual machines and case studies of different operating systems (e.g. Android, Windows, Linux, etc.). (Penn)

    CIS 4500: Database and Information Systems (1) sys

    This course provides an introduction to the broad field of database and information systems, covering a variety of topics relating to structured data, ranging from data modeling to logical foundations and popular languages, to system implementations. We will study the theory of relational and XML data design; the basics of query languages; efficient storage of data, execution of queries and query optimization; transactions and updates; web-database development; and 'big data' and NoSQL systems. The course assumes mathematical and programming experience equivalent to CIS 1600 and CIS 1210. (Penn)

    CIS 4510: Computer and Network Security (1) sys

    This is an introduction to topics in the security of computer systems and communication on networks of computers. The course covers four major areas: fundamentals of cryptography, security for communication protocols, security for operating systems and mobile programs, and security for electronic commerce. Sample specific topics include: passwords and offline attacks, DES, RSA, DSA, SHA, SSL, CBC, IPSec, SET, DDoS attacks, biometric authentication, PKI, smart cards, S/MIME, privacy on the Web, viruses, security models, wireless security, and sandboxing. Students will be expected to display knowledge of both theory and practice through written examinations and programming assignments. (Penn)

    CIS 4550: Internet and Web Systems (1) sys

    This course focuses on the challenges encountered in building Internet and web systems: scalability, interoperability (of data and code), security and fault tolerance, consistency models, and location of resources, services, and data. We will examine how XML standards enable information exchange; how web services support cross-platform interoperability (and what their limitations are); how to build high-performance application servers; how 'cloud computing' services work; how to perform Akamai-like content distribution; and how to provide transaction support in distributed environments. We will study techniques for locating machines, resources, and data (including directory systems, information retrieval indexing, ranking, and web search); and we will investigate how different architectures support scalability (and the issues they face). We will also examine ideas that have been proposed for tomorrow's Web, and we will see some of the challenges, research directions, and potential pitfalls. An important goal of the course is not simply to discuss issues and solutions, but to provide hands-on experience with a substantial implementation project. This semester's project will be a peer-to-peer implementation of a Googe-style search engine, including distributed, scalable crawling; indexing with ranking; and even PageRank. As a side-effect of the material of this course you will learn about some aspects of large-scale software development assimilating large APIs. (Penn)

    CIS 4710: Computer Organization and Design (1) sys

    This is the second computer organization course and focuses on computer hardware design. Topics covered are: (1) basic digital system design including finite state machines, (2) instruction set design and simple RISC assembly programming, (3) quantitative evaluation of computer performance, (4) circuits for integer and floating-point arithmatic, (5) datapath and control, (6) micro-programming, (7) pipeling, (8) storage hierarchy and virtual memory, (9) input/output, (10) different forms of parallelism including instruction level parallelism, data-level parallelism using both vectors and message-passing multi-processors, and thread-level parallelism using shared memory multiprocessors. Basic cache coherence and synchronization. (Penn)

    CIS 5010: Computer Architecture (1) sys

    This course is an introductory graduate course on computer architecture with an emphasis on a quantitative approach to cost/performance design tradeoffs. The course covers the fundamentals of classical and modern uniprocessor design: performance and cost issues, instruction sets, pipelining, superscalar, out-of-order, and speculative execution mechanisms, caches, physical memory, virtual memory, and I/O. Other topics include: static scheduling, VLIW and EPIC, software speculation, long (SIMD) and short (multimedia) vector execution, multithreading, and an introduction to shared memory multiprocessors. Knowledge of computer organization and basic programming skills. (Penn)

    CIS 5050: Software Systems (1) sys

    This course provides an introduction to fundamental concepts of distributed systems, and the design principles for building large scale computational systems. Topics covered include communication, concurrency, programming paradigms, naming, managing shared state, caching, synchronization, reaching agreement, fault tolerance, security, middleware, and distributed applications. This course is appropriate as an upper-level undergraduate CIS elective. (Penn)

    CIS 5400: Principles of Embedded Computation (1) sys

    This course is focused on principles underlying design and analysis of computational elements that interact with the physical environment. Increasingly, such embedded computers are everywhere, from smart cameras to medical devices to automobiles. While the classical theory of computation focuses on the function that a program computes, to understand embedded computation, we need to focus on the reactive nature of the interaction of a component with its environment via inputs and outputs, the continuous dynamics of the physical world, different ways of communication among components, and requirements concerning safety, timeliness, stability, and performance. Developing tools for approaching design, analysis, and implementation of embedded systems in a principled manner is an active research area. This course will attempt to give students a coherent introduction to this emerging area. This course is appropriate as an upper-level undergraduate CIS elective. (Penn)

    CIS 5410: Embedded Software for Life-Critical Applications (1) sys

    The goal of this course is to give students greater design and implementation experience in embedded software development and to teach them how to model, design, verify, and validate safety critical systems in a principled manner. Students will learn the principles, methods, and techniques for building life-critical embedded systems, ranging from requirements and models to design, analysis, optimization, implementation, and validation. Topics will include modeling and analysis methods and tools, real-time programming paradigms and languages, distributed real-time systems, global time, time-triggered communications, assurance case, software architecture, evidence-based certification, testing, verification, and validation. (Penn)

    CIS 5420: Embedded Systems Programming (1) sys

    This course explores techniques for writing correct and efficient embedded code. Topics include C/C++ idioms, data abstraction, elementary data structures and algorithms, environment modeling, concurrency, hard real time, and modular program reasoning. C fluency. (Penn)

    CIS 5480: Operating Systems Design and Implementation (1) sys

    The purpose of this masters-level course is to teach the design and implementation of operating systems and operating systems concepts that appear in other advanced systems. The course divides into three major sections. The first part of the course discusses concurrency: how to manage multiple tasks that execute at the same time and share resources. Topics in this section include processes and threads, context switching, synchronization, scheduling, and deadlock. The second part of the course addresses the problem of memory management; it will cover topics such as linking, dynamic memory allocation, dynamic address translation, virtual memory, and demand paging. The third major part of the course concerns file systems, including topics such as storage devices, disk management and scheduling, directories, protection, and crash recovery. After these three major topics, the class will conclude with specialized topics such as virtual machines and case studies of different operating systems (e.g. Android, Windows, Linux, etc.). (Penn)

    CIS 5490: Wireless Communications for Mobile Networks and Internet of Things (1) sys

    This course covers generations of wireless mobile network standards and systems, basic differences and their evolution, charting the development of mobile telecommunications systems from 3G, to today's state-of-the-art wireless technology 4G LTE, and the next generation wireless technology, 5G. (Penn)

    CIS 5500: Database and Information Systems (1) sys

    This course provides an introduction to the broad field of database and information systems, covering a variety of topics relating to structured data, ranging from data modeling to logical foundations and popular languages, to system implementations. We will study the theory of relational and XML data design; the basics of query languages; efficient storage of data, execution of queries and query optimization; transactions and updates; web-database development; and 'big data' and NoSQL systems. (Penn)

    CIS 5510: Computer and Network Security (1) sys

    This is an introduction to topics in the security of computer systems and communication on networks of computers. The course covers four major areas: fundamentals of cryptography, security for communication protocols, security for operating systems and mobile programs, and security for electronic commerce. (Penn)

    CIS 5530: Networked Systems (1) sys

    This course provides an introduction to fundamental concepts in the design and implementation of networked systems, their protocols, and applications. Topics to be covered include: Internet architecture, network applications, addressing, routing, transport protocols, network security, and peer-to-peer networks. The course will involve written assignments, examinations, and programming assignments.. Students will work in teams to design and implement networked systems in layers, from routing protocols, transport protocols, to peer-to-peer networks. Preparation for this course would include taking CIS 1210 or equivalent knowledge. (Penn)

    CIS 5550: Internet and Web Systems (1) sys

    This course focuses on the challenges encountered in building Internet and web systems: scalability, interoperability (of data and code), security and fault tolerance, consistency models, and location of resources, services, and data. We will examine how XML standards enable information exchange; how web services support cross-platform interoperability (and what their limitations are); how to build high-performance application servers; how 'cloud computing' services work; how to perform Akamai-like content distribution; and how to provide transaction support in distributed environments. (Penn)

    CIS 5570: Programming for the Web (1) sys

    This course will focus on web programming. The first half will focus on the basics of the internet and the Web, HTML and CSS, and basic and advanced Ruby. The second half will focus on Rails. Teams (of size 2-3) will build a web application in the second half of the semester as the class project. Through Rails, we'll ex;ore the 'culture' of web programming such as agile methodology, testing, key aspects of software engineering, using web services and APIs, and deploying to the cloud. (Penn)

    CIS 5650: GPU Programming and Architecture (1) sys

    This course examines the architecture and capabilities of modern GPUs. The graphics processing unit (GPU) is orders of magnitude faster for computation than traditional CPU, and with the power of general purpose programming, GPUs can be used for a diverse set of applications far removed from their traditional graphics usage. In this course, students will learn to program and optimize GPUs for computationally intensive algorithms. Topics covered include architectural aspects of modern GPUs, with a special focus on massively parallel programming, writing programs using CUDA, and using the GPU for graphics and general purpose applications in the area of geometry modeling, physical simulation, scientific computing and games. Students are expected to have a basic understanding of computer architecture and graphics, and should be proficient in C/C++. This course is appropriate as an upper-level undergraduate CIS elective. (Penn)

    CIS 5710: Computer Organization and Design (1) sys

    This is the second computer organization course and focuses on computer hardware design. Topics covered are: (1) basic digital system design including finite state machines, (2) instruction set design and simple RISC assembly programming, (3) quantitative evaluation of computer performance, (4) circuits for integer and floating-point arithmatic, (5) datapath and control, (6) micro-programming, (7) pipeling, (8) storage hierarchy and virtual memory, (9) input/output, (10) different forms of parallelism including instruction level parallelism, data-level parallelism using both vectors and message-passing multi-processors, and thread-level parallelism using shared memory multiprocessors. Basic cache coherence and synchronization. (Penn)

    CSCI 350: Introduction to Operating Systems (4) sys

    Basic issues in concurrency, deadlock control, synchronization scheduling, memory management, protection and access control, inter-process communication, and structured design. Laboratory experiences with Unix-like operating system. (USC)

    CSCI 353: Introduction to Internetworking (4) sys

    Global Internet: design principles, layering, protocol design/analysis. Networked applications, Internet structure/architecture, Protocols for transport/congestion control, network layer/routing, link layer/MAC. Network security. (USC)

    CSCI 356: Introduction to Computer Systems (4) sys

    Computer organization; entity abstraction and representation; program execution; code optimization; memory usage; exception handling; processing control; computer performance; hands-on work done in C and assembly. (USC)

    ITP 380: Video Game Programming (4) sys

    Underlying concepts and principles required for programming video games (topics include vectors, transformations, 3-D math, geometric primitives, matrices). (USC)

    ITP 382: Mobile Game Development (4) sys

    Application of techniques used to develop games for mobile devices. Sprites, mobile input, mobile graphics and monetization. (USC)

    CSCI 402: Operating Systems (4) sys

    Concurrency, deadlock control, synchronization, process and thread scheduling, memory management, file systems, security and access control, communication and networking, distributed file systems, data management. (USC)

    CSCI 423: Native Console Multiplayer Game Development (4) sys

    Implementation of AAA style multiplayer game running on consoles and DX11. Console development in native C++, console SDKs, engine components, gameplay, networking, data prediction/replication. (USC)

    ITP 438: Advanced Gameplay Programming (4) sys

    Advanced gameplay programming techniques for both single player and networked multiplayer games using an industry-standard game engine. (USC)

    ITP 485: Programming Game Engines (4) sys

    Techniques for building the core components of a game engine; 2-D/3-D graphics, collision detection, artificial intelligence algorithms, shading, programming input devices. (USC)

    CTIN 492L: Experimental Game Topics (4) sys

    Development of a game around a custom-made physical interface; various technologies and techniques involved in a software/hardware integration; peripheral design. (USC)

    CMPU 224: Computer Organization (1) sys

    Examines the hierarchical structure of computing systems, from digital logic and microprogramming through machine and assembly languages. Topics include the structure and workings of the central processor, instruction execution, memory and register organization, addressing schemes, input and output channels, and control sequencing. The course includes a weekly hardware/software laboratory where digital logic is explored and assembly language programming projects are implemented. (Vassar)

    CMPU 334: Operating Systems (1) sys

    Deals with the theory and implementation of the software that governs the management of system resources. (Vassar)

    CMPU 375: Computer Networks (1) sys

    Computer networks, in the form of the Internet, have revolutionized society in the last 3 decades. This course provides an introduction to the design and operation of the Internet and computer networks in general. Topics include layered communication protocols, routing, transport, naming, security and mobility. Knowledge is consolidated through projects involving the creation of network applications. (Vassar)

    CMPU 377: Parallel Programming (1) sys

    An introduction to parallel computing, with coverage of parallel architectures, programming models, and techniques. Topics include SIMD and MIMD models, shared-memory and message-passing styles of computation, synchronization, deadlock, and parallel language design. Students are exposed to common techniques for solving problems in sorting, searching, numerical methods, and graph theory, and gain practical experience through programming assignments run on a parallel processing system. (Vassar)

    CSE 204A: Web Development (3) sys

    This course explores elementary principles for designing, creating, and publishing effective websites and web application front-ends. Topics include page layout concepts, design principles, HTML, CSS, JavaScript, front-end frameworks like Angular and React, and other development tools. Students apply the topics by creating a series of websites that are judged based on their design and implementation. (Washington U.)

    CSE 222S: Internet of Things (3) sys

    With the advent of the Internet of Things, we can address, control, and interconnect formerly isolated objects to create new and interesting applications. In this course we study fundamental technologies behind Internet-of-Things devices, and Appcessories, which include smart watches, health monitors, toys, and appliances. (Washington U.)

    CSE 231S: Introduction to Parallel and Concurrent Programming (3) sys

    This course explores concepts, techniques, and design approaches for parallel and concurrent programming. We study how to write programs that make use of multiple processors for responsiveness and that share resources reliably and fairly. Parallel programming concepts include task-level, functional, and loop-level parallelism. Concurrent programming concepts include threads, synchronization, and locks. We cover how to adapt algorithms to achieve determinism and avoid data races and deadlock. Concepts and skills are acquired through the design and implementation of software projects. (Washington U.)

    CSE 260M: Introduction to Digital Logic and Computer Design (3) sys

    Introduction to design methods for digital logic and fundamentals of computer architecture. Boolean algebra and logic minimization techniques; sources of delay in combinational circuits and effect on circuit performance; survey of common combinational circuit components; sequential circuit design and analysis; timing analysis of sequential circuits; use of computer-aided design tools for digital logic design (schematic capture, hardware description languages, simulation); design of simple processors and memory subsystems; program execution in simple processors; basic techniques for enhancing processor performance; configurable logic devices. (Washington U.)

    CSE 314A: Data Manipulation and Management (3) sys

    As the base of data science, data needs to be acquired, integrated and preprocessed. This important step in the data science workflow ensures both quantity and quality of data and improves the effectiveness of the following steps of data processing. Students will gain an understanding of concepts and approaches of data acquisition and governance including data shaping, information extraction, information integration, data reduction and compression, data transformation as well as data cleaning. The course will further highlight the ethical responsibility of protecting the integrity of data and proper use of data. (Washington U.)

    CSE 330S: Rapid Prototype Development and Creative Programming (3) sys

    This course uses web development as a vehicle for developing skills in rapid prototyping. Students acquire the skills to build a Linux web server in Apache, to write a website from scratch in PHP, to run an SQL database, to perform scripting in Python, to employ various web frameworks, and to develop modern web applications in client-side and server-side JavaScript. The course culminates with a creative project in which students are able to synthesize the course material into a project of their own interest. The course implements an interactive studio format: after the formal presentation of a topic, students develop a related project under the supervision of the instructor. (Washington U.)

    CSE 361S: Introduction to Systems Software (3) sys

    This course is an introduction to the hardware and software foundations of computer processing systems. The course provides a programmer's perspective of how computer systems execute programs and store information. The course material aims to enable students to become more effective programmers, especially when dealing with issues of performance, portability and robustness. It also serves as a foundation for other system courses (e.g., those involving compilers, networks, and operating systems), where a deeper understanding of systems-level issues is required. Topics covered include machine-level code and its generation by optimizing compilers, performance evaluation and optimization, computer arithmetic, memory organization and management, and supporting concurrent computation. (Washington U.)

    CSE 362M: Computer Architecture (3) sys

    This course explores the interaction and design philosophy of hardware and software for digital computer systems. Topics include: processor architecture, instruction set architecture, Assembly Language, memory hierarchy design, I/O considerations, and a comparison of computer architectures. (Washington U.)

    CSE 365S: Elements of Computing Systems (3) sys

    All computers are made up of 0s and 1s. However, the conceptual gap between the 0s and 1s and the day-to-day operation of modern computers is enormously wide. This fast-paced course aims to bridge the divide by starting with simple logic gates and building up the levels of abstraction until one can create games like Tetris. There is no specific programming language requirement, but some experience with programming is needed. (Washington U.)

    CSE 422S: Operating Systems Organization (3) sys

    This course involves a hands-on exploration of core OS abstractions, mechanisms and policies in the context of the Linux kernel. Readings, lecture material, studio exercises, and lab assignments are closely integrated in an active-learning environment in which students gain experience and proficiency writing OS code, as well as tracing and evaluating OS operations via user-level programs and kernel-level monitoring tools. Topics include: system calls, interrupt handling, kernel modules, concurrency and synchronization, proportional and priority-based scheduling of processes and threads, I/O facilities, memory management, virtual memory, device management, and file system organization. (Washington U.)

    CSE 427S: Cloud Computing with Big Data Applications (3) sys

    This course provides an overview of the tools necessary to harness big data on the cloud for real-world analytic applications. Each lecture will cover an important cloud computing concept or framework and will be accompanied by a lab. There will be an emphasis on hands-on experience through using each of the tools taught in this course in a small project. (Washington U.)

    CSE 433S: Introduction to Computer Security (3) sys

    Secure computing requires the secure design, implementation, and use of systems and algorithms across many areas of computer science. Fundamentals of secure computing such as trust models and cryptography will lay the groundwork for studying key topics in the security of systems, networking, web design, machine learning algorithms, mobile applications, and physical devices. (Washington U.)

    CSE 434S: Reverse Engineering and Malware Analysis (3) sys

    This course will focus on reverse engineering and malware analysis techniques. Reverse engineering -- the process of deconstructing an object to reveal its design and architecture -- is an essential skill in the information security community. Although hackers often use reverse engineering tools to discover and exploit vulnerabilities, security analysts and researchers must use reverse engineering techniques to find what a specific malware does, how it does it, and how it got into the system. (Washington U.)

    CSE 435S: Database Management Systems (3) sys

    A study of data models and the database management systems that support these data models. The design theory for databases is developed and various tools are utilized to apply the theory. General query languages are studied and techniques for query optimization are investigated. Integrity and security requirements are studied in the context of concurrent operations on a database, where the database may be distributed over one or more locations. The unique requirements for engineering design databases, image databases, and long transaction systems are analyzed. (Washington U.)

    CSE 438S: Mobile Application Development (3) sys

    Learn how to create iOS apps in the Swift programming language. This course covers a variety of topics in the development of modern mobile applications, with a focus on hands-on projects. Students will create multiple fully-functional apps from scratch. The course emphasizes object-oriented design patterns and real-world development techniques. Time is provided at the end of the course for students to work on a project of their own interest. (Washington U.)

    CSE 439S: Mobile Application Development II (3) sys

    In this course, students will work in groups to design, develop, test, publish, and market an iOS mobile application. Throughout the semester, students will operate in different roles on a team, serving as lead developer, tester, and project manager. Topics include how to publish a mobile application on an app store, APIs and tools for testing and debugging, and popular cloud-based SDKs used by developers. This course requires completion of the iOS version of CSE 438 Mobile Application Development or the appropriate background knowledge of the iOS platform. (Washington U.)

    CSE 462M: Computer Systems Design (3) sys

    Introduction to modern design practices, including FPGA and PCB design methodologies. Student teams use Xilinx Vivado for HDL-based FPGA design and simulation; they also perform schematic capture, PCB layout, fabrication, and testing of the hardware portion of a selected computation system. (Washington U.)

    CSE 463M: Digital Integrated Circuit Design and Architecture (3) sys

    This is a project-oriented course on digital VLSI design. The course material focuses on bottom-up design of digital integrated circuits, starting from CMOS transistors, CMOS inverters, combinational circuits and sequential logic designs. (Washington U.)

    CSE 465M: Digital Systems Laboratory (3) sys

    Hardware/software co-design; processor interfacing; procedures for reliable digital design, both combinational and sequential; understanding manufacturers' specifications; use of test equipment. (Washington U.)

    CSE 467S: Embedded Computing Systems (3) sys

    This course introduces the issues, challenges, and methods for designing embedded computing systems -- systems designed to serve a particular application and which incorporate the use of digital processing devices. Examples of embedded systems include PDAs, cellular phones, appliances, game consoles, automobiles, and iPods. Emphasis is given to aspects of design that are distinct to embedded systems. The course examines hardware, software, and system-level design. Hardware topics include microcontrollers, digital signal processors, memory hierarchy, and I/O. Software issues include languages, run-time environments, and program analysis. System-level topics include real-time operating systems, scheduling, power management, and wireless sensor networks. Students will perform a course project on a real wireless sensor network testbed. (Washington U.)

    CSE 469S: Security of the Internet of Things and Embedded System Security (3) sys

    This course presents a deep dive into the emerging world of the 'internet of things' from a cybersecurity perspective. With billions of internet-enabled devices projected to impact every nook and cranny of modern existence, the concomitant security challenge portends to become dazzlingly complex. Students will learn the fundamentals of internet of things architecture and operations from a layered perspective and focus on identifying, assessing, and mitigating the threats and vulnerabilities therein. Through a blend of lecture and hands-on studios, students will gain proficiency in the range of approaches, methods, and techniques required to address embedded systems security and secure the internet of things using actual devices from both hardware and software perspectives and across a range of applications. (Washington U.)

    CSE 473S: Introduction to Computer Networks (3) sys

    A broad overview of computer networking. Topics include history, protocols, Hyper Text Transfer Protocol (HTTP), File Transfer Protocol (FTP), Simple Mail Transfer Protocol (SMTP), Domain Name System (DNS), peer-to-peer (P2P), transport layer design issues, transport layer protocols, Transmission Control Protocol (TCP), User Datagram Protocol (UDP), TCP congestion control, network layer, Internet Protocol version 4 (IPv4), Internet Control Message Protocol (ICMP), Internet Protocol version 6 (IPv6), routing algorithms, routing protocols, Open Shortest Path First (OSPF), Routing Information Protocol (RIP), Border Gateway Protocol (BGP), datalink layer and local area networks carrier sense multiple access with collision detection (CSMA/CD), Ethernet, virtual local area networks (VLANs), Point-to-Point Protocol (PPP), Multi-Protocol Label Switching, wireless and mobile networks, multimedia networking, security in computer networks, cryptography, and network management. (Washington U.)

    CS 204: Intro to Web Development (1) sys

    This course introduces modern web development using HTML, CSS, and JavaScript. JavaScript is explored in detail, including scoping, closures, objects, classes, object-oriented programming, and modules. The jQuery library is also introduced, and the course covers event handling and Ajax interactions. Students will build web pages that manage data structures using menus and forms, and that save/restore that data from local storage resulting in a persistent, dynamic web application. Designed web pages will be modern, responsive, and accessible. The course also covers Bootstrap and the jQuery UI (User Interface) library. (Wellesley)

    CS 240: Foundations of Computer Systems (11.25) sys

    This course examines how computers run programs, introducing key software and hardware abstractions and implementations between programming languages and transistors. The course traces representation and translation of data and programs through three broad topics in computer systems: computer hardware implementation, including digital logic, computer arithmetic, and machine organization; the hardware-software interface, including instruction set architecture, assembly code, and the C programming language; and abstractions for practical systems, including the physical memory hierarchy, the operating system process model, virtual memory, and memory management. Students complete extensive hands-on projects in hardware and software systems. Students are required to attend one three-hour laboratory weekly. (Wellesley)

    CS 242: Computer Networks (1) sys

    A systems-oriented approach to data networks, including a theoretical discussion of common networking problems and an examination of modern networks and protocols. Topics include point-to-point links, packet switching, Internet protocols, end-to-end protocols, congestion control, and security. Projects may include client-server applications and network measurement tools. (Wellesley)

    CS 304: Databases with Web Interfaces (1) sys

    CS 304 is a course in full-stack web development. (Wellesley)

    CS 315: Data Science for the Web (1) sys

    In the past decade, we have experienced the rise of socio-technical systems used by millions of people: Google, Facebook, Twitter, Wikipedia, etc. Such systems are on the one hand computational systems, using sophisticated infrastructure and algorithms to organize huge amounts of data and text, but on the other hand social systems, because they cannot succeed without human participation. How are such systems built? What algorithms underlie their foundations? How does human behavior influence their operation and vice-versa? In this class, we will delve into answering these questions by means of: a) reading current research papers on the inner-workings of such systems; b) implementing algorithms that accomplish tasks such as web crawling, web search, random walks, learning to rank, text classification, topic modeling; and c) critically thinking about the unexamined embrace of techno-solutionism using a humanistic lens. (Wellesley)

    CS 317: Mobile App Development (1) sys

    Mobile devices have become more popular than desktops or laptops for communicating with others, accessing information, and performing computation. This course covers the principles and practice of developing applications for mobile devices, with an emphasis on features that distinguish them from desktop/laptop applications and web applications. Topics include: the functionality of modern smartphones and tablets, including device sensors, actuators, and communication; an iterative design process for apps that people find both useful and usable; designing and implementing mobile app interfaces and behaviors; and tools for developing software in teams. In this hands-on and programming-intensive course, groups will build web apps and mobile apps using a process that combines aspects of Human Computer Interaction and software engineering. This course begins by using the React JS framework to build interactive web apps out of modular components. It then transitions to React Native, a cross-platform component-based mobile app development environment for creating mobile apps that run on both iOS and Android devices. The course also explores how apps can leverage cloud databases to store and share information. (Wellesley)

    CS 340: Modeling for Computer Systems (1) sys

    This course focuses on modeling and specifying computer systems. Students will learn how to reason about the properties and expected behavior of modern software. Topics include designing specifications, property-based testing, model checking, and satisfiability solvers. We will use real-world case studies to motivate the analysis of reliable computer systems. By the end of the course, students will be able to (1) design specifications for the expected behavior of a system, (2) model system behavior using state-of-the-art tools with automated formal methods, and (3) identify and prevent software bugs. While prior experience with algorithm design and analysis is expected, the course will cover any necessary background in systems programming and formal methods. (Wellesley)

    CS 341: Operating Systems (1) sys

    This course is designed to provide a solid foundation in the design and implementation of key concepts in existing operating systems. These concepts include process management, scheduling, multitasking, synchronization, deadlocks, memory management, file systems, and I/O operations. Throughout the course, the mechanism design aspects of these concepts will be discussed and assessed from the point of view of a programmer. Moreover, more modern operating systems will be explored, such as virtual operating systems. (Wellesley)

    CS 342: Computer Security (1) sys

    An introduction to computer security and privacy. Topics will include privacy, threat modeling, software security, web tracking, web security, usable security, the design of secure and privacy preserving tools, authentication, anonymity, practical and theoretical aspects of cryptography, secure protocols, network security, social engineering, the relationship of the law to security and privacy, and the ethics of hacking. This course will emphasize hands-on experience with technical topics and the ability to communicate security and privacy topics to lay and expert audiences. Assignments will include technical exercises exploring security exploits and tools in a Linux environment; problem sets including exercises and proofs related to theoretical aspects of computer security; and opportunities to research, write, present, and lead discussions on security- and privacy-related topics. Students are required to attend an additional 70-minute discussion section each week. (Wellesley)

    CS 343: Distributed Computing (1) sys

    What is the “cloud”? What is a distributed system? This course is for students interested in understanding the fundamental concepts and algorithms underlying existing distributed systems. By the end of this course, students will have the basic knowledge needed to work with and build distributed systems, such as peer-to-peer systems and cloud computing systems. Topics include MapReduce, Spark, communication models, synchronization, distributed file systems, coordination algorithms, consensus algorithms, fault-tolerance, and security. (Wellesley)

    COMP 331: Computer Structure and Organization (1) sys

    The purpose of the course is to introduce and discuss the structure and operation of digital computers. Topics will include the logic of circuits, microarchitectures, microprogramming, conventional machine architectures, and an introduction to software/hardware interface issues. Assembly language programming will be used to demonstrate some of the basic concepts. (Wesleyan)

    COMP 332: Computer Networks (1) sys

    This course will provide an introduction to the fundamentals of computer networks. Computer networks have become embedded in our everyday lives, from the Internet to cellular phones to cloud networking, enabling applications such as email, texting, web browsing, on-demand video, video conferencing, peer-to-peer file sharing, social networking, cloud computing, and more. This course will delve into the infrastructure and protocols that have allowed computer networks to achieve their current ubiquity. While the primary focus of the course will be on the Internet's architecture, protocols, and applications, we will also touch on other types of computer networks. Programming assignments will be done using Python; prior knowledge of Python is not required. (Wesleyan)

    CSCI 237: Computer Organization (1) sys

    This course studies the basic instruction set architecture and organization of a modern computer. It provides a programmer's view of how computer systems execute programs, store information, and communicate. Over the semester the student learns the fundamentals of translating higher level languages into assembly language, and the interpretation of machine languages by hardware. At the same time, a model of computer hardware organization is developed from the gate level upward. (Williams)

    CSCI 331: Introduction to Computer Security (1) sys

    This class explores common vulnerabilities in computer systems, how attackers exploit them, and how systems engineers design defenses to mitigate them. The goal is to be able to recognize potential vulnerabilities in one's own software and to practice defensive design. Hands-on experience writing assembly language and C code to inspect and modify the low-level operation of running programs is emphasized. Finally, regular reading and writing assignments round out the course to help students understand the cultural and historical background of the computer security 'arms race.' (Williams)

    CSCI 333: Storage Systems (1) sys

    This course will examine topics in the design, implementation, and evaluation of storage systems. Topics include the memory hierarchy; ways that data is organized (both logically and physically); storage hardware and its influence on storage software designs; data structures; performance models; and system measurement/evaluation. Readings will be taken from recent technical literature, and an emphasis will be placed on identifying and evaluating design trade-offs. (Williams)

    CSCI 336: Computer Networks (1) sys

    This course explores the design and implementation of computer networks. Topics include wired and wireless networks; techniques for efficient and reliable encoding and transmission of data; addressing schemes and routing mechanisms; resource allocation for bandwidth sharing; and security issues. An important unifying themes is the distributed nature of all network problems. We will examine the ways in which these issues are addressed by current protocols such as TCP/IP and 802.11 WIFI. (Williams)

    CSCI 337: Digital Design and Modern Architecture (1) sys

    This tutorial course considers topics in the low-level design of modern architectures. Course meetings will review problems of designing effective architectures including instruction-level parallelism, branch-prediction, caching strategies, and advanced ALU design. Readings will be taken from recent technical literature. Labs will focus on the development of custom CMOS circuits to implement projects from gates to bit-sliced ALUs. Final group projects will develop custom logic demonstrating concepts learned in course meetings. (Williams)

    CSCI 338: Parallel Processing (1) sys

    This course explores different parallel programming paradigms used for writing applications on today's parallel computer systems. The course will introduce concurrency (i.e. multiple simultaneous computations) and the synchronization primitives that allow for the creation of correct concurrent applications. It will examine how a variety of systems organize parallel processing resources and enable users to write parallel programs for these systems. Covered programming paradigms will include multiprogramming with processes, message passing, threading in shared memory multiprocessors, vector processing, graphics processor programming, transactions, MapReduce, and other forms of programming for the cloud. Class discussion is based on assigned readings. Assignments provide students the opportunity to develop proficiency in writing software using different parallel programming paradigms. (Williams)

    CSCI 339: Distributed Systems (1) sys

    This course studies the key design principles of distributed systems, which are collections of independent networked computers that function as single coherent systems. Covered topics include communication protocols, processes and threads, naming, synchronization, consistency and replication, fault tolerance, and security. Students also examine some specific real-world distributed systems case studies, including Google and Amazon. Class discussion is based on readings from the textbook and research papers. The goals of this course are to understand how large-scale computational systems are built, and to provide students with the tools necessary to evaluate new technologies after the course ends. (Williams)

    CSCI 432: Operating Systems (1) sys

    This course explores the design and implementation of computer operating systems. Topics include historical aspects of operating systems development, systems programming, process scheduling, synchronization of concurrent processes, virtual machines, memory management and virtual memory, I/O and file systems, system security, os/architecture interaction, and distributed operating systems. (Williams)

    CPSC 323: Introduction to Systems Programming and Computer Organization (1) sys

    Machine architecture and computer organization, systems programming in a high-level language, issues in operating systems, software engineering, prototyping in scripting languages. After CPSC 223. (Yale)

    CPSC 334: Creative Embedded Systems (1) sys

    Ubiquitous computing is creating new canvases and opportunities for creative ideas. This class explores the use of microprocessors, distributed sensor networks, IoT, and intermedia systems for the purposes of creative expression. (Yale)

    CPSC 338: Digital Systems (1) sys

    Development of engineering skills through the design and analysis of digital logic components and circuits. Introduction to gate-level circuit design, beginning with single gates and building up to complex systems. (Yale)

    CPSC 362: Decisions and Computations across Networks (1) sys

    For a long time there has been interest in distributed computation and decision making problems of all types. Among these are consensus and flocking problems, the multi-agent rendezvous problem, distributed averaging, gossiping, localization of sensors in a multi-sensor network, distributed algorithms for solving linear equations, distributed management of multi-agent formations, opinion dynamics, and distributed state estimation. (Yale)

    CPSC 364: Introduction to Blockchains, Cryptocurrencies, Smart Contracts, and Decentralized Applications (1) sys

    This course offers an introduction to blockchain technology and its practical applications. The objective is to provide students with a comprehensive overview of the fundamental concepts and hands-on experience in building on actual blockchains. (Yale)

    CPSC 413: Computer System Security (1) sys

    Overview of the principles and practice behind analyzing, designing, and implementing secure computer systems. Covers problems that have continued to plague computer systems for years as well as recent events and research in this rapidly evolving field of computer science. (Yale)

    CPSC 420: Computer Architecture (1) sys

    This course offers a treatment of computer architectures for high-performance and power/energy-efficient computer systems. Topics include the foundations of general-purpose computing, including instruction set architectures, pipelines, superscalar and out-of-order execution, speculation, support for precise exceptions, and simultaneous multi-threading. (Yale)

    CPSC 426: Building Distributed Systems (1) sys

    Ubiquitous services such as Google, Facebook, and Amazon run on the back of massive distributed systems. This course covers the fundamental principles, abstractions, and mechanisms that inform the design of such systems, as well as the practical details of real-world implementations. (Yale)

    CPSC 427: C++ Programming for Stability, Security, and Speed (1) sys

    Computer programming involves both abstraction and practice. Lower-level programming courses focus on learning how to correctly implement algorithms for carrying out a task. (Yale)

    CPSC 429: Principles of Computer System Design (1) sys

    Humans are stupid; computers are limited. Yet a collaboration of humans and computers has led to ever more powerful and complex computer systems. (Yale)

    CPSC 437: Database Systems (1) sys

    Introduction to database systems. Data modeling. The relational model and the SQL query language. Relational database design, integrity constraints, functional dependencies, and normal forms. (Yale)