Prerequisite(s): prior programming experience in any language recommended.
This course covers abstraction and design in computation. Topics include functional and object-oriented styles of programming, software engineering in the small, and models of computation. The goal is to understand how to design large programs to make them readable, maintainable, efficient, and elegant. Exercises are conducted in OCaml.. (4 credits)
As an introduction to the fundamental structure and services of the Unix and Linux operating systems, this course combines theory with programming at the system call level. Topics include files and directories, device control, terminal handling, processes and threads, signals, pipes, and sockets. Examples and exercises include directory management utilities, a shell, and a web server. (4 credits)
This course covers the fundamentals of computer systems programming, machine organization, and performance tuning. It provides a solid background in systems programming and a deep understanding of low-level machine organization and design. The course centers on C/C++ programming, with some assembly language. Topics include (but may not be limited to) program optimization, memory hierarchy, caching, virtual memory, dynamic memory management, concurrency, threads, and networking.
This is an applications course highlighting the use of computers in solving scientific problems. Students learn the fundamentals of developing scientific software systems including abstract thinking, algorithmic development, and assessment of computational approaches. They use a series of open source tools and libraries for data analysis, modeling, and visualization of real scientific problems.
This course approaches object-oriented software design from three perspectives: the software engineering principles that enable development of quality software, the modeling of software components using the Unified Modeling Language (UML), and the application of design patterns as a means of reusing design models that are accepted best practices. These patterns include both the original software patterns as well as more recent modularization patterns for software construction. There is at least one significant modeling exercise and a set of programming assignments that require the application of design principles and good programming technique. Students are expected to write a detailed description of the design for each of their programs, incorporating UML models as appropriate. Students implement their programs in the Java programming language. In addition, there is at least one significant assignment that requires designing and documenting a software subsystem without prior implementation. (4 credits)
The majority of modern programming languages assume some degree of runtime support to allow for a simplified abstraction, which leads in turn to increased developer productivity and a more robust end product. For example, automatic memory management removes the need for developers to manually track and release memory, eliminating entire classes of bugs and simplifying the interfaces between components. This course examines the technologies that make up a modern runtime environment, such as interpretation, JIT and selective compilation, memory management and garbage collection, and native interface design. Students develop components of a virtual machine, and learn about the design trade-offs required to build a high performance runtime environment. (4 credits)
Design and analysis of efficient algorithms and data structures. Algorithm design methods, graph algorithms, approximation algorithms, and randomized algorithms are covered.
This course is an introduction to the theory, design, and implementation of programming languages. Topics covered in this course include formal semantics of programming languages (operational, axiomatic, denotational, and translational), type systems, higher-order functions and lambda calculus, lazy evaluations, continuations, dynamic types, monads, objects, modules, concurrency, and communication.