[PORTALNAME]

Course Criteria

Add courses to your favorites to save, share, and find your best transfer school.

  • CMSC 22100 /32100: Programming Languages

    3.00 Credits
    University of Chicago

    PQ: CMSC 15300. Programming language design aims at the closest possible correspondence between the structures of a program and the task it performs. This course studies some of the structural concepts affecting programming languages: iterative and recursive control flow, data types and type checking, procedural versus functional programming, modularity and encapsulation, fundamentals of interpreting and compiling, and formal descriptions of syntax and semantics. Students write short programs in radically different languages to illuminate the variety of possible designs. Autumn.
    ShareCMSC 22100 /32100 - Programming Languages
    Favorite

  • CMSC 22200 /32200: Computer Architecture

    3.00 Credits
    University of Chicago

    PQ: CMSC 15400. This course is a survey of contemporary computer organization covering CPU design, instruction sets, control, processors, busses, ALU, memory, pipelined computers, multiprocessors, networking, and case studies. We focus on the techniques of quantitative analysis and evaluation of modern computing systems, such as the selection of appropriate benchmarks to reveal and compare the performance of alternative design choices in system design. We emphasize major component subsystems of high-performance computers: pipelining, instruction-level parallelism, memory hierarchies, input/output, and network-oriented interconnections. Autumn.
    ShareCMSC 22200 /32200 - Computer Architecture
    Favorite

  • CMSC 22300: Functional Programming

    3.00 Credits
    University of Chicago

    PQ: CMSC 15300. This course presents the functional programming paradigm and related program design concepts and techniques for systematically developing and reasoning about programs. The Haskell programming language is used as the vehicle for illustrating functional programming; it is a pure, lazy functional language that represents the functional paradigm in its most undiluted form. By providing better support for modularity and abstraction, functional programming languages make it easier to produce correct and well-structured software. We look at a range of programming examples covering lists, trees, and symbolic and textual structures. D. MacQueen. Spring.
    ShareCMSC 22300 - Functional Programming
    Favorite

  • CMSC 22610: Implementation of Computer Languages I

    3.00 Credits
    University of Chicago

    PQ: CMSC 15300 and 15400 required; CMSC 22100 recommended. Prior experience with ML programming not required. This course covers principles and techniques for implementing computer languages (e.g., programming languages, query languages, specification languages, domain-specific languages). Topics include lexical analysis, parsing, tree representations of programs (both parse trees and abstract syntax trees), types and type checking, interpreters, abstract machines, and run-time systems. This is a project-based course involving the implementation of a small language using Standard ML. J. Reppy. Winter. Not offered 2009 C10; will be offered 201 0 -11.
    ShareCMSC 22610 - Implementation of Computer Languages I
    Favorite

  • CMSC 22620 /32620: Implementation of Computer Languages II

    3.00 Credits
    University of Chicago

    PQ: CMSC 22610 required; CMSC 22100 strongly recommended. This course is a continuation of CMSC 22610, covering compilers for general-purpose languages. Topics include compiler-immediate representations, continuation-passing style, runtime representations, code generation, code optimization, register allocation, instruction scheduling, and garbage collection. This is a project-based course in which students construct a complete, working compiler for a small language using Standard ML. Spring. Not offered 2009 C10; will be offered 201 0 -11.
    ShareCMSC 22620 /32620 - Implementation of Computer Languages II
    Favorite

  • CMSC 22630 /32630: Advanced Implementation of Computer Languages

    3.00 Credits
    University of Chicago

    PQ: CMSC 22100 and 22620, or equivalent. This course explores advanced topics in the implementation of high-level programming languages that vary each year (e.g., control-flow analysis algorithms, abstract interpretation, partial evaluation, advanced optimizations, runtime system representations, garbage collection algorithms, foreign-function interfaces). Students are expected to develop both a foundational and applied understanding of these topics. J. Reppy. Autumn. Not offered 2009 C10; will be offered 201 0 -11.
    ShareCMSC 22630 /32630 - Advanced Implementation of Computer Languages
    Favorite

  • CMSC 23000: Operating Systems

    3.00 Credits
    University of Chicago

    PQ: CMSC 15400. This course covers basic concepts of operating systems. Topics include the notion of a process, interprocess communication and synchronization, main memory allocation, segmentation, paging, linking and loading, scheduling, file systems, and security and privacy. Classes are taught on a Sun workstation using UNIX. Spring. Not offered 2009 C10; will be offered 201 0 -11.
    ShareCMSC 23000 - Operating Systems
    Favorite

  • CMSC 23300 /33300: Networks and Distributed Systems

    3.00 Credits
    University of Chicago

    PQ: CMSC 15400. This course focuses on the principles and techniques used in the development of networked and distributed software. Topics include programming with sockets; remote procedure calls (RPC); interprocess communication (IPC); distributed objects (i.e., CORBA, DCOM); and commonly used network protocols (e.g., TCP/IP, UDP, FTP, HTTP). In addition, data encoding, encryption, and compression algorithms are presented. This is a project-oriented course in which students are required to develop software in the UNIX programming environment. A. Rogers. Spring.
    ShareCMSC 23300 /33300 - Networks and Distributed Systems
    Favorite

  • CMSC 23340 /33340: Grid Computing

    3.00 Credits
    University of Chicago

    PQ: Substantial programming experience. The new Open Grid Services Architecture (OGSA) defines interfaces and protocols that promise to make it far easier to construct decentralized, dynamic, large-scale systems. We explore and evaluate this technology by using it to develop a range of scalable distributed services. We use the Globus Toolkit, an open source implementation of key OGSA standards, to design and build services. We then evaluate our implementations from the perspectives of performance and programmability. I. Foster. Winter. Not offered 2009 C10; will be offered 201 0 -11.
    ShareCMSC 23340 /33340 - Grid Computing
    Favorite

  • CMSC 23500: Introduction to Database Systems

    3.00 Credits
    University of Chicago

    PQ: CMSC 15300 and 15400. This course introduces database design and programming. Topics include entity-relationship and relational models, relational algebra, functional dependencies, and normal forms. We extensively cover SQL and take a brief look at data warehousing and data mining. This course is offered in alternate years. S. Salveter. Spring.
    ShareCMSC 23500 - Introduction to Database Systems
    Favorite
To find college, community college and university courses by keyword, enter some or all of the following, then select the Search button.
(Type the name of a College, University, Exam, or Corporation)
(For example: Accounting, Psychology)
(For example: ACCT 101, where Course Prefix is ACCT, and Course Number is 101)
(For example: Introduction To Accounting)
(For example: Sine waves, Hemingway, or Impressionism)
Distance:
of
(For example: Find all institutions within 5 miles of the selected Zip Code)