Univ. of Virginia, Department of Computer Science
Course Objectives for Undergraduate Courses

(Last updated on March 26 2004. Please email updates or corrections to Tom Horton.)

This document is intended for CS faculty and others at the University who wish to see the course objectives defined for each CS undergrad course. These have been developed in part to help us meet ABET/CAC assessment requirements.

This is a working document. Each term instructors may alter the objectives for their course. They may wish to adopt or modify the objectives that other instructors used. They should send an updated copy of their objectives to Tom Horton so that they can be added to this document. Instructors who are writing or modifying course objectives should see the guidelines at the end of this document for importnat information.

Click on a course number below to jump to its course objectives.

[CS101]    [CS110]    [CS120]    [CS200]    [CS201]    [CS201J]    [CS202]    [CS216]    [CS333]    [CS340]    [CS390]    [CS414]    [CS415]    [CS416]    [CS432]    [CS440]    [CS445]    [CS446]    [CS453]    [CS457]    [CS494]    [CS551: Advanced Graphics]    [CS551: Real-time Rendering]    [CS551: Dependable Computing]    [CS571]    [CS588]   

[Horton, Spring 02] Students who complete the course will:

1. Understand common fundamentals of programming such as variables, conditional and iterative execution, functions, etc.
2. Understand fundamentals of object-oriented programming in C++, including defining classes, calling member functions, using class libraries, etc.
3. Have an appreciation of important topics and principles of software development and computer science.
4. Be able to write a computer program to solve a specified problem.
5. Have strong practical experience using the Microsoft Visual C++ environment to create, debug and run simple C++ programs.

[Horton, Spring 02] Upon completing the course, students will be able to:

1. Identify and analyze ethical and social responsibility issues that arise related to computing and information technology.
2. Apply basic and intermediate skills to create useful documents etc. using Word, Excel, and Powerpoint software.
3. Analyze Web sites for effectiveness, design and style, and to create good Web pages using HTML editors.
4. Understand the basic principles underlying technologies behind the Web, including HTML, the role of the client and server, and the fundamentals of client/server communication.
5. Understand the basics of computing topics such as programming, algorithms, database systems, and e-commerce.

[Ferrer, Spring 02] Students will:

1. Create user interfaces using the Visual Basic programming language.
2. Understand and apply basic structured programming constructs (including loops, conditionals, procedures, functions, variables, and arrays) in the context of the Visual Basic programming language.
3. Develop an understanding of the role of computers and programming in modern business practice.
4. Understand and manipulate sequential and random access files, and simple relational databases.

[Evans, Spring 2002] This course will:

1. Teach students with no previous background to think like computer scientists.
2. Convince students majoring in liberal arts to take further computer science courses.
3. Teach students to understand language, produce programs and reason about the processes they define.

[Sullivan, Fall 2002] Students at the end of the course will:

1. Understand Software Engineering principles of information hiding, software reuse and libraries. Understanding is reinforced by identification of design decisions and use of existing classes.
2. Develop good programming practices and knowledge of object-oriented design through the design and implementation of small systems from requirements specifications. Students use separate compilation, and develop test cases.
3. Develop understanding of various programming tools and environments. In particular, become familiar with interactive development environments, especially preprocessors, compilers, linkers, and learn to diagnose errors using debuggers.
4. Develop understanding of imperative programming and the underlying model of computation. In particular, students master operator precedence, iteration, condition statements, streams, pointers, structures and simple data structures, including linked lists and binary search trees. Mastery gained by implementing ~1000 line algorithms.
5. Understand object-oriented programming and some design. Students master classes, objects, members, access rules, operators, constructors and destructors, templates, virtual functions. Mastery gained by design of classes, templates and constructors. Students are exposed to the ideas of architectures and frameworks, with a particular emphasis on event-driven, message-passing frameworks for graphical user interface construction. Students implement a non-trivial graphical user interface in a group project.
6. Develop understanding of inheritance, virtual functions, problems related to explicit memory allocation, overloading functions. Understanding gained by design and implementation of hierarchy of classes, by derivation of classes from existing classes and implementation of copy constructors, assignment operators and destructors.

[Milner, Anderson, Fall 01 and Spring 02] Students at the end of the course will:

1. Understand Software Engineering principles of information hiding, software reuse and libraries. Understanding is reinforced by identification of design decisions and use of existing classes.
2. Develop good programming practices and knowledge of object-oriented design through the design and implementation of small systems from requirements specifications. Students use separate compilation, and develop test cases.
3. Develop understanding of various programming tools and environments. In particular, become familiar with source-code control tools and interactive development environments, and learn to locate errors using debuggers.
4. Develop understanding of imperative programming and the underlying model of computation. In particular, students master operator precedence, iteration, condition statements, streams, pointers, structures and simple data structures. Mastery gained by implementing ~1000 line algorithms.
5. Understand object-oriented programming and some design. In particular, students master classes, objects, members, access rules, operators, constructors and destructors, templates.. Mastery gained by design of classes, templates and constructors.
6. Develop understanding of inheritance, virtual functions, problems related to explicit memory allocation, overloading functions. Understanding gained by design and implementation of hierarchy of classes, by derivation of classes from existing classes and implementation of copy constructors, assignment operators and destructors.

[Evans, Fall 03] Students who complete this course will:

1. Understand mechanisms for managing complexity in software systems including procedural abstraction, data abstraction and specification.
2. Be able to apply these mechanisms to design and implement a medium-size software system.
3. Be able to think about and document procedural interfaces and data type invariants and use these properties to reason informally about program correctness.
4. Develop good strategies for testing programs, but realize the limitations of testing in proving program correctness.

[Taylor, Fall 2002]

1. Introduce a formal system (propositional and predicate logic) which mathematical reasoning is based on.
2. Develop an understanding of how to read and construct valid mathematical arguments (proofs) and understand mathematical statements theorems).
3. Introduce and work with various problem solving strategies and techniques (e.g. abstracting away unimportant details to state a problem in its basic form, transforming a problem into another simpler problem which we have already solved).
4. Introduce and work with important discrete data structures such as sets, relations, and discrete functions.
5. Develop important mathematical traits such as precision and the willingness and ability to investigate and solve one problem in multiple ways to verify that the solution is indeed correct.

[Anderson, Fall 03] Students will:

1. Implement basic and advanced data structures in C++ (stacks, queues, hash tables, binary search trees & balanced trees, heaps, graphs).
2. Evaluate the asymptotic time and space complexity of the above listed data structures and assess the suitability of a data structure for a particular problem.
3. Develop an understanding of the underlying representation of basic data structures (ints, chars, floats, arrays, records, pointers) as well as more advanced structures (linked lists, 2-D arrays, trees, hash tables, heaps, graphs).
4. Implement basic program control and data structures in an assembly language (loops, conditionals, subroutines and parameter passing modes, arrays)
5. Develop a basic understanding of program execution model and underlying computer hardware and software (fetch-execute cycle, memory hierarchy, operating system, compiler).

[Milner, Fall 02] Upon completing this course, students will:

1. Understand the classification of computers (accumulator machines, stack machines
   and general purpose register machines), instruction types (arithmetic, data movement
   and control), instruction formats (0,1,2, etc.-address machines) and addressing modes.
2. Understand formal notations for describing processors.
3. Evaluate the design and performance trade-offs between Complex Instruction Set`Computers (CISC) and Reduced Instruction Set Computers (RISC) .
4. Develop an understanding of processor design (the design process, data path implementation, control unit implementation, 1- 2- and 3-bus processor designs and machine exceptions, pipelining and instruction-level parallelism)
5. Develop an understanding of computer arithmetic and arithmetic units
6. Develop an understanding of the memory hierarchy, cache memory and virtual memory.
7. Gain practical experience in programming with assembly language.
8. Understand program vulnerabilities arising from computer architecture decisions.

[Knight, Spring 2002] Students will:

1. Develop an understanding of how to specify, design, and implement a complex software entity that involves many aspects of modern software systems.
2. Master a number of modern tools and a number of difficult technical fields including user interface design, distributed architecture development, and concurrent programming.
3. Develop the skills necessary to prepare professional quality technical documents as are required in the creation of complex software systems.
4. Develop the presentation skills necessary to convey elaborate and detailed technical concepts to colleagues.
5. Acquire experience of working on a large software system as a member of a group working on system development and as a member of a group that has to interact with other groups and customer representatives.

[Luebke, Spring 04] At the end of the semester students will:

1. Have been exposed to a wide range of state-of-the-art research topics in computer science and related disciplines.
2. Have begun preparing to undertake an in-depth research project in computer science or a related field.
3. Have been exposed to issues and questions in ethics and professionalism in computer science.

[Son, Fall 03] Students will:

1. Develop a basic understanding of key concepts and notions in operating systems.
2. Develop an understanding how the computer architecture and programming languages interact with OS to manage the concurrent activities and resources.
3. Develop an understanding of some of the major components of operating systems, including process, scheduling, virtual memory, and file system, as well as more advanced topics such as real-time systems.
4. Develop skills to understand an existing OS and make changes to underlying mechanisms.
5. Implement control structures and necessary mechanisms for concurrency control and resource management using an instructional OS.

[Skadron, Spring 02] students will:

1. Develop an understanding of the tasks and components of an operating system and how they influence the operation of user-level programs.
2. Implement the fundamental services and data structures that comprise an operating system kernel: system calls, process creation and scheduling, resource management, virtual memory, and synchronization primitives.
3. Learn the principles of correct concurrent programming and how various types of synchronization primitives operate.
4. Implement correct concurrent programs using various types of synchronization primitives.
5. Develop an understanding of the fundamental concepts of security in an operating system.

[Anderson, Fall 03]

1. Develop a greater understanding of the issues involved in programming language design and implementation.
2. Develop an in-depth understanding of functional, logic, and object-oriented programming paradigms.
3. Implement several programs in languages other than the one emphasized in the core curriculum (C++).
4. Understand design/implementation issues involved with variable allocation and binding, control flow, types, subroutines, parameter passing.
5. Develop an understanding of the compilation process.

[Ferrer, Spring 02] Students will:

1. Develop an understanding of classical AI algorithms including theorem provers, graph searching, heuristic functions, alpha-beta search, genetic algorithms and neural networks.
2. Learn how to write functional programs in the Common Lisp programming language.
3. Understand how to apply the scientific method to claims made regarding AI algorithms and systems.

[Horton, Fall 03] Upon successful completion of this course, students will:

1. Comprehend fundamental ideas in algorithm analysis, including: time and space complexity; identifying and counting basic operations; order classes and asymptotic growth; lower bounds; optimal algorithms.
2. Apply these fundamental ideas to analyze and evaluate important problems and algorithms in computing, including search, sorting, graph problems, and optimization problems.
3. Apply appropriate mathematical techniques in evaluation and analysis, including limits, logarithms, exponents, summations, recurrence relations, lower-bounds proofs and other proofs.
4. Comprehend, apply and evaluate the use of algorithm design techniques such as divide and conquer, the greedy approach, dynamic programming, and exhaustive or brute-force solutions.
5. Comprehend the fundamental ideas related to the problem classes NP and NP-complete, including their definitions, their theoretical implications, Cook's theorem, etc. Be exposed to the design of polynomial reductions used to prove membership in NP-complete.

[Luebke, Fall 02] Students will be able to:

1. Learn to work in groups that span disciplinary boundaries.
2. Learn to use new tools, techniques, and media in the realm of 3D computer animation.
3. Learn the skills of making short video segments incorporating 3D animation and visual effects.

[Fall 02, Brogran] Students will have:

1. Developed a working knowledge of the mathematics, science, and engineering topics related to the theory of computer graphics (linear algebra, calculus of splines, optics of light transfer, engineering efficient rendering algorithms).
2. Implemented fundamental graphics algorithms and state-of-the-art applications using the OpenGL programming environment.
3. Gained experience developing intermediate-sized computer programs, using existing libraries to build more complex programs, and using graphical visualization methods to debug.

[Luebke, Fall 02] Not yet documented here.

[Fall 02, Weaver] Upon completion of this course, students will be able to:

1. Understand the history of the Internet, World Wide Web, electronic commerce, and the rise of web innovation, utilizing case studies of success and failure.
2. Understand the need for privacy and security, and how they are implemented using cryptography; study the mathematical fundamentals of cryptography supporting symmetric key and public key crypto.
3. Utilize crypto in electronic commerce by using SET, SSL, and PHP.
4. Utilize a weekly hands-on programming laboratory to implement electronic commerce software using JavaScript, Perl, CGI, SQL, ASP, and XML. The programming lab was a new addition for this semester.
5. Investigate website security; understand the threat of viruses, worms, and hacking tools.
6. Identify the value of intellectual property and how to protect it via copyrights, trademarks, trade secrets, and patents. Conduct a mock patent infringement trial

[Abdelzaher, Fall 03] The student should be able to:

1. Define, distinguish, understand and apply netowrking concpets related to Network Architecture and Layering, Link Layer Protocols, LANs and Wireless, Routing and Switching, the TCP/IP Protocol Suite, Congestion Control, Network Applications, and WWW.
2. Synthesize ideas presented in the course into original new network services, protocols, architectures, or tools.
3. Work in an interdisciplinary group (combining CS and EE students)

[Horton, Spring 03] Students should be able to:

1. Create a requirements model using UML class notations and use-cases based on statements of user requirements, and to analyze requirements models given to them for correctness and quality.
2. Create the OO design of a system from the requirements model in terms of a high-level architecture description, and low-level models of structural organization and dynamic behavior using UML class, object, and sequence diagrams.
3. Comprehend enough Java to see how to create software the implements the OO designs modeled using UML.
4. Comprehend the nature of design patterns by understanding a small number of examples from different pattern categories, and to be able to apply these patterns in creating an OO design.
5. Given OO design heuristics, patterns or published guidance, evaluate a design for applicability, reasonableness, and relation to other design criteria.

[Brogan, Spring 02] A student will be able to:

1. Use a textbook and many modern research papers to provide the student with advanced knowledge of the mathematics, science, and engineering topics related to the theory of computer graphics and animation (optimization, linear algebra, calculus of splines, inverse kinematics, artificial intelligence, two-point boundary value problems).
2. Implement state-of-the-art graphics and optimization techniques using the OpenGL programming environment.
3. Gain experiene developing intermediate-sized computer programs with graphical user interfaces, using the FLTK library to build more complex programs.
4. Use graphical visualization methods to debug.

[Luebke, Fall 02] In this course, students will:

1. Learn about and implement advanced computer graphics techniques used for real-time rendering: level of detail, visibility and occlusion culling, scene graph representation, etc.
2. Learn about modern graphics hardware architecture and capabilities, focusing on programmable vertex and fragment pipelines.
3. Exposure to a high-level language for programmable graphics hardware (e.g., the Cg language by NVIDIA).
4. Learn about and implement some current rendering and special effects techniques (e.g., particle systems, non-photorealistic rendering, shadow volumes)
5. Develop a broad integrative project throughout the course of the semester, working in teams over several assignments, to incorporate all of the above techniques.

[Knight, Fall 2003] Students will:

1. Develop an understanding of the need for dependability in modern digital systems.
2. Master the terminology and basic concepts of dependable computing.
3. Develop the skills necessary to analyze complex digital systems and identify the types of faults to which they are vulnerable.
4. Develop the skills necessary to design digital systems that meet appropriate dependability requirements.
5. Acquire experience of using design and analysis techniques used in the field of dependable computing.

[Davidson, Fall 03] Students will:

1. Learn the basic architecture of a typical compiler.
2. Learn the theory and techniques for analysis of a source program including lexical analysis, syntax analysis, and semantic analysis.
3. Learn to use compiler development tools such as lex, yacc, cup.
4. Learn to use a compiler for a subset of a modern programming language. This includes both a code generator for an existing processor and a small optimizer.

[Evans, Fall 01] This course will:

1. Teach students to think critically and rigorously about security.
2. Develop understanding of the theory and mathematics behind historical and modern cryptosystems.
3. Be able to analyze the security of cryptosystems and software designs.
4. Be able to explain security issues clearly to both non-technical audiences and computer scientists without solid security knowledge, and relate them to political, legal and economic issues.
5. Inspire students to enjoy working on challenging problems and persist until a solution is found.

Guidelines for Writing Course Objectives:

In this context, what do we mean by course objectives?

These should be course goals written up as a series of bullet items that describes skills or knowledge that students will have at the end of the course.

• You can think of these as criteria that describe what students should have learned or experienced at the end of the course.
• They should describe characteristics of the students. They should not be a list of topics covered, or a list of things taught, or a list of things students do. The point of view should be "characteristics of the student at the end of the course."
• Write these at a high-level of abstraction. Normally 3-7 objectives is plenty. From a practical point of view, you want fewer of these because you may be required to collect data or write up results for each of your objectives!
• You may want to indicate the level of learning for each objective. Sometimes people use words related to the six levels of learning defined in Bloom's taxonomy to indicate a level of learning for each item. So terms like be exposed to, comprehend, apply, evaluate, synthesize, etc. might be appropriate to indicate how much they should know. For more info and lists of good description words, see these pages: http://www.humboldt.edu/~tha1/bloomtax.html or http://ceaspub.eas.asu.edu/mae-ec2000/blooms.htm
• Please include your course objectives in your beginning-of-course memo (syllabus) if possible and on your class Web page. Make your objectives known to your students.

The first two examples on this page (CS101 and CS110) were written with these guidelines in mind (and others were too). But not all the examples here were written as suggested here. If you adopt or modify, please try to re-write your new course objectives as suggested here. Thanks.

---

Assessment based on Course Objectives:

Course objectives may be the basis for assessing how well students succeed in your course. Your ABET coordinator will provide full details. Typically it works like this.

Each objective is assess separately. The overall course grade (or the grade of the final exam etc.) combines results for student performance in all areas. We need more fine-grain information about students' performance in your course.

Why? For example, assume the department is assessing "design" across all sets of course. One of your course objectives may map to the degree-program's objective on "design". At the end of your course, you will report data on how well students' did on your course-objective about design. Someone will get these results, combine them with "design" results from other courses, and obtain an overall measure of students' performance in the area of design.

If this kind of analysis is required for your course (ask your ABET coordinator if it is), then at the start of term you must identify the specific aspects (problems, experiments etc.) of your assignments that measure student achievement of each course objective. On a test
for example, certain problems may measure student achievement of one objective and other problems another objective. It is necessary to record these individual scores and at the end of the course come up with a composite score that measures how well you achieved each objective. These objective scores may be based on a few measures (something from the final project and a question or two on the final exam) -- it's up to you to decide what subset of what the students do for grades is the best summative measure of their performance in an area.

Again, if you are required to do this level of analysis, plan ahead. You will need to record scores in a way that allows you to report on a per-objective basis. You will need to report performance data and write up a paragraph that describes your assessment of your achievement of each objective based on the data in your end-of-course memo (EOCM).

Example from CS432 (above): You could imagine that problems on the midterm and final exam could be mapped to the five course objectives listed there. Also, homework problems could also be mapped to one of these five objectives. With some thought, some individual scores could be recorded and combined to give an overall score for each objective. (Makign good use use of a spreadsheet and your TAs can greatly facilitate this, obviously.)