Information for Prospective Students Information for First-Year Students Information for Transfer Students Information for International Students Learning Communities, Study Abroad, Theme Semester Calendars Quick Reference Forms Listings Table of Contents SAA Search Feature Academic Advising, Concentration Advising, How-tos, and Degree Requirements Academic Standards Board, Academic Discipline, Petitions, and Appeals SAA Advisors and Support Staff

Winter Academic Term 2003 Course Guide

Note: You must establish a session for Winter Academic Term 2003 on wolverineaccess.umich.edu in order to use the link "Check Times, Location, and Availability". Once your session is established, the links will function.

Courses in Electrical Engineering and Computer Science


This page was created at 11:27 AM on Thu, Feb 6, 2003.

Winter Academic Term, 2003 (January 6 - April 25)

Search the LS&A Course Guide
(Advanced Search Page)


EECS 181. Introduction to Computer Systems.

Computer Science

Instructor(s): Karen Langona

Prerequisites & Distribution: Intended for students whose goal is computer literacy; not intended for computer science, computer engineering, electrical engineering concentrators. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/181/001.nsf

EECS181 is meant to develop students into better computer users by offering a broad overview of how computers influence our lives. The lecture establishes what a computer is and how its parts affect the whole. In laboratory, students learn how to increase their productivity with several commercial software packages Microsoft PowerPoint, Word, and Excel, as well as Filemaker Pro. Students will also create and publish their personal Web site. There is no programming in this course.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 183. Elementary Programming Concepts.

Computer Science

Instructor(s): Mary Dorf (mdorf@umich.edu), Teorey

Prerequisites & Distribution: Not intended for engineering students. Students intending transfer to the College of Engineering should take ENGR 101. CS concentrators who qualify should elect EECS 280. Prerequisites enforced on Wolverine Access. Credit is granted for only one course among EECS 183 or ENGR 101. (4). (MSA). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/183/002.nsf

Fundamental concepts and skills of programming in a high-level language. Flow of control: selection, iteration, subprograms. Data structures: strings, arrays, records, lists, tables. Algorithms using selection an d iteration (decision making, finding maxima/minima, searching, sorting, simulation, etc.). Good program design, structure and style are emphasized. Testing and debugging.

EECS 183 can be taken by both majors and non-majors in Computer Science. The course does indeed teach "elementary programming concepts." The underlying goal of the course is to enable students to learn and apply fundamental programming techniques and solve basic programming problems using a high-level progr amming language. The language used is C++.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 203. Discrete Mathematics.

Computer Science

Instructor(s): Gregory Wakefield, Viviane Jensen , Martha Pollack

Prerequisites & Distribution: MATH 115. Prerequisites enforced on Wolverine Access. (4). (MSA). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://coursetools.ummu.umich.edu/2003/winter/eecs/203/001.nsf

EECS203 introduces the mathematical foundations of computer science and engineering. Topics covered include: propositional and predicate logic, set theory, functions and relations, growth of functions and asymptotic notation, introduction to algorithms, and elementary combinatorics and graph theory.

There are three lecture sections of EECS 203 this term, each with a faculty instructor; additionally there are four GSIs, each covering two discussion sessions. The instructors for each section are responsible for grading and advising you, but the content of all three sections will be closely coordinated, and the homework and examination questions, as well as examination times, will be identical. Note, however, that the lectures will not be strictly synchronized, so you should attend your own lecture and discussion section.

Required Textbook: Kenneth Rosen, Discrete Mathematics and Its Applications, 5th Edition, New York: McGraw Hill, 2003. Note that we are using a brand-new edition of this text.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 270. Introduction to Logic Design.

Computer Science

Instructor(s): Pinaki Mazumder (mazum@umich.edu)

Prerequisites & Distribution: Engineering 101 or EECS 183. Prerequisites enforced on Wolverine Access. (4). (MSA). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/courses/eecs270/

Course goals: This course is intended to give you an understanding of digital logic. We will mostly concern ourselves with gate-level designs, but we will also address one level of abstraction up (larger logic devices such as MUXes, adders, etc.) and one level down (CMOS and TTL logic). There will be a heavy emphasis on learning design tools in your lab sections, and in the latter half of the course, the use of a hardware description language (HDL), namely the ABEL HDL, to complete labs.

There will be six homework assignments. There will be two midterms and a final.

Grading Lab assignments: 35% Homework: 10% Midterms: 30% (15% each) Final: 25% Further, for each lab assignment where you do not complete the lab, you will have your course grade lowered by 1/3 a letter grade (B to B-, for example.).

Textbook: Wakerly, J. F., Digital Design: Principles and Practices, 3d ed. Upper Saddle River, NJ: Prentice-Hall, 2000.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 280. Programming and Introductory Data Structures.

Computer Science

Instructor(s):

Prerequisites & Distribution: MATH 115 and prior programming experience (assumes prior programming experience using decision constructs, iteration, functions, basic I/O, and simple arrays in C/C++). Those without prior programming experience should elect ENGR 101 or EECS 183 before electing EECS 280. Prerequisites enforced on Wolverine Access. No credit granted to those who have completed or are enrolled in EECS 283. (4). (MSA). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/280/001.nsf

Techniques for algorithm development and effective programming, top-down analysis, structured programming, testing, and program correctness. Program language syntax and static and runtime semantics. Scope, procedure instantiation, recursion, abstract data types, and parameter passing methods. Structured data types, pointers, linked data structures, stacks, queues, arrays, records, and trees.

OVERVIEW: The main purpose of this course is to prepare CS and CE majors for their remaining undergraduate coursework, which require a high level of independent programming skill. EE majors are also required to take this course. CSE courses which follow EECS 280 will assume that a student can independently write a 3000 line program in about a week or so.

By the end of this course, a student should be able to: take a problem and develop an algorithm to solve it, after comparing various possible algorithms
convert the algorithm into C++ code, using good design, structure and style
test and debug the program using appropriate techniques
understand the concepts of top-down design, data encapsulation, information hiding
design, implement and use complete classes including constructors, destructors, and operator overloading
implement dynamic data structures for stacks, queues and lists
be able to select an appropriate data structure for a given application afer
comparing various possibilities
be able to quickly design, implement, test and debug a large scale project independently (1000+ lines of code)

COURSE TOPICS The following general topic areas will be covered:
Implementation, testing, debugging
Arrays (1-dimensional, multi-dimensional)
File I/O
Structs
Classes, objects
Overloading
Friends
Strings (C-style and C++ string class)
Pointers and dynamic arrays
Templates
Linked Lists
Stacks, queues
Iterators
Exceptions
Recursion
Time permitting: STL (Standard Template Library)

Throughout the course we will discuss good programming style, design, documentation, and efficiency.

REQUIRED TEXTBOOKS: Absolute C++ Walter Savitch, 1st Edition, Addison Wesley Publishers, 2002 Note: a link to the publisher's materials accompanying this book is provided on the class course tools site

Practical Debugging in C++ Ann Ford & Toby Teorey, 1st Edition, Prentice-Hall Publishers, 2002

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 281(380). Data Structures and Algorithms.

Computer Science

Instructor(s): Jignesh Patel (jignesh@umich.edu) , Mark Brehob (brehob@umich.edu)

Prerequisites & Distribution: EECS 280 and 203. Prerequisites enforced on Wolverine Access. (4). (NS). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/courses/eecs281/

Course Overview: EECS 281 is an introductory course in data structures and algorithms at the undergraduate level. The objective of the course is to present a number of fundamental techniques to solve common programming problems. For each of these problems, we will determine an abstract specification for a solution and examine one or more potential representations to implement the abstract specification, focusing on those with significant advantages in time/space required to solve large problem instances. When appropriate, we will consider special cases of a general problem that admit particularly elegant solutions. Prerequisites Students must have obtained a grade of C or better in each of EECS/CS 203 and EECS/CS 280, or have equivalent knowledge of discrete mathematics and C++ programming and permission of the instructor. Students are expected to have C++ programming experience and familiarity with UNIX. Also, students are expected to have some experience with make. Students with questions about whether they have sufficient preparation for this course should speak with the instructors as soon as possible.

Grading Policy: Homework and quizes 10% Projects 40% (see below for breakdown) Midterm Exam 20% Final Exam 30%

Text books and reading list: This course has one required text: Algorithms in C++ by Sedgewick. There is also one recommended text: The C++ Standard Library: A tutorial and Reference by Josuttis.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 370. Introduction to Computer Organization.

Computer Science

Instructor(s): Don Winsor (don@umich.edu) , Gary Tyson (tyson@umich.edu) , Marios Papaefthymiou (marios@umich.edu)

Prerequisites & Distribution: EECS 280 or 283. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/courses/eecs370

Course Overview: This course is intended to give you a basic understanding of how computers execute programs. Understanding computers means understanding the hardware/software process of how you and the computer work together to have the computer carry out a concept. In your introductory programming courses (e.g. EECS 280), you learned how to express a concept in terms of a high-level programming language such as C/C++. In EECS 370, you will see how a low-level language is executed by the hardware, and you will see how to put together basic, hardware building blocks to form the functional units of a computer. To achieve these goals, you will design and "build" simple computers at various levels of detail. Building in this course will not mean connecting chips and gates. Rather, you will describe the hardware in diagrams, finite-state machines, and hardware simulators (written in C). To further your understanding of other topics, we will provide practice questions that will be discussed in the discussion sections. Prerequisites Students must have taken EECS 280. Depending on when you took EECS 280, you may not yet be familiar with programming C on Unix. I advise you to learn quickly. A brief overview of C vs. C++ will occur during the first discussion section of the semester. Also you can go to GSI office hours for additional help.

Four projects will be assigned during the term, each of which will require a substantial time commitment on your part. There will be three exams this semester. There will be 4 or 5 homework assignments

Grading policy Final grades will be based on the total points earned on the projects and exams. Factors such as class participation may be used to adjust your final grade, especially if it falls on a borderline. The tentative point breakdown is as follows: Projects 10% each = 40% Homework (Probably 4-6 assignments) = 5% Exams 2 midterms, 15% each, 1 final 25% = 55%

Course Material: The required text for the course is Computer Organization and Design: The Hardware/Software Interface (2nd edition), by Patterson and Hennessy. There are also optional lecture notes on the course web page.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 373. Design of Microprocessor Based Systems.

Computer Science

Instructor(s): Steve Reinhardt

Prerequisites & Distribution: EECS 370 and 270; junior standing. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/courses/eecs373

Course Objectives In this class, you will: learn how the hardware and software components of a microprocessor-based system work together to implement system-level features; learn both hardware and software aspects of integrating digital devices (such as memory and I/O interfaces) into microprocessor-based systems; learn the operating principles of, and gain hands-on experience with, common microprocessor peripherals such as UARTs, timers, and analog-to-digital and digital-to-analog converters; get practical experience in applied digital logic design and assembly-language programming; and be exposed to the tools and techniques used by practicing engineers to design, implement, and debug microprocessor-based systems. This course has both a lecture component and a lab component. Lectures will generally focus on universal concepts of microprocessor-based system design. The lab will reinforce these concepts as you are forced to apply them to a real system. Of necessity, some lecture time will be spent covering aspects specific to the lab. At the end of the semester, you will have the chance to apply your lab skills to a project in which you design and build a microprocessor-based system of your own choosing. The lab is a very important part of the class, and will require a significant investment of your time. One of our goals is that the knowledge and experience you gain from this course will justify the time you spend on it (even if it takes you several years to realize that). However, we cannot meet this goal without your cooperation. The ability to debug your hardware and software efficiently, including the effective use of the debugging tools available in the lab, is a critical skill which separates those who succeed in this class from those who spend hours spinning their wheels. If you feel you are spending an inordinate amount of time in the lab, chances are good that your debugging technique is at fault. We will try to emphasize debugging techniques in the lab sections and occasionally in the lecture this semester.

Prerequisites: You must have taken EECS 270 and EECS 370 to take this course. This also implies you have taken EECS 280. I will assume you are familiar with (on the hardware side) Boolean algebra, gates, multiplexers, flip-flops, and finite-state machines, (on the computer architecture side) assembly language, pipelining, memory, and caching, and (on the software side) program control structures (if/then/else, while and for loops), functions, procedures, parameter passing, pointer-based data structures, and basic structured programming techniques (information hiding, modular programming, etc.).

Grading Overall breakdown: Item Weight (each) Total Labs (8) 2-7% 40% Project 20% 20% Midterm exams (2) 10% 20% Final exam 20% 20% In spite of this breakdown, you will not earn a C in this course unless you have a C average on the labs+project and on the exams independently. Lab grade breakdown: Item Weight Prelab 30% Demonstration 40% Lab report 30%

There is no required textbook for this course.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 376(476). Foundations of Computer Science.

Computer Science

Section 001.

Instructor(s): Daniel Koditschek (kod@umich.edu)

Prerequisites & Distribution: EECS 280 or 203. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/376/001.nsf

An introduction to computation theory: finite automata, regular languages, pushdown automata, context-free languages, Turing machines, recursive languages and functions, and computational complexity

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 376(476). Foundations of Computer Science.

Computer Science

Section 002.

Instructor(s): Shi

Prerequisites & Distribution: EECS 280 or 203. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/376/002.nsf

No Description Provided. Contact the Department.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 427. VLSI (Very Large Scale Integrated) Design I.

Computer Science

Instructor(s): Gordy Carichner

Prerequisites & Distribution: EECS 270 and 311. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/courses/eecs427/

his course introduces mask level integrated circuit design. This is a senior/graduate level project-oriented course in which the students design a simple 16-bit, 2-stage pipelined RISC microprocessor. Weekly CAD assignments will be in the form of design of the cells for the processor. Extensive use of commercial CAD tools is required. Within constraints of available funding, eligible projects will be fabricated through the MOSIS service.

The Lab/Disc. time will be used primarily for discussing project-related assignments, quizzes and occasionally for catching up on lecture material. Otherwise, all "lab" time is unscheduled - you'll be doing the majority of your design work in the CAEN labs on your own time.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 470. Computer Architecture.

Computer Science

Instructor(s):

Prerequisites & Distribution: EECS 370. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/~tnm/470/home.htm

Course Synopsis: EECS 470 is an introductory graduate-level course in computer architecture. This course is intended to do two things: to give you a solid, detailed understanding of how computers are designed and implemented, including the central processor and memory and I/O interfaces; and to make you aware of the numerous tradeoffs in design and implementation, their interaction, their realization in both historical and state-of-the-art systems, and trends that will affect them in future systems. We will cover instruction set architectures, pipelining (including basic pipelining, multiple-instruction-per-cycle machines, out-of-order instruction execution, and vector processing), memory systems (including caches and virtual memory), I/O interfaces, operating system issues, and basic multiprocessor systems. We will also do case studies on microprocessors and systems you may have used, such as the P6 (Pentium Pro/II/III), and Pentium 4. A central part of EECS 470 is the detailed design of major portions of a substantial processor using the Verilog hardware design language (HDL). Portions of this work will be done individually as homeworks; the bulk of the work will be done in groups of four as a term project. You will use modern commercial CAD tools to develop your design. This project represents a significant investment of time on your part, and is a significant portion of your grade in this class. However, in computer architecture it is particularly true that "the devil is in the details", and you will gain important experience and knowledge by coming face to face with that devil. Textbooks: 1. Computer Architecture: A Quantitative Approach, 3rd edition, by Hennessy and Patterson, Morgan Kaufman Publishers. If you can find a used version, I would suggest buying it. The second edition is ok, but you must be responsible for the the fact that references to the "text book" refer to the third edition. 2. Optional: Verilog Styles for Synthesis of Digital Systems, 1st edition, by Smith and Franzon, Prentice Hall.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 478. Logic Circuit Synthesis and Optimization.

Computer Science

Instructor(s): John Patrick Hayes

Prerequisites & Distribution: EECS 270 and 203, and senior or graduate standing. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/478/001.nsf

This is an advanced course in logic design that focuses on computer-aided design (CAD) methods for synthesis and optimization. The topics to be covered include: Advanced design of logic circuits. Technology constraints. Theoretical foundations. Computer-aided design algorithms. Two-level and multilevel optimization of combinational circuits. Optimization of finite-state machines. High-level synthesis methods: modeling, scheduling, and binding. Verification and testing.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 481. Software Engineering.

Computer Science

Instructor(s):

Prerequisites & Distribution: EECS 281. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

No Description Provided. Contact the Department.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 482. Introduction to Operating Systems.

Computer Science

Instructor(s): Brian Noble (bnoble@umich.edu)

Prerequisites & Distribution: EECS 370 and 281. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/~bnoble/482/

Course Overview: EECS 482 is an introductory course in operating systems at the advanced undergraduate or beginning graduate level. The objective of the course is to familiarize you with the issues involved in the design and implementation of mod-ern operating systems. The concepts in this course are not limited to any particular operating system or hardware platform. We will discuss examples that are drawn from historically significant and modern operating systems in-cluding MULTICS, UNIX, Mach, and Windows NT. We will cover topics such as processes and threads, concur-rency and synchronization, CPU scheduling, virtual memory management, communication in distributed systems, secondary-storage management, file systems, and security. To help you understand operating systems, you will implement several modules that form much of the core func-tionality in modern operating systems. These projects will give you practical exposure to topics such as threads, vir-tual memory management, client-server systems, and file systems. We will also provide practice questions that will be discussed in the discussion sections; you can use these to help gauge your understanding of the material as the course progresses.

Prerequisites: Students must have obtained a grade of C or better in EECS 370 and EECS 281/380. Students are expected to un-derstand computer architecture and data structures, to have extensive C/C++ programming experience, and to be familiar with UNIX. Students with questions about whether they have sufficient preparation for this course should speak with the instructor as soon as possible.

Required Textbook: Modern Operating Systems (2nd ed.), Andrew S. Tanenbaum, Prentice Hall. ISBN 0-13-031358-0

Other Course-Related Resources

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 484. Database Management Systems.

Computer Science

Instructor(s): Viviane Jensen

Prerequisites & Distribution: EECS 380. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://coursetools.ummu.umich.edu/2003/winter/eecs/484/001.nsf

EECS 484 provides basic introduction to relational database management systems (DBMSs). This course is designed to provide you with both an external and an internal view of relational DBMSs. Topics related to the external view will cover concepts that will allow you to use a relational DBMS. Topics related to the internal view will allow you to better understand how a relational DBMS works, making you more sophisticated (and perhaps higher paid) database users/administrators.

The course has a group course project in which you will build a simple, but fairly complete, single-user relational database engine. Note, in this course you will not learn the details of how to use any specific commercial database system, or the intricacies of SQL programming. This course is designed to cover the fundamental database concepts and the implementation techniques that are used in relational database engines. Using the course project, you will actually build a few key components of a database engine.

If you are interested in the details of SQL programming, or the operation of a specific commercial database system, you will be able to pick this up very easily after you have taken this course.

Prerequisites EECS 281: Data Structures and Algorithms or equivalent. WARNING: The course project is programming intensive and requires that you be comfortable programming in C++. For most of you, the course project will be the largest and most complex software project that you have built so far. If you are not comfortable programming in C++, you should take a lower-level course to build these skills, and take 484 in a later semester.

Text Database Management Systems (3rd edition) - by Raghu Ramakrishnan and Johannes Gehrke, McGraw Hill.

Course Format and Approximate Grading Exam 1, February 19 Time TBA (maybe evening) 24%

Exam 2, April 16 Time TBA (maybe evening) 24%

Quizzes: Three to four 20-30 minutes in-class quizzes (lowest score will be dropped not make-up quizzes under any circumstances) 6% total

SQL Assignment: Individual SQL assignment. 10%

Group Project: The group project involves building a simple relational database engine, Minirel 2000. We will provide you a skeleton framework of this database engine, and in a sequence of four assignments you will fill up this framework to build a simple relational database engine. You can form your own groups (of 3). 36% total

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 485. Web Database and Information Systems.

Computer Science

Instructor(s):

Prerequisites & Distribution: EECS 484. Permission of instructor required. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

No Description Provided. Contact the Department.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: 5, Permission of instructor

EECS 486. Object-Oriented Methodology.

Computer Science

Instructor(s): David R. Chesney

Prerequisites & Distribution: EECS 281. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/courses/eecs486/win03/

The course will first study characteristics that make an object-oriented (OO) language object-oriented, such as abstraction, encapsulation, polymorphism, inheritance, generalization, and reusability. The focus of the class is using a design methodology to develop software in an OO language. Therefore, expressive notations that describe OO language characteristics are needed. Both Object Modeling Technique (OMT) and Unified Modeling Language (UML) are such expressive notations, and both will be described in the course. The notations related to system structure, architecture, and behavior will be thoroughly described. The methodology will be applied to a semester project, such as a requirements and design analysis. Finally, current industry-standard OO languages may be reviewed.

Instructional Objectives Draw, understand, and critique an individual descriptive diagram in the appropriate context. Map between related diagrams and incorporate the interplay into system understanding. As an example, the student should be able to map the following sequence of UML diagrams: scenario, sequence diagram, collaboration diagram, object diagram, class diagram. Decompose a moderately complex system and completely describe its implementation in terms of object-oriented characteristics. Both requirements and design of the system may be described. Use a current PC- or workstation-based tool (e.g., Visio 2000 Professional) to decompose a system in an industry standard specification language, such as UML and OMT. Work within a group of 2-4 persons to complete jointly established goals.

Grading Homework 10% Midterm Exam 25% Final Exam 25% Project 1 Documentation 5% Project 1 Implementation 5% Project 2 Proposal and Requirements Draft 5% Project 2 Requirements Document 10% Project 2 Design Document 10% Project 2 Implementation 5%

Text Books Required: Developing Software with UML, Object Oriented Analysis and Design in Practice, Bernd Oestereich, Addison Wesley, 2001, ISBN 0-201-75603-X.

Reference: The Unified Modeling Language User Guide, Grady Booch, James Rumbaugh, and Ivar Jacobson, Addison Wesley Longman, 1999, ISBN 0-201-57168-4.

The Unified Modeling Language Reference Manual, James Rumbaugh, Ivar Jacobson, and Grady Booch, Addison Wesley Longman, 1999, ISBN 0-201-30998-X.

Using UML, Software Engineering with Objects and Components, Rob Pooley and Perdita Stevens, Addison Wesley Longman Limited, 1999, ISBN 0-201-36067-5.

Instant UML, Pierre-Alain Muller, Wrox Press Ltd., 1997, ISBN 1-861000-87-1.

Programming Languages Design and Implementation 3rd Edition, Terrence Pratt and Marvin Zelkowitz, Prentice Hall, 1999, ISBN 0-13-678012-1.

Java How to Program, Deitel & Deitel, Prentice Hall, 1997, ISBN 0-13-263401-5.

UML Explained, Kendall Scott, Addison Wesley, 2001, ISBN 0-201-72182-1.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 487. Interactive Computer Graphics.

Computer Science

Instructor(s): Jon Harris (harrisjw@umich.edu)

Prerequisites & Distribution: EECS 281 and senior standing. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/courses/eecs487/w03/index.html

The course will have four major focus areas:

Mathematics for Computer Graphics
This includes the representation and manipulation of points, lines, planes, and vectors; 2-D and 3-D coordinate transformations, and their representation as matrices; 3-D viewing and perspective.

Geometric Modeling
Includes the modeling hierarchy, facets, polygons, curves, splines, and solids models (combinatoric solid geometry CSG).

Rendering
Including scan line and ray tracing techniques, camera models, illumination and reflection models for surfaces, shadowing, texture mapping, and anit-aliasing.

Applications
Graphical User Interfaces, Visualization, Animations

Familiarity with simple trigonometry and linear algebra concepts will make the course material easier to understand and comprehend. Likewise, familiarity with object oriented programming techniques is a plus in developing programs driven by graphical user interfaces.

Programming exercises will use the C (or C++) language for general-purpose programming and OpenGL for 3-D graphics. We will review OpenGL in class and discussion; you are assumed to know C or C++. Extensive information about OpenGL is available on the web. Check the class web page for links.

You will undertake written assignments and programming assignments to explore and increase your understanding of the concepts covered in this course. Grading and Exams: Final course grades will be based on the total points earned on the homework, computer programming projects, and the two exams.

Class Text: (Required) Computer Graphics; Donald Hearn, M. Pauline Baker Source Code Link: http://www.ncsa.uiuc.edu/Vis/Graphics/code.html (Recommended) Computer Graphics using Open GL; F.S Hill, Jr. Source Code Link: http://cwx.prenhall.com/bookbind/pubbooks/hill4/chapter0/deluxe.html

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 489. Computer Networks.

Computer Science

Instructor(s):

Prerequisites & Distribution: EECS 482. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://devon.eecs.umich.edu/

If you want to learn how to design way-cool Web pages, how to build and maintain a killer Web site, or how to setup, administer, and engineer a LAN, this course is not for you. In this course we do not study how modems work, nor do we study how ISDN works. We do not study Novell Netware Administration and we do not learn how to use Adobe Photoshop. We do not learn how to set up a chat room, nor how to set up an electronic guest book. We do try to understand how networks operate and how network applications are written. We study the workings of the Ethernet and the Internet: how packets are routed, how packets are transmitted, and what to do when there is network congestion. We look at packet headers and routing and transmission protocols. We learn how to use sockets. And we write code. We write code to implement various routing and transmission protocols. We write code to build client-server applications. There will be a lot of programming. You should know what processes and threads are and be familiar with concurrency and interprocess communication. EECS 482 (Introduction to Operating Systems) is a strict prerequisite. You must also have good working knowledge of C and UNIX. An introduction to probability course such as EECS 401, EECS 501, Math 425, Math 525, or Stat 412 is highly recommended as a co-requisite.
Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.


EECS 492. Introduction to Artificial Intelligence.

Computer Science

Instructor(s): Satinder Baveja

Prerequisites & Distribution: EECS 281. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

The purpose of this course is to introduce the student to the major ideas and techniques of Artificial Intelligence, as well as to develop an appreciation for the engineering issues underlying the design of intelligent, computational agents. The successful student will finish the course with specific modeling and analytical skills (e.g., search, logic, probability), knowledge of many of the most important knowledge representation, reasoning, and machine-learning schemes, and a general understanding of AI principles and practice. The course will serve to prepare the student for further study of AI, as well as to inform any work involving the design of computer programs for substantial application domains.

Topic Overview of AI; Intelligent Agents; Solving Problems by Searching; Informed Search and Exploration; Constraint Satisfaction Problems; Adversarial Search; Logical Agents; First-Order Logic; Inference in First-Order Logic; Knowledge Representation; Planning; Planning and Acting; Review of Probability/Statistics; Uncertainty; Probablistic Reasoning; Probablistic Reasoning over time; Decision Making; Learning from Observations; Knowledge in Learning; Statistical Learning; Reinforcement Learning; Probablistic Language Processing; Philosophical Issues.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 493. User Interface Development.

Computer Science

Instructor(s): David Kieras (kieras@umich.edu)

Prerequisites & Distribution: EECS 281. Fluency in a standard object-oriented programming language is assumed. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.engin.umich.edu/class/eecs493/html/index.html

Concepts and techniques for designing computer system user interfaces to be easy to learn and use, with an introduction to their implementation. Task analysis, design of functionality, display and interaction design, and usability evaluation. Interface programming using an object-oriented application framework. Fluency in a standard object-oriented programming language is assumed.

Usefulness and usability of software is becoming more critical, as we see hard-to-use e-commerce sites frustrating millions, a monopoly operating systems and its applications in thrall to severe "featuritis," and a brilliant open-source OS floundering under the burden of misguided GUIs that do not solve the fundamental usability problems. This course is intended for advanced undergraduates and graduate students who plan a career in software development in domains where the usefulness and usability of the software is a critical design goal. The ideal student is a good programmer who has done some significant application programming and is now ready to focus on getting a good design of the software and its interface rather than simply getting code to work. The emphasis of the course will be on learning and applying modern concepts and techniques for user interface design and evaluation, along with an introduction to how GUIs can be programmed to implement usable designs. Within very broad limits, students will be able to use a user interface toolkit, platform, and programming language of their choice, but background in object-oriented C++ techniques is assumed as the "common language" for discussion in the course. Past experience both with this course, and industry experience in general, is that GUI programming is relatively difficult - there is a mass of details to be nailed down in code that must be well-structured and reliable. So this course is a good choice only for those students who are comfortable with writing and debugging substantial amounts of code, who are able to learn a specific toolkit on their own, and who expect to have time to do this work for this course.

Texts: Dan Olsen. Developing User Interfaces. Morgan-Kaufman, 1998. Don't purchase until you have formally registered for the course! Clayton Lewis & John Rieman. Task-Centered User Interface Design: A Practical Introduction. Internet-distributed shareware publication. Download (plain text, multiple files) from ftp://ftp.cs.colorado.edu/pub/distribs/clewis/HCI-Design-Book. Your choice: Appropriate manuals and documentation for the platform/application framework/language of your choice for the programming projects.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 496. Capstone Design Course in Computing.

Computer Science

Instructor(s): William P Birmingham

Prerequisites & Distribution: Senior standing, and concurrent enrollment in Technical Communication 496 and one of the approved 400-level team project courses in computing. Prerequisites enforced on Wolverine Access. (2). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (2).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/496/001.nsf

Unlike the other courses in the CSE curriculum, 496/497 is a course where students actually go through the entire lifecycle for a software project, from project conception to user testing and with some luck, even wide scale deployment! The intent behind 496/497 is to provide students with a "real-world" project experience. 496/497 meets concurrently since the faculty felt that both courses were needed in order to fulfill the Major Design Experience (MDE) requirement. We are expecting that a student put in quite a bit of work inasmuch as a student is getting 6 credit hours. Now, a student can still sign up for only 496 or only 497. But a student signing up for only one of the courses must still come to all the classes. Their grade will be based on the requirements for that specific course. The heart the MDE is a team project. This semester teams will be made up of 3-4 students. The project of the team will either be one suggested by the faculty or one of the team's own choosing. It is expected that a team will meet with one of the MDE faculty or GSIs at least 4 times during the semester. Teams will be formed on the second class meeting.

Required Texts 1. Brooks, Frederick The Mythical Man-Month, 20th anniversary edition: Essays on Software Engineering, 1995. 2. Moore, Geoffrey Crossing the Chasm, Harper Collins Publishers Inc., 1999. 3. Smith, Karl Project Management and Teamwork, McGraw-Hill, 2000. 4. Tavani, Herman Ethics in an Age of Information and Communication Technology, Wiley, 2002 (special notes available on the web).

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 497. EECS Major Design Projects.

Computer Science

Instructor(s): Solloway

Prerequisites & Distribution: Senior standing. Prerequisites enforced on Wolverine Access. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/496/001.nsf

See Electrical Engineering and Computer Science 496.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 498. Special Topics.

Computer Science

Section 001 AI in Computer Games. [credits?]

Instructor(s): John E Laird

Prerequisites & Distribution: Prerequisites enforced on Wolverine Access. (1-4). (Excl). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

No Description Provided. Contact the Department.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 498. Special Topics.

Computer Science

Section 002 Real-Time Rendering. [credits?] Meets with EECS 598.006

Instructor(s): Igor Guskov (guskov@umich.edu)

Prerequisites & Distribution: Prerequisites enforced on Wolverine Access. (1-4). (Excl). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/~guskov/eecs498-2/

Even though the class is called Real-Time Rendering, it will cover some relevant graphics modeling techniques as well. EECS 487 is a prerequisite. Basic knowledge of OpenGL programming will be assumed.

Graphics rendering pipeline in detail Advanced lighting, shading Advanced texturing Scene graph topics, culling etc. Non-photorealistic rendering Level-of-detail techniques Collision detection Polygonal techniques Vertex and fragment programs.

The required text is Real-Time Rendering (2nd edition) by Tomas Akenine-Möller and Eric Haines, AK Peters (2002).

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 498. Special Topics.

Computer Science

Section 003 Formal Verification Methods. [credits?]

Instructor(s): Compton

Prerequisites & Distribution: Prerequisites enforced on Wolverine Access. (1-4). (Excl). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/498/003.nsf

An introduction to current methodologies for verifying computer systems. Topics covered include logic and theorem proving; modeling sequential, reactive and concurrent systems; transition systems; model checking methods; and controlling state explosion. Special topics such as temporal logic, the mu-calculus, binary decision diagrams, Buechi automata, partial order reduction, and process algebras will be covered as time permits. Students will complete a project using current model checking technology.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 498. Special Topics.

Computer Science

Section 004 Experimental Algorithms. [credits?]

Instructor(s): Quentin F. Stout (qstout@umich.edu)

Prerequisites & Distribution: Prerequisites enforced on Wolverine Access. (1-4). (Excl). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

The course will allow advanced undergraduates (or graduates) to go beyond standard algorithms classes by pursuing a problem of their interest and implementing algorithms to solve it. Each student (or team) will select a problem area, such as sorting, scheduling, matrix multiplication, intersecting polygons, etc. They will read selected papers on their topic, make class presentations, implement algorithms, and evaluate and improve the algorithms. Some students may pick an area for which exact solutions are available (such as sorting), or may pick an area where heuristics are used, such as solving an NP-complete problem. As part of this, we will also discuss basic issues in experimentally measuring and predicting the performance of algorithms, and in tuning performance. This area is the basis for the new electronic journal, the ACM Journal of Experimental Algorithms, and is one of the up-and-coming areas in the field of algorithms. Since the running time of an algorithm is a random variable, this will require that we address some statistical issues, though no prior statistical background is required. This random behavior has important effects that must be taken into account, yet it is rarely addressed in most computer science courses. Students will be expected to be active participants in the seminar, and most of the presentations will be by students, not the professor. This course can be counted as having 2 credits of engineering design experience. Grading will be based primarily on presentations and reports. As the course progresses, we will use the web to put up summaries and projects, and to keep track of work on experimental algorithms elsewhere. I expect that some students may decide to continue their projects as an REU project or as a directed study.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 498. Special Topics.

Computer Science

Section 005 Natural Language Generation. [credits?]

Instructor(s): Thomason

Prerequisites & Distribution: Prerequisites enforced on Wolverine Access. (1-4). (Excl). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/eecs/courses/eecs498.005/index.html

You need natural language generation when you want to get a computer to produce individually crafted texts and utterances in human language. This course will deal with the computational techniques for doing this effectively. We will ignore the problem of how to take a written text and render it in human speech (this problem is mostly solved, but with a residue of very difficult unsolved problems). Instead, we will focus on how to produce well-structured, effective communicative outputs. This places the emphasis on applications in human-computer dialogues, and puts us in the center of an exciting and rapidly-developing field. By the end of the course, students should be in a position to understand the scientific and technological issues in this area, and to have a sense of how they play out in applications such as intelligent tutoring and task-oriented dialogues.

The first half of the course will be based on the required textbook, and will be concerned mainly with (1) the architecture of typical NLG systems, (2) document planning, (3) microplanning (low-level methods of expressing already-specified content), and (4) surface realization. The second half of the course will use course notes, and will be mainly concerned with issues having to do with interactive dialogue. Students who take this course for credit will be asked to complete three assignments and to plan, execute and report on a (moderately ambitious) project. Typical projects will involve developing and testing a component of a natural language generation system.

REQUIRED TEXT: Building Natural Language Generation Systems, by Ehud Reiter and Robert Dale, Cambridge University Press, 2000.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 498. Special Topics.

Computer Science

Section 006 Radio Frequency Engineering.

Instructor(s): Mortazawi

Prerequisites & Distribution: Prerequisites enforced on Wolverine Access. (1-4). (Excl). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

No Description Provided. Contact the Department.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 498. Special Topics.

Computer Science

Section 007 Cryptography and Security. [credits?]

Instructor(s): Honeyman

Prerequisites & Distribution: Prerequisites enforced on Wolverine Access. (1-4). (Excl). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.citi.umich.edu/u/honey/crypto/

This course introduces the principles and practices of cryptography, network security, and secure software.

The first half of the lecture content covers basic cryptographic methods, key distribution, and protocols for authenticated and confidential communications. Topics include block and stream ciphers, transposition, substitution, Feistel networks, DES, 3DES, IDEA, Blowfish, CAST-128, Rijndael, feedback and chaining modes, confidentiality, traffic analysis, key distribution, random number generation, public key cryptography, RSA, public key certificates, key distribution, Needham-Schroeder protocol, Diffie-Hellman key exchange, one-way hash functions, message authentication codes, weak and strong collision resistance, birthday attack, MD4, MD5, SHA-1, HMAC, digital signatures, mutual authentication, and replay attacks.

The latter half of the lecture content addresses the practice of network security. Topics include Kerberos, PGP, public key infrastructures, SSL, and IP security.

The discussion sections focus on secure software. Topics include risk management, open source vs. closed source, software auditing, buffer overflow, and race conditions.

is course is intended for advanced undergraduate or first-year graduate students. There will be weekly homework assignments, occasional programming assignments, and a midterm and final exams.

Required textbooks (available at online bookstores):

Cryptography and Network Security: Principles and Practice, Third Edition William Stallings ISBN 0130914290 Please take care to purchase the Third Edition.

Building Secure Software: How to Avoid Security Problems the Right Way John Viega and Gary McGraw ISBN 020172152X

Supplementary textbooks (on reserve and available at online bookstores)

Applied Cryptography: Protocols, Algorithms, and Source Code in C, Second Edition Bruce Schneier ISBN 0471117099

Cryptography: Theory and Practice, Second Edition Douglas Stinson ISBN 1584882069

Handbook of Applied Cryptography Alfred J. Menezes, Paul C. Van Oorschot, Scott A. Vanstone (Editor) ISBN 0849385237 (free download available online)

Network Security: Private Communication in a Public World, Second Edition Charlie Kaufman, Radia Perlman, Mike Speciner ISBN 0130460192

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 498. Special Topics.

Computer Science

Section 009 Dev. Educational Software for

Instructor(s): Soloway

Prerequisites & Distribution: Prerequisites enforced on Wolverine Access. (1-4). (Excl). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

No Description Provided. Contact the Department.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 499. Directed Study.

Computer Science

Instructor(s):

Prerequisites & Distribution: Senior standing in EECS. Prerequisites enforced on Wolverine Access. (1-4). (Excl). CAEN lab access fee required for non-Engineering students. (INDEPENDENT). May be repeated for credit.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

No Description Provided. Contact the Department.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 571. Principles of Real-Time Computing.

Computer Science

Instructor(s):

Prerequisites & Distribution: EECS 470 and 482. (3). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (3).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/571/001.nsf

Real-time computing (RTC) is a crucial discipline of study as computational systems are being depended upon in increasingly time-critical applications such as multimedia, virtual reality, telecommunications, industrial automation, embedded commercial and defense systems, medical instrumentation, and life-support systems. This course is intended to provide a solid introduction to the foundations of RTC. While examples and case studies may be considered at times, the emphasis of the course is on principles rather than particular applications. This course will provide students with a firm grasp of the fundamentals of RTC, expose students to some of the state-of-the-art research and development activities in this field, and give students an opportunity to do a small amount of research and development on their own.

Real-time computing (RTC) is a crucial discipline of study as computational systems are being depended upon in increasingly time-critical applications such as multimedia, virtual reality, telecommunications, industrial automation, embedded commercial and defense systems, medical instrumentation, and lifesupport systems. This course is intended to provide a solid introduction to the foundations of RTC. While examples and case studies may be considered at times, the emphasis of the course is on principles rather than particular applications. This course will provide students with a firm grasp of the fundamentals of RTC, expose students to some of the state-of-the-art research and development activities in this field, and give students an opportunity to do a small amount of research and development on their own.

Course Topics: Background, motivation, and definition of real-time computing; Characterization of real-time computing systems: performance measures and deadlines; Estimation of execution time of real-time tasks, and evaluation of the system's ability to meet deadlines; Task assignment and scheduling to meet deadlines, principles, and examples; Real-time databases and their applications ; Real-time communications: protocols and end-to-end delay guarantees, and their implementation; Fault-tolerance and evaluation techniques for real-time systems: models, algorithms and architectures for error detection, fault isolation, and recovery; Real-time artificial intelligence (separate reading).

Course Materials: The required text for the course is Real-Time Systems by Krishna and Shin, McGraw-Hill 1997.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 573. Microarchitecture.

Computer Science

Instructor(s):

Prerequisites & Distribution: EECS 470. (3). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (3).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

No Description Provided. Contact the Department.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 581. Software Engineering Tools.

Computer Science

Instructor(s):

Prerequisites & Distribution: EECS 481 or equivalent programming experience. (3). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (3).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: No homepage submitted.

No Description Provided. Contact the Department.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 583. Programming Languages.

Computer Science

Instructor(s): Scott Mahlke

Prerequisites & Distribution: EECS 376 and 483. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: http://www.eecs.umich.edu/~mahlke/583w03

An in-depth study of compiler backend design for high-performance architectures. Topics include control-flow and data-flow analysis, classical optimization, instruction scheduling, and register allocation. Advanced topics include memory hierarchy management, optimization for instruction-level parallelism, modulo scheduling, predicated and speculative execution. The class focus is processor-specific compilation techniques, thus familiarity with both computer architecture and compilers is recommended.

Prerequisites: Strong C++ programming skills (EECS 281), good background in computer architecture (EECS 370 at minimum, EECS 470 is desirable), basic familiarity of compilers (EECS 483 is useful but not required)

Grade Midterm Exam - 30% Project - 35% Homeworks - 20% Paper presentation 7.5% Class participation 7.5%

References: Compilers: Principles, Techniques, and Tools, Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman, Addison-Wesley, 1988. Advanced Compiler Design & Implementation, Steven S. Muchnick, Morgan Kaufmann, 1997. Building an Optimizing Compiler, Robert Morgan, Butterworth-Heinemann,1998.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 592. Advanced Artificial Intelligence.

Computer Science

Instructor(s): Michael P Wellman

Prerequisites & Distribution: EECS 492. (4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May not be repeated for credit.

Credits: (4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/592/001.nsf

Advanced topics in Artificial Intelligence. Intended as preparation for research in the field. Coursework will comprise extensive reading, research and writing assignments, quizzes, and a final project.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 598. Special Topics in Electrical Engineering and Computer Science.

Computer Science

Section 001 Mobile and Pervasive Computing. [credits?]

Instructor(s): Jason Flinn

Prerequisites & Distribution: Permission of instructor or advisor. (1-4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/598/001.nsf

This course covers advanced topics and current issues in mobile and pervasive computing. The objective of the course is threefold. First, it will expose you to many of the important prior results in the field. Second, it will illustrate current trends in mobile and pervasive computing. Third, it will give you practical experience in the area through the design and execution of a modest research project.

Intended Audience This is a graduate-level course; it is meant primarily for EECS graduate students, particularly those with a research interest in software systems. The prerequisite for the course is a strong undergraduate course in operating systems, equivalent to EECS 482. Undergraduates and graduate students from other departments should speak with me before deciding to take this course.

Course Requirements The work of this course consists of: Reading, analyzing, and actively discussing papers; As part of a team, designing a semester-long project, carrying it out, and writing up the results; Taking a final exam that will occur during the last week of class.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

EECS 598. Special Topics in Electrical Engineering and Computer Science.

Computer Science

Section 006 Real-Time Rendering. [credits?] Meets with EECS 498.002.

Instructor(s): Igor Guskov (guskov@umich.edu)

Prerequisites & Distribution: Permission of instructor or advisor. (1-4). (Excl). (BS). CAEN lab access fee required for non-Engineering students. May be repeated for credit. May be elected more than once in the same term.

Credits: (1-4).

Lab Fee: CAEN lab access fee required for non-Engineering students.

Course Homepage: https://coursetools.ummu.umich.edu/2003/winter/eecs/498/002.nsf

See Electrical Engineering and Computer Science 498.002.

Check Times, Location, and Availability Cost: No Data Given. Waitlist Code: No Data Given.

Graduate Course Listings for EECS.


Page


This page was created at 11:28 AM on Thu, Feb 6, 2003.


lsa logo

University of Michigan | College of LS&A | Student Academic Affairs | LS&A Bulletin Index

This page maintained by LS&A Academic Information and Publications, 1228 Angell Hall

Copyright © 2003 The Regents of the University of Michigan,
Ann Arbor, MI 48109 USA +1 734 764-1817

Trademarks of the University of Michigan may not be electronically or otherwise altered or separated from this document or used for any non-University purpose.