Computer Science courses I've taken

CS 130 Developing Programming Principles

• This course teaches fundamental concepts of object-oriented computer programming.

• Student labs are equipped with a Java development environment running under Windows 95. Students may use a Java development environment on their personal computers for course work and assignments.

• Using, Extending, Writing Classes. UML. Instance variables. File I/O. Hashtable

• Arrays

• Object-Oriented Design

• Graphical User Interfaces

• Polymorphism

CS 134 Principles of Computer Science

• This course introduces students to the three basic paradigms of computer science: design (from engineering), experiment (from science), and proof (from mathematics). These are introduced through study of some elementary data structures and algorithms, together with the programming mechanisms and methodologies required to implement and use them.

• Algorithm Design, Correctness and Efficiency

• Recursion. Binary search. Recursive sorting algorithms.

• Abstract Data Types. Iterators. Implementations of sets, tables, stacks, queues, and trees. Implementation of
  nested procedure calls, depth-first and breadth-first traversals, and discrete event simulation. Binary search trees.

• Discipline of Computer Science. Social impacts of computer technology. Responsibility and liability.

CS 241 Foundations of Sequential Programs

• To describe the relationship between high-level programming languages and the computer architecture that underlies their implementation.

• Scanning. Compiler architecture. Syntax vs. semantics. Formal languages. Regular languages, regular expressions and finite state machines.

• Debugging in the Small 

• Parsing. Context-free grammars, derivations, derivation trees, ambiguous grammars. Introduction to top-down and bottom-up parsing, LL(1) and LR(1) grammars.

• Semantic Analysis. Simple code. Constructing parse trees.

• Basic Machine Architecture. Functional components of a computer: memory, control unit, arithmetic/logic unit, input/output devices. Data representation. Machine language: operation codes, addressing modes, indexing, base registers, register designation.

• Assemblers, Linkers and Loaders: Mnemonic op-codes, pseudo-ops, symbolic constants and addresses, literals. Assembler algorithm, linker and loader algorithms.

• Scheme: Control structures, data structures, and naming structure. Implementation on a von Neumann machine. Procedural vs. declarative languages.

CS 251 Computer Organization and Design

• To introduce students to theoretical and practical concepts relevant to designing digital systems. Starting from basic gate-level logic, the students advance to simple CPU architectures.

• Number Systems and Information Representation: Binary, octal and hexadecimal number systems. One's complement, two's complement, binary addition and subtraction. Decimal and alphanumeric codes.

• Boolean Algebra and Digital Circuits: Binary logic and gates. Standard forms, K-maps, algebraic manipulation. Symbolic representation of logic gates. Truth tables. Canonical expressions and networks.

• Combinational Logic Design: Analysis and design procedures. Half adder, full adder, multiplexer/
  demultiplexer, encoder/decoder design.

• Sequential Logic Design: Latches, flip-flops, analysis and synthesis procedures, state diagrams, transition tables, excitation tables.

• Registers and Counters: Analysis and design of registers and shift registers, up/down counters.

• Memory and Programmable Logic: RAM, ROM, PLAs, PALs, FPGAs.

• Register Transfer: Register and bus transfer, ALU, microoperations.

• Control Logic Design: Microprogrammed control, control of CPU, some examples, ASM design.

• CPU Architecture: ALUs, control logic, instruction formats, CISC and RISC, pipelining.

CS 240 Data Structures and Data Management

• To introduce students to widely used and effective methods of data organization. The course includes not only data structures and algorithms, but also the analysis of their performance and their use in database systems. The course concludes with a brief introduction to database systems and memory management.

• Introduction to Data Structures: Abstract data type. Abstractions and representations of basic data types including trees and graphs.

• Operations on Sets Including Dictionaries: Programming language support for sets. Linear representations (unordered, sorted by value, sorted by frequency of access). Hashing techniques including linear probing, double hashing, and separate chaining. Search trees including binary search trees, balancing, and B-trees. Analysis of the efficiency of these techniques and their merits and deficiencies for use on secondary storage.

• Sorting and Priority Queues: Lower bounds for sorting. Algorithms for internal sorting including quicksort, mergesort, heapsort and radix sort. External sorting. Heaps and implementation of priority queues. Applications of priority queues.

• String Matching and Data Compression: Knuth-Morris-Pratt and Boyer-Moore algorithms. Tries. Huffman and Lempel-Ziv coding.

• Memory Management: Storage allocation. Garbage collection. Buddy system.

• Introduction to Database Systems: The notion of a relational database. SQL as a data manipulation language. The use of efficient data structures within database systems.

CS 246 Software Abstraction and Specification

• This course is intended to introduce students to systematic methods for designing, coding, testing, and documenting medium-sized computer programs. The principles will be taught in a practical setting.

• Software engineering. Working in groups.

• Introduction to C++

• Procedural Abstraction: Logic and specification. Pre/postconditions, assertions, invariants, defensive programming. Data abstraction. Black box testing.

• Advanced Object-oriented Programming: Inheritance and polymorphism. Multiple inheritance. Overloading of functions and operators. Basic object model. Constructors and destructors. Garbage collection. Memory management. Namespaces and packages. Higher-level abstractions. Generics. STL. Java collections.

• Programming in the Medium: Software design. Object-oriented design. Design patterns. Testing.

• Exceptions: Declaring, raising, and specifying exceptions. When to use exceptions.

• Event-Based Programming

CS 342 Control Structures

• An introduction to advanced control structures with an emphasis on concurrency and writing concurrent programs. Programming techniques and styles are examined to express complex forms of control flow, such as multi-level loop exit, data-structure iterators, exceptions, coroutines, and concurrency. Students will learn how to select appropriate control structures to solve complex programming problems.

• C++ Programming

• Advanced Control Flow: Multi-exit loops, multi-level exits, exceptions, iterators.

• Coroutines: Multiple stacks, context switching. Semi and full coroutines.

• Introduction to Concurrency: Starting multiple processes, synchronizing, and communication among processes. Ready queue, process states, interrupts.

• Mutual Exclusion: Software and hardware solutions for critical sections. Dekker and Peterson algorithms. Test and set.

• Semaphores: Binary and counting semaphores. Baton passing and split binary semaphores. Bounded buffer and readers/writer

• Deadlock: Deadlock definition, examining prevention, avoidance and recovery.

• High-Level Concurrency: Conditional critical regions, monitors, tasks. Internal and external scheduling of tasks. Rendezvous. Client/Server.

• Increasing Concurrency: Server: buffering, secretary, administrator, workers, courier. Client: sync/async communication, tickets, call-backs, futures.

• Other Concurrency Approaches: Threads/locks, threads/message-passing, Ada, Java.

• Interprocess Communication: Shared versus non-shared memory.Remote procedure call.

• Theory of Concurrency: Global invariants. Safety and liveness.

CS 360 Introduction to the Theory of Computing

• To give a basic introduction to the theoretical foundations of computer science.

• Finite Automata: Deterministic and non-deterministic finite automata and their equivalence. Equivalence with regular expressions. Closure properties. The pumping lemma and applications.

• Context-free Grammars: Definitions. Parse trees. The pumping lemma for CFLs and applications. Normal forms. General parsing. Sketch of equivalence with pushdown automata.

• Turing Machines: Designing simple TMs. Variations in the basic model (multi-tape, multi-head, non-determinism). Church-Turing thesis and evidence to support it through the study of other models.

• Undecidability: The undecidability of the halting problem. Reductions to other problems. Reduction in general.

CS 370 Numerical Computation

• In this course, simple but realistic examples of scientific computations are used to introduce basic algorithms and modern hardware and software environments for numerical computing.

• Interpolation: Lagrange interpolation, spline interpolation, spline representations, mono- and bi-variate data, roots of equations. Applications: Representing hand-writing.

• Fourier: Approximation, interpolation by Fourier series, fast Fourier transform. Application: Time series analysis, image processing, JPEG.

• Linear Systmes: Solution of linear systems, least squares fitting, overdetermined systems, conditioning, sparse systems. Application: Analysis of data, i.e. running times for Gaussian elimination and measurement of floating point processor speed.

• ODE: Solving differential equations. Error analysis, i.e. distinction between round-off and discretization errors, stability of computations. Application: Satellite trajectories, pursuit dynamics

Home 

Page updated on: 19-Feb-2002 03:40 PM