These are the course descriptions as they appear in the 1998-2000 UMBC Undergraduate Catalog. The current course descriptions are available here.
Last updated: 3/30/2000.
CMSC 100 Introduction to Computers and Programming. [3]
A one-semester introduction to computers and their uses. This course is intended for non-science majors. Topics include: computer programs; computer systems; personal computers and software packages; simulation; databases; artificial intelligence; computers in education and industry; and the effects of computers on society. Note: this course is not open to students who have passed CMSC 103. This course should not be taken by students planning to take CMSC 103 or CMSC 201.
CMSC 101 Introduction to Computer Science I for Non-Majors. [4]
An introduction to computer programming, problem solving and algorithm design using a high-level language such as C or Pascal. Programming concepts covered by this course include: structured programming techniques, assignment statements, input/output statements, control structures, repetition structures, procedures, functions, arrays, records, files, testing and documentation. Note: this course is not open to students intending to major in computer science. Prerequisite: MATH 150.
CMSC 102 Introduction to Computer Science II for Non-Majors. [3]
An extension of the concepts introduced in CMSC 101. This course introduces more advanced topics using a high-level language such as C or Pascal. Programming concepts covered by this course include: program design, discipline and style; debugging and testing of large programs; string processing; recursion; internal sorting and searching techniques; pointers and dynamic data structures including lists, stacks, queues and trees. Note: this course is not open to students intending to major in computer science. Prerequisites: CMSC 101, MATH 151 or MATH 155.
CMSC 103 Scientific Computing. [4]
An introduction to computers and programming. This course is intended for students who will major in scientific disciplines other than computer science. The course emphasizes scientific applications and uses the FORTRAN programming language. The elements of FORTRAN covered in this course include: assignment statements, input/output statements, control structures, repetition structures, subroutines, functions, arrays and files. This course also covers general programming concepts including: computer components, structured programming, algorithm development, problem solving, testing, debugging and documentation. Note: this course is not open to students intending to major in computer science. Prerequisite: MATH 151.
CMSC 104 Problem Solving and Computer Programming. [3]
This course is designed to prepare students for CMSC 201 by providing an introduction to computer programming which does not require prior programming experience. Students will be taught the basic use of a programming environment and the basic elements of the C programming language (including loops, control statements and arrays). This course also introduces general computer science concepts such as operating systems, computer organization, computer architecture, data representation and memory usage. Note: this course does not fulfill any of the computer science major requirements.
CMSC 106 Programming in C. [2]
An introduction to programming in C for students experienced in a high-level programming language. Topics include: elementary data structures, control structures and input/output functions in C; the use of the C preprocessor; user-defined types such as arrays, records and structures; system calls; and the use of a symbolic debugger. Students will be expected to complete significant programming projects using the C programming language. Prerequisite: Mastery of a high-level programming language other than C. Note: this course is not open to students who have previously taken a course in C programming. Credit will not be given for both CMSC 106 and CMSC 201.
CMSC 109 Programming Topics. [2]
An introduction to programming in a specific programming language, which may vary from semester to semester. Notes: this course is not open to students who have had programming experience using the specified language. This course may be repeated when the language is different. Prerequisite: CMSC 103 or CMSC 201.
CMSC 201 Computer Science I for Majors (MS). [4]
An introduction to computer science through problem solving and computer programming. Programming techniques covered by this course include modularity, abstraction, top-down design, specifications, documentation, debugging, and testing. Selected topics in computer science are introduced through programming projects in the C language running under a UNIX operating system. The core material for this course includes functions, recursion, arrays, strings, pointers, records, and files. Students are assumed to already know the basics of a modern high-level language such as C or Pascal (expressions, basic data types, arrays, and control structures). Students with no prior programming experience should take CMSC 104. This is the first course for students interested in pursuing further study in computer science. Note: credit will not be given for both CMSC 106 and CMSC 201 Prerequisite: MATH 150.
CMSC 202 Computer Science II for Majors (MS). [4]
This course continues the development of programming and problem-solving skills, focusing on recursion, pointers, data abstraction, and procedural abstraction. Topics include: introduction to asymptotic notation; data structures including lists, stacks, queues, hash tables and elementary binary search trees; sorting and searching; and an introduction to the C++ language and to object-oriented programming. Programming projects for this course will use the C and C++ programming languages. This is the second course for students interested in pursuing further study in computer science. Prerequisites: CMSC 201 and MATH 151.
CMSC 203 Discrete Structures. [3]
Discrete Structures introduces the fundamental tools, topics, and concepts of discrete mathematics needed to study computer science. This course emphasizes counting methods, proof techniques, and problem-solving strategies. Topics include Boolean algebra; set theory; symbolic logic; predicate calculus; number theory; the methods of direct, indirect and inductive proofs; bijective functions; equivalence relations; graphs; set partitions; combinatorics; modular arithmetic; summations; and recurrences. Prerequisite: CMSC 103 or CMSC 201 and MATH 151.
CMSC 211 Assembly Language Programming. [3]
An introduction to low-level programming in assembly language. Topics include: basic concepts in digital logic; machine representation of numbers and characters; digital arithmetic; addressing techniques; program segmentation and linkage; and assembler construction. Prerequisite: CMSC 202.
CMSC 291 Special Topics in Computer Science. [1-4]
This course may be repeated provided the topic varies.
CMSC 299 Independent Study in Computer Science. [1-4]
This course is offered on a pass/fail basis only.
CMSC 311 Introduction to Computer Organization. [3]
This course covers basic concepts of digital logic, including the following topics: Boolean algebra, logic gates, simplification of logical expressions, Karnaugh maps, combinational circuit design and analysis, half-adders, full-adders, n-bit-adders, decoders, multiplexers, arithmetic logic units, flip-flops, clocked circuit design and analysis, registers, counters, register transfer and computer operation, control unit, random-access memories, and read-only memory. Note: credit will not be given for both CMSC 311 and the equivalent CMPE course. Prerequisite: CMSC 211.
CMSC 331 Principles of Programming Languages. [3]
This course examines the semantics of programming languages. Topics include: formal specifications of syntax, declarations, binding, allocation, data structures, data types, control structures, control and data flow; the implementation and execution of programs; and functional programming versus imperative programming. Other possible topics include: non-procedural and logic programming; object-oriented programming; and program verification. Programming projects will provide experience in a number of languages. Prerequisites: CMSC 202.
An examination of a wide range of advanced data structures with an emphasis on an object-oriented approach. Topics include: a further introduction to asymptotic analysis; a variety of binary search trees including AVL, red-black, and splay trees; skip lists and tries as alternatives to binary search trees; data structures for geometric and multi-dimensional data including quad trees, k-d trees and interval trees; heaps and priority queues including binary heaps, binomial heaps, leftist heaps (and/or other mergeable heaps); and B-trees for external storage. Programming projects in this course will focus on implementation issues for data structures and on empirical analysis of their asymptotic performance. Prerequisites: CMSC 202 and CMSC 203.
CMSC 404 The History of Computers and Computing. [3]
This course is an historical account of the pioneers of computing and the rise of the computer and related industries. Although technical and institutional developers are the focus of the class, such developments are explained in a broad historical context --- one including such factors as the state of scientific knowledge, economic conditions, defense requirements, the nature of business and financial systems, and governmental policies. Prerequisite: junior or senior status or permission of instructor. Note: also listed as IFSM 404 and HIST 404. This course does not fulfill a computer science elective requirement.
CMSC 411 Computer Architecture. [3]
This course covers the design of complex computer systems making heavy use of the components and techniques discussed in CMSC 311 or CMPE 312. All parts of a computer system - CPU, memory, and input/output --- are discussed in detail. Topics include information representation, floating-point arithmetic, instructions set design issues (RISC vs. CISC), microprogrammed control, hardwired control, pipelining, memory caches, bus control and timing, input/output mechanisms, and issues in the construction of parallel processors. Prerequisite: CMSC 311 or CMPE 312.
CMSC 412 Microprocessor Systems. [3]
A study of microprocessor hardware and software. Topics include the architecture, addressing schemes, and data manipulation mechanisms of popular microprocessors. Prerequisites: CMSC 311 and CMSC 331.
CMSC 421 Principles of Operating Systems. [3]
An introduction to the fundamentals of operating systems. Topics include: interprocess communication, process scheduling, deadlock, memory management, virtual memory, file systems, and distributed systems. Formal principles are illustrated with examples and case studies of one or more contemporary operating systems. Prerequisites: CMSC 311 and CMSC 341.
CMSC 422 Operating System Design. [3]
The study of the internal design of a widely used operating system such VMS or UNIX with an emphasis on systems programming for the operating system. Topics include: kernel design, the I/O system, scheduling algorithms, process control, interprocess communication, system calls and memory management Prerequisite: CMSC 421.
CMSC 425 Performance Analysis of Computer Systems. [3]
Review of probability theory, birth-death processes, Markov chains, mean-value analysis, approximation techniques, simulation studies on the performance of computer systems. Prerequisite: STAT 355 or permission of the instructor.
CMSC 431 Compiler Design Principles. [3]
A detailed study of the design and implementation of a compiler for a high-level programming language. Topics include: lexical analysis, parsing techniques (including LL and LR parsers), semantic routines, run-time storage allocation, code generation and optimization. Prerequisites: CMSC 311 and CMSC 331.
CMSC 432 Object-Oriented Programming Languages and Systems. [3]
This course covers the concepts of object-oriented programming (OOP) languages and systems including an introduction to fundamental abstraction, modularity and encapsulation mechanisms in OOP from a software engineering and representational perspective. Basic OOP concepts covered in this course include: polymorphism and operator overloading; message passing via generic functions; late versus early binding times; and inheritance mechanisms and their relationship to the type systems of programming languages. Other topics include: a survey of OOP languages and systems; OOP languages versus imperative programming languages; and contrasting pure OOP environments versus mixed paradigm languages. Prerequisite: CMSC 331.
CMSC 435 Computer Graphics. [3]
An introduction to the fundamentals of interactive computer graphics. Topics include: graphics hardware; line drawing; area filling; clipping; two-dimensional and three-dimensional geometrical transforms; three-dimensional perspective viewing; hidden surface removal; illumination; color; and shading models. Prerequisites: CMSC 341 and MATH 221.
CMSC 437 Graphical User Interface Programming. [3]
This is a practical, hands-on course in how to program interactive 2D graphical user interfaces using the X11/Motif package and OpenGL. Graphical user interfaces are taken here to mean not just standard widget sets but also a variety of interactive, pointer-based techniques that comprise the modern desktop metaphor. So, this course will also introduce some of the concepts and software techniques used to implement such applications. In addition, it will briefly review some of the larger issues, history and future directions of programming graphical interfaces. While the primary emphasis of the course is on 2D interfaces, there will be a short introduction to some of the 3D capabilities of OpenGL as well as a discussion of 3D interaction and virtual reality. Prerequisite: CMSC 341 and MATH 221.
CMSC 441 Design and Analysis of Algorithms. [3]
This course studies fundamental algorithms, strategies for designing algorithms, and mathematical tools for analyzing algorithms. Fundamental algorithms studied in this course include: graph algorithms; algorithms for sorting and searching; hashing; integer arithmetic; and selected combinatorial tasks. Mathematical tools include: asymptotic notations and methods for solving recurrences. Algorithm design strategies include: the greedy method, divide-and-conquer, dynamic programming, and randomization. Prerequisites: CMSC 341 and MATH 152.
CMSC 442 Information and Coding Theory. [3]
An introduction to information and coding theory. The error-control coding problems, entropy, channels, Shannon's theorems, error correcting codes, applications of coding theory, algebraic coding theory, block codes, linear codes, cyclic codes, decoding algorithms, BCH codes, convolutional codes, sequential circuits and sequential decoding. Prerequisites: CMSC 203 and MATH 221.
An introduction to cryptology --- the science of making and breaking codes and ciphers. Topics include: conventional and public-key cryptosystems, including DES, RSA, shift-register systems, and selected classical systems; examples of cryptanalytic techniques; digital signatures, pseudorandom number generation, cryptographic protocols, and their applications; and an introduction to the theories of cryptographic strength based on information theory and complexity theory. Prerequisites: CMSC 203 and MATH 221.
CMSC 445 Software Engineering. [3]
This course describes the software development process in detail including: the software life cycle and models of software development; requirements analysis and software design techniques, such as SADT and Jackson Design Methodology; techniques for software quality assurance, including design reviews, testing, metrics and an introduction to program verification; and software project planning, organization and management. Students will be expected to participate in a team programming project. Prerequisites, CMSC 211, CMSC 331 and CMSC 341.
CMSC 451 Automata Theory and Formal Languages. [3]
This course introduces the basic concepts in the theory of formal languages. Topics include: regular grammars and finite automata; context-free grammars and push-down automata; Turing machines and the halting problem; and an introductory treatment of computable and non-computable functions. Prerequisites: CMSC 202 and CMSC 203.
CMSC 452 Logic for Computer Science. [3]
This course covers the fundamental topics in sentential and first order logic, including models, logical consequence, deduction and the completeness theorem. Other topics include: undecidability theorems, including Goedel's incompleteness theorem and Tarski's theorem; Herbrand's theorem; and applications including resolution, logic programming, automatic deduction, program specification and program verification. Prerequisite: Though not a formal prerequisite (the material is independent), CMSC 451 is strongly recommended.
CMSC 453 Applied Combinatorics and Graph Theory. [3]
An introduction to the application of combinatorial methods to computer science. Topics include: enumeration methods; recurrence relations; generating functions; graph theory and graph algorithms; connectivity; Euler tours; Hamiltonian cycles; flow graphs and transport networks; matching theory; planarity; Kuratowski's theorem; and NP-complete combinatorial problems. Prerequisites: CMSC 203, CMSC 341, MATH 152 and MATH 221.
CMSC 455 Numerical Computations. [3]
Topics include: numerical linear algebra, interpolation, solving non-linear systems and the numerical solution of differential equations. This course also provides some emphasis on numerical algorithms and computation in a parallel environment. Prerequisites: CMSC 341 and MATH 221.
CMSC 456 Symbolic Computation. [3]
The theme of this course is abstract algebra from an algorithmic perspective. Algorithms for computing in groups, rings, fields, ideals, quotient rings, and other algebraic objects are studied. For example, the Coxeter coset enumeration and the Groebner basis algorithms are studied. Algebraic varieties play a key role in this course. The course also covers many applications of symbolic computation, such as applications to algebraic coding theory, robotics, and automatic theorem proving. There are various projects using a symbolic computation package such as Maple or Mathematica. Prerequisites: CMSC 341 and MATH 221.
CMSC 461 Database Management Systems. [3]
This course covers database management and the different data models currently used to structure the logical view of databases: relational, hierarchical and network. The course also covers implementation techniques including: file organization, query processing, concurrency control, recovery, integrity and security. Prerequisite: CMSC 341.
CMSC 471 Artificial Intelligence. [3]
This course is designed as a broad introduction to artificial intelligence. Topics include: an overview of AI, its subfields and applications; knowledge representation, techniques and issues; natural language understanding; search; logic and deduction; basic robot plan generation; expert systems; handling uncertainty; and learning. Prerequisite: CMSC 341.
CMSC 472 Knowledge-Based Systems. [3]
This course is designed for students interested in expert systems and other computer programs whose performance depends upon specialized domain knowledge such as that possessed by human experts. Topics include: production system fundamentals; knowledge representation for expert systems; problem solving methods including forward and backward chaining, and belief and uncertainty; and an expert system case study. Prerequisites: CMSC 341 and CMSC 451 or CMSC 452 or PHIL 348 or some formal background in mathematics or logic.
CMSC 481 Computer Networks. [3]
This course introduces the fundamentals of data communication and computer networking including: circuit and packet switching; network architectures and protocols; local/metropolitan/wide area networks; OSI protocols; TCP/IP suite; X.25; ISDN; network management; and network programming. Prerequisites: CMSC 311.
CMSC 482 Computer Systems Security. [3]
This course will cover an introduction to computer security concepts: security and integrity policies; access and flow controls; security models; Trojan horses and covert channels; formal security specifications and verification; security architectures; and DOD classification of secure systems. Prerequisite: CMSC 421.
CMSC 483 Parallel and Distributed Processing. [3]
This course provides a project and applications oriented approach to parallel and distributed programming. Students will learn a specific parallel language and programming environment and will complete a large programming project. Topics include a selected parallel programming language; a survey of parallel and distributed architectures and associated programming styles; an introduction to parallel and distributed algorithms; and a study of tradeoffs between computation and communication in parallel processing. Prerequisites: CMSC 331 and CMSC 421.
CMSC 491 Special Topics in Computer Science. [1-4]
This course may be repeated provided the topic varies.
CMSC 498 Independent Study in Computer Science for CMSC Interns and COOP Students. [3]
This course is offered on a pass/fail basis only. This course may not be repeated.
CMSC 499 Independent Study in Computer Science. [1-4]
This course is offered on a pass/fail basis only. [an error occurred while processing this directive]