2000 Computer Science Course Descriptions

Note: These are the course descriptions as they appear in the 2000-2002 UMBC Undergraduate Catalog. The prerequisites for some courses have changed. See Spring 2000 Preregistration News.

Course descriptions that differ from or supersede the 2000-2002 catalog appear in blue.

The old course descriptions are still available.

Last update: 03/30/2001

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 documen-tation. 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. Prerequisite: 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, sub-routines, functions, arrays and files. This course also covers general programming concepts including computer components, structured programming, algorithm development, problem solving, testing, debugging and documentation. 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. Students who have taken, received transfer credit for, or are taking concurrently any computer programming course in a high-level programming language will not receive credit for CMSC 104. The list of such computer programming courses includes, but is not limited to, CMSC 103, CMSC 106, CMSC 109, CMSC 201, CMSC 202, and sections of CMSC 291 that cover programming topics.

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. 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 201. Prerequisite: Mastery of a high-level programming language other than C.

CMSC 109 Programming Topics. [2]

An introduction to programming in a specific programming language, which may vary from semester to semester. Note: 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. [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. [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 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. Prerequisite: CMSC 201 and either MATH 151 or MATH 140.

CMSC 203 Discrete Structures. [3]

This course 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: MATH 151 or MATH 140. Corequisite: CMSC 103 or CMSC 201.

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. Prerequisite: Varies by topic. Check current schedule of classes.

CMSC 299 Independent Study in Computer Science. [1-4]

A student may enroll in this course to study computer science topics that are not available in a regular course. The student and the faculty member supervising the independent study must determine the objectives of the project, the number of credits to be earned and the evaluation criteria for the project. Students are limited to two independent study courses in computer science. Note: this course is offered on a P/F basis only and does not apply toward the requirements for a computer science major. Prerequisite: permission of the instructor.

CMSC 311 Introduction to Computer Organization. [3]

This course covers basic concepts of digital logic, including 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 203.

CMSC 313 Computer Organization and Assembly Language Programming. [3]

This course covers the basics of computer organization with emphasis on the lower level abstraction of a computer system including digital logic, instruction set and assembly language programming. Topics includes data representation, logic gates, simplification of logical expressions, design and analysis of simple combinational circuit such as decoders and multiplexers, flip-flops and registers, design and analysis of simple synchronous sequential circuit, random-access and read-only memories, instruction set architecture and programming in assembly language. Prerequisites: CMSC 202 and CMSC 203.

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. Prerequisite: CMSC 202.

CMSC 341 Data Structures. [3]

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. Prerequisite: CMSC 202 and CMSC 203.

CMSC 345 Software Design and Development. [3]

This course introduces the basic concepts of software engineering including: software life cycle, requirements analysis and software design methods. Professional ethics in computer science and the social impact of computing are discussed as an integral part of the software development process. Additional topics may include: tools for software development, software testing, software metrics and software maintenance. Prerequisite: CMSC 341.

CMSC 391 Special Topics in Computer Science. [1-4]

This course may be repeated, provided the topic varies. Prerequisite: Varies by topic. Check current schedule of classes.

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. Note: Also listed as IFSM 404 and HIST 404. This course does not fulfill a computer science elective requirement. Prerequisite: Junior/senior status or permission of instructor.

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 and 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 211 and CMSC 311 ) or ( CMPE 310 and CMPE 312 ) or CMSC 313.

CMSC 412 Microprocessor Systems. [3]

A study of microprocessor hardware and software. Topics will include the architecture, addressing schemes, and data manipulation mechanisms of popular microprocessors. Note: Credit will not be given for both CMSC 412 and CMPE 310. Prerequisite: CMSC 211; and CMSC 311 or CMPE 312.

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. Prerequisite: CMSC 341 and [( CMSC 211 and CMSC 311 ) or ( CMPE 310 and CMPE 312 ) or CMSC 313 ].

CMSC 422 Operating System Design. [3]

The study of the internal design of a widely used operating system such as VMS or UNIX with an emphasis on system 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 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. Prerequisite: ( CMSC 211 or CMSC 313 ) and CMSC 331 and CMSC 341.

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 and CMSC 341.

CMSC 433 CMSC 433 Scripting Languages. [3]

This course is a study of a class of programming languages and tools known as Scripting Languages. Topics include: writing scripts to control and connect other programs, strengths and weaknesses of interpreted languages, extending scripting languages to include new functionality, embedding functions of a scripting language in other tools, syntax and usage of regular expressions, and the role of open source software. Programming projects in multiple languages will be required. Languages studied may include Unix shell and related tools (sed, awk), Perl, Tcl/Tk, and Python. 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. Prerequisite: 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. 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. Prerequisite: MATH 142 or 152; CMSC 341; and STAT 355.

CMSC 442 Information and Coding Theory. [3]

An introduction to information and coding theory. Topics include 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, linear sequential circuits and sequential decoding. Prerequisite: CMSC 203 and MATH 221.

CMSC 443 Cryptology. [3]

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. Prerequisite: CMSC 341; MATH 221; and STAT 355.

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. Prerequisite: CMSC 331 and 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. Prerequisite: 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. Highly recommended: CMSC 451

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. Prerequisite: CMSC 341, MATH 221, and either MATH 142 or 152.

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. Prerequisite: CMSC 341; MATH 142 or 152; 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. Prerequisite: CMSC 341; MATH 142 or 152; 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.

This course covers database management and the different data models currently used to structure the logical view of databases. The course also covers database design, 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. Prerequisite: CMSC 471.

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. Prerequisite: ( CMSC 311 or CMPE 312 or CMSC 313 ) and STAT 355.

CMSC 482 Computer Systems Security. [3]

This course will cover an introduction to computer security concepts including 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. Prerequisite: CMSC 421. Recommended: CMSC 455.

CMSC 491 Special Topics in Computer Science. [1-4]

This course may be repeated, provided the topic varies. Prerequisite: Varies by topic. Check current schedule of classes.

CMSC 496 Master of Science Preparation, Software. [4]

An accelerated course in software concepts specifically designed for technically sophisticated students who wish to trade exceptionally hard work for a shortened learning schedule. Compresses material from CMSC 331, CMSC 341, and CMSC 441 into a single semester. Note: Not open to undergraduate computer science or computer engineering majors or minors. Credits for this course do not apply to requirements for a computer science or computer engineering major or minor. Prerequisites: completion of CMSC 202, CMSC 203, MATH 152, MATH 221, the UMBC CMSC BS science requirements (or equivalent), and permission of the instructor.

CMSC 497 Master of Science Preparation, Systems. [4]

An accelerated course in software concepts specifically designed for technically sophisticated students who wish to trade exceptionally hard work for a shortened learning schedule. Compresses material from CMSC 211, CMSC 311, CMSC 411, and CMSC 421 into a single semester. Note: Not open to undergraduate computer science or computer engineering majors or minors. Credits for this course do not apply to requirements for a computer science or computer engineering major or minor. Prerequisites: completion of CMSC 202, CMSC 203, MATH 152, MATH 221, the UMBC CMSC BS science requirements (or equivalent), and permission of the instructor.

CMSC 498 Independent Study in Computer Science for CMSC Interns and Co-Op students

This course is offered on a P/F basis only. This course may not be repeated. Consult the department web page on CMSC 498 for more information.

CMSC 499 Independent Study in Computer Science. [1-4]

A student may enroll in this course to study computer science topics that are not available in a regular course. The student and the faculty member supervising the independent study must determine the objectives of the project, the number of credits to be earned and the evaluation criteria for the project. Students are limited to two independent study courses in computer science. Note: this course is offered on a P/F basis only and does not apply toward the requirements for a computer science major. Prerequisite: junior standing and permission of the instructor. [an error occurred while processing this directive]