| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||

## Comp. Sci. 183/EECS 183. Elementary Programming Concepts.## Instructor(s): Ann Ford (aford@umich.edu)
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 and iteration (decision making, finding maxima/minima, searching, sorting, simulation, EECS/CS 183 is intended for both majors and non-majors in Computer Science, and is not intended for Engineering students. 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 programming language. Currently the language used is C++. In this course you will learn to write programs in the C++ programming language using good style and design. No prior programming knowledge is assumed, however this is not a course in how to usecomputer software such as word processors and world wide web browsers (EECS/CS 181 is such a course). This course is concerned with how to design and write computer software. Six programming projects will be assigned during the term, some of which will require a large time commitment on your part. Many students find the work load in this course to be heavy, especially during the last half of the course. Assignments will begin with simple problems, and the difficulty level and length will increase as the term progresses. The first project will not require you to write a program yourself, but will be a very simple exercise which will familiarize you with our computer system and C++ compiler. Textbook Readings are from GRADING AND EXAMS: Final grades will be based on the total points earned on 6 programming projects and 2 exams. You are expected to take both exams at the scheduled times. If a medical or personal emergency is not involved in your missing an exam, you will receive a zero for that exam. If you anticipate an exam in another course which conflicts with our exam time, you must notify the instructor at least two weeks before the exam date. The exam dates are given at the beginning of the term so that you can avoid scheduling job interviews or other commitments on exam days, hence job interviews etc. are not considered valid reasons for missing an exam.
## Comp. Sci. 203(303)/EECS 203. Discrete Structures.## Section 001.## Instructor(s): Daniel Koditschek (kod@umich.edu)
Introduction to the foundations of discrete mathematics: logic; sets; functions; methods of proof; methods of counting. Introduction to the foundations of computational representation: relations, graphs, matrices. Application to problems in computer science and engineering. Text: Discrete Mathematics and its Appllications by Kenneth H. Rosen Topics: - Logic
- Predicate Logic and Quantifiers
- Sets
- Set Operations
- Functions
- Sequences and Summations
- Growth of Functions
- Methods of Proof
- Mathematical Induction.
- Recursive Definitions
- Recursive Algorithms
- Program Correctness
- Basics of Counting
- The Pigeonhole Principle
- Permutations and Combinations
- Discrete Probability
- Probability Theory
- Generalized Permutations and Combinations
## Comp. Sci. 203(303)/EECS 203. Discrete Structures.## Section 005.## Instructor(s): Mark Brehob (brehob@umich.edu)
Fundamental concepts of algebra; partially ordered sets, lattices, Boolean algebras, semigroups, rings, polynomial rings. Graphical representation of algebraic systems; graphs, directed graphs. Application of these concepts to various areas of computer engineering. Required Reading - Kenneth H. Rosen.
*Discrete Mathematics and Its Applications,*4th Edition, McGraw-Hill. (Web site) - Handouts
## Comp. Sci. 210/EECS 210. Electrical Engineering I.## Section 001.## Instructor(s): Alfred Hero (hero@umich.edu)
Introductory electrical engineering topics: audio signals and their processing; basics of electricity; elementary circuit design and analysis. Frequency content of signals, Fourier series, filtering. Analysis of resistive circuits. Steady-state response of circuits of resistors, capacitors, inductors and operational amplifiers to sinusoidal signals (frequency response). Laboratory experience with electrical signals and circuits. Text: Also Required: - EECS 210 Electrical Engineering I Lab Manual and Study Guide.
- EECS 210 Additional Course Notes.
Purchase these from The Michigan Union Bookstore, 530 South State St., or Grade A Notes at 1100 South University (741-9669). Lab lectures and lab sessions will occur in alternate weeks beginning with a lab lecture during your lab period on the week of Sept. 13. Students must register for a specific lab section, and attendance is required at its specific session. See the Laboratory Manual for lab policies, especially those on page 2, "Any student missing a lab (not present in the lab) with no proper or reasonable excuse will get a "0" grade on that specific lab and will have his/her letter grade reduced by a full letter (for example, A- to B-). Any student missing two labs with no proper excuse will automatically get a failing grade (F) on the entire course.
## Comp. Sci. 210/EECS 210. Electrical Engineering I.## Section 002.## Instructor(s): Wayne Stark (stark@umich.edu)
Introductory electrical engineering topics: audio signals and their processing; basics of electricity; elementary circuit design and analysis. Frequency content of signals, Fourier series, filtering. Analysis of resistive circuits. Steady-state response of circuits of resistors, capacitors, inductors and operational amplifiers to sinusoidal signals (frequency response). Laboratory experience with electrical signals and circuits. Text: Also Required: - EECS 210 Electrical Engineering I Lab Manual and Study Guide.
- EECS 210 Additional Course Notes.
Purchase these from The Michigan Union Bookstore, 530 South State St., or Grade A Notes at 1100 South University (741-9669). Lab lectures and lab sessions will occur in alternate weeks beginning with a lab lecture during your lab period on the week of Sept. 13. Students must register for a specific lab section, and attendance is required at its specific session. See the Laboratory Manual for lab policies, especially those on page 2, "Any student missing a lab (not present in the lab) with no proper or reasonable excuse will get a "0" grade on that specific lab and will have his/her letter grade reduced by a full letter (for example, A- to B-). Any student missing two labs with no proper excuse will automatically get a failing grade (F) on the entire course.
## Comp. Sci. 211/EECS 211. Electrical Engineering II.## Instructor(s): Gabriel Rebeiz (rebeiz@umich.edu)
Introductory electrical engineering topics, continued: basic circuit analysis; elementary transistor and diode circuits. Equivalent transformations of electric circuits. Transient analysis of circuits. Introduction to diode and transistor circuits. Amplifiers, limiters, filters and logic circuits. Laboratory experience with electrical signals and circuits. Book: - Lab and CAD Manuals by Prof. Rebeiz.
- Chapters 3, 5 and 13 on Diodes, MOS Transistors and MOS Digital Circuits from Microelectronics Circuits by Sedra & Smith, Oxford Univ. Press, Fourth Edition.
Course Packs available from Grade A Notes, Ulrich Bookstore, S. University, Tel: 741-9669. (Chapters not yet available.
## Comp. Sci. 270/EECS 270. Introduction to Logic Design.## Section 001.## Instructor(s): Janice Jenkins (jenkins@umich.edu)
This course provides you with a basic understanding of what digital devices are, how they operate, and how they can be designed to perform useful functions. It forms the foundation necessary for the more advanced hardware and software design courses in our curriculum. You will learn about digital design through a combination of lectures, homework, and a hands-on laboratory. The laboratory is an integral part of the course that shows how the theory of digital design learned in lectures is applied in practice to construct real digital systems. Binary and non-binary systems, Boolean algebra, digital design techniques, logic gates, logic minimization, standard combinational circuits, sequential cir-cuits, flip-flops, synthesis of synchronous sequential circuits, PLAs, ROMs, RAMs, arithmetic circuits, computer-aided design. Laboratory includes hardware design and CAD experiments. Required Textbook:
John Wakerly, References (On reserve at the Media Union Library): - J. P. Hayes, Introduction to Digital Logic Design, Addison-Wesley.
- M. Mano, Digital Design, 2nd Ed., Prentice-Hall.
- C. H. Roth, Jr., Fundamentals of Logic Design, 3rd Ed.
- R. H. Katz, Contemporary Logic Design, 1st Ed., Prentice-Hall.
Coursework and Grading Policy Besides attending lectures (which I highly recommend!) you are expected to produce evidence of your performance in this course based on: - Six homework problem sets
- Seven laboratory experiments
- Two 1-hour mid-term exams and one 2-hour final exam
The two 1-hour mid-term exams are scheduled for 7:30-8:30 PM on Friday October 13, and Friday November 17.
## Comp. Sci. 270/EECS 270. Introduction to Logic Design.## Section 002.## Instructor(s): Pinaki Mazumder (mazum@umich.edu)
This course provides you with a basic understanding of what digital devices are, how they operate, and how they can be designed to perform useful functions. It forms the foundation necessary for the more advanced hardware and software design courses in our curriculum. You will learn about digital design through a combination of lectures, homework, and a hands-on laboratory. The laboratory is an integral part of the course that shows how the theory of digital design learned in lectures is applied in practice to construct real digital systems. Binary and non-binary systems, Boolean algebra, digital design techniques, logic gates, logic minimization, standard combinational circuits, sequential cir-cuits, flip-flops, synthesis of synchronous sequential circuits, PLAs, ROMs, RAMs, arithmetic circuits, computer-aided design. Laboratory includes hardware design and CAD experiments. Required Textbook:
John Wakerly, References (On reserve at the Media Union Library): - J. P. Hayes, Introduction to Digital Logic Design, Addison-Wesley.
- M. Mano, Digital Design, 2nd Ed., Prentice-Hall.
- C. H. Roth, Jr., Fundamentals of Logic Design, 3rd Ed.
- R. H. Katz, Contemporary Logic Design, 1st Ed., Prentice-Hall.
Coursework and Grading Policy Besides attending lectures (which I highly recommend!) you are expected to produce evidence of your performance in this course based on: - Six homework problem sets
- Seven laboratory experiments
- Two 1-hour mid-term exams and one 2-hour final exam
The two 1-hour mid-term exams are scheduled for 7:30-8:30 PM on Friday October 13, and Friday November 17.
## Comp. Sci. 280/EECS 280. Programming and Introductory Data Structures.## Section 001 is intended for non-concentrators## Instructor(s): Andrew Morgan (morgana@umich.edu)
Techniques and algorithm development and effective programming, top-down analysis, structured programming, testing, and program correctness. Program language syntax and static and run-time 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.
## Comp. Sci. 280/EECS 280. Programming and Introductory Data Structures.## Section 006 – Section 006 is intended for concentrators.## Instructor(s): Jim Eng (jimeng@umich.edu) , Charles Severance (csev@umich.edu)
Techniques and algorithm development and effective programming, top-down analysis, structured programming, testing, and program correctness. Program language syntax and static and run-time 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. Course Overiew The purpose of this course is to prepare CS and CE majors for the rest of their undergraduate courses. All of the courses which follow this course will simply assume that all students are capable of writing a 3000 line program in a week or so. Students coming into this course will have diverse skill levels. Some students will find the first few weeks of the course to be review while others will feel that the pace is impossible to keep up with. Pre-Requisites The prerequisite for the course is EECS 183, EECS 100, ENGIN 101, or equivalent. The goal is for students to have some familiarity with programming before taking this class. If a student is not already familiar with computers and programming concepts, they should take one of the above courses. A strong high school programming class should also be sufficient. You should be a confident programmer capable of writing 200 line programs given a written specification. Textbook: The exams are scheduled as follows:
## Comp. Sci. 285/EECS 285. A Programming Language or Computer System.## Section 001 – Java## Instructor(s): Sandra Bartlett (bartlett@umich.edu)
Supported programming environment – Java 1.2 using Sun's JDK on Unix - Writing, compiling and running Java programs
- Java syntax
- Object Based programming in Java
- Object Oriented programming in Java
- Java applets
- Java GUI components
- Layout managers
- Images and sounds, animation, and Threads
- Advanced animation, multithreading
- Exception handling
Grades will be based on: - 40% homework assignments
- 30% midterm (1 hour)
- 30% final exam (1 hour) (cumulative)
*Java How to Program*3rd Ed. (recommended, not required) by Deitel and Deitel Publisher: Prentice Hall- Java and the JDK
## Comp. Sci. 285/EECS 285. A Programming Language or Computer System.## Section 002.## Instructor(s): Sandra Bartlett (bartlett@umich.edu)
A course covering a complex computer system or programming language. Programming problems are assigned. Specific languages or systems offered are announced in advance.
## Comp. Sci. 370/EECS 370. Introduction to Computer Organization.## Section 001.## Instructor(s): Peter Chen (pmchen@umich.edu)
Computer organization will be presented as a hierarchy of virtual machines representing the different abstractions from which computers can be viewed. These include the logic level, microprogramming level, and assembly language level. Lab experiments will explore the design of a microprogrammed computer. This course is intended to give you a basic understanding of how computers execute programs. Under-standing
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. EECS 270 taught you the basics building blocks of hardware (flip-flops, gates, Prerequisites: Students must have taken EECS 270 and EECS 280, or have equivalent knowledge of digital logic design and C. You should understand digital design concepts such as multiplexors, gates, boolean algebra, finite-state machines, and flip-flops. You should also understand and be reasonably fluent in programming in C, e.g. using arrays, structures, functions, and pointers. 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 TA can help you during office hours. Course Material:
The required text for the course is Class Projects: Four projects will be assigned during the term, each of which will require a substantial time commit-ment on your part. Many students find the work load in this course to be heavy. 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:
## Comp. Sci. 370/EECS 370. Introduction to Computer Organization.## Section 002.## Instructor(s): Mark Brehob (brehob@umich.edu)
Computer organization will be presented as a hierarchy of virtual machines representing the different abstractions from which computers can be viewed. These include the logic level, microprogramming level, and assembly language level. Lab experiments will explore the design of a microprogrammed computer. This course is intended to give you a basic understanding of how computers execute programs. Under-standing
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. EECS 270 taught you the basics building blocks of hardware (flip-flops, gates, Prerequisites: Students must have taken EECS 270 and EECS 280, or have equivalent knowledge of digital logic design and C. You should understand digital design concepts such as multiplexors, gates, boolean algebra, finite-state machines, and flip-flops. You should also understand and be reasonably fluent in programming in C, e.g. using arrays, structures, functions, and pointers. 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 TA can help you during office hours. Course Material:
The required text for the course is Class Projects: Four projects will be assigned during the term, each of which will require a substantial time commit-ment on your part. Many students find the work load in this course to be heavy. 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:
## Comp. Sci. 380/EECS 380. Data Structures and Algorithms.## Section 001.## Instructor(s): William Birmingham (wpb@umich.edu)
Abstract data types. Recurrence relations and recursions. Advanced data structures: sparse matrices, generalized lists, strings. Tree-searching algorithms, graph algorithms, general searching and sorting. Dynamic storage management. Analysis of algorithms and O-notation. Complexity. Top-down program development: design, implementation, testing, modularity. Several programming assignments. Course Objectives: By the end of the course, you will become familiar with various techniques for estimating program performance, organizing data to allow efficient searching and sorting, and methods for developing efficient algorithms. You will also get critical foundational material for courses on such things as operating systems, compilers, networks, database, artificial intelligence, computer architecture and advanced algorithm design and analysis. While programming plays an important role in this course, this is not a programming course. Rather, our emphasis is on the design and analysis of data structures and algorithms. Course Materials:
Course textbook: Course Requirements Homework Assignments From time to time, we will distribute homework assignments. These assignments are intended to help you master the course material, prepare for exams, and become familiar with topics not covered in class, but which we consider nonetheless important. We will post answers to these assignments on the course web page. The assignments will not be graded. Programming Projects There will be four programming assignments during the term. The assignments will cover material from lecture and discussion. The assignment details will be given in handouts, along with the assignment due date. Remember to turn your work in on time, otherwise you will receive a substantial reduction in your score, or the assignment may not be accepted at all. Grading. The tentative grade breakdown is: Programming Assignments (4) – 55%, Exams (3) – 45%
## Comp. Sci. 380/EECS 380. Data Structures and Algorithms.## Section 005.## Instructor(s): Martha Pollack
Abstract data types. Recurrence relations and recursions. Advanced data structures: sparse matrices, generalized lists, strings. Tree-searching algorithms, graph algorithms, general searching and sorting. Dynamic storage management. Analysis of algorithms and O-notation. Complexity. Top-down program development: design, implementation, testing, modularity. Several programming assignments. Course Objectives: By the end of the course, you will become familiar with various techniques for estimating program performance, organizing data to allow efficient searching and sorting, and methods for developing efficient algorithms. You will also get critical foundational material for courses on such things as operating systems, compilers, networks, database, artificial intelligence, computer architecture and advanced algorithm design and analysis. While programming plays an important role in this course, this is not a programming course. Rather, our emphasis is on the design and analysis of data structures and algorithms. Course Materials:
Course textbook: Course Requirements Homework Assignments From time to time, we will distribute homework assignments. These assignments are intended to help you master the course material, prepare for exams, and become familiar with topics not covered in class, but which we consider nonetheless important. We will post answers to these assignments on the course web page. The assignments will not be graded. Programming Projects There will be four programming assignments during the term. The assignments will cover material from lecture and discussion. The assignment details will be given in handouts, along with the assignment due date. Remember to turn your work in on time, otherwise you will receive a substantial reduction in your score, or the assignment may not be accepted at all. Grading. The tentative grade breakdown is: Programming Assignments (4) – 55%, Exams (3) – 45%
## Comp. Sci. 398/EECS 398. Special Topics.## Instructor(s):
Topics of current interest selected by the faculty. Lecture, seminar, or laboratory.
## CMPTRSC 400/EECS 400/Math. 419. Linear Spaces and Matrix Theory.## Section 001, 003.## Instructor(s): Alexandre I Barvinok (barvinok@umich.edu)
## CMPTRSC 400/EECS 400/Math. 419. Linear Spaces and Matrix Theory.## Section 002, 004.## Instructor(s): J Tobias Stafford (jts@umich.edu)
## CMPTRSC 400/EECS 400/Math. 419. Linear Spaces and Matrix Theory.## Section 005, 006.## Instructor(s): Bruce A Kleiner (bkleiner@umich.edu)
## Comp. Sci. 476/EECS 476. Foundations of Computer Science.## Instructor(s): William Rounds (rounds@umich.edu)
An introduction to computation theory: finite automata, regular languages, pushdown automata, context-free languages, Turing machines, recursive languages and functions, and computational complexity. - Review of discrete math
- Discrete math; introduction to finite automata
- Regular lanuages, NDFA, and DFA
- State equivalence and minimization
- Non-pumping lemma, proofs of nonregularity
- Context-free grammars
- Pushdown automata; closure properties
- Pumping Lemma, Non-CF languages
- Algorithms for CFG
- More algorithms
- Turing machines
- What Turing machines do
- What TMs do NOT and CANNOT do.
- Undecidable problems; reducibility
Texts: - Sipser,
*Introduction to the Theory of Computation,*PWS Publishers - Barwise and Etchemendy:
*Turing's World,*CSLI Publications
## Comp. Sci. 477/EECS 477. Introduction to Algorithms.## Instructor(s): John Meyer (jfm@umich.edu)
Fundamental techniques for designing efficient algorithms and basic mathematical methods for analyzing their performance. Paradigms for algorithm design: divide-and-conquer, greedy methods, graph search techniques, dynamic programming. Design of efficient data structures and analysis of the running time and space requirements of algorithms in the worst and average cases.
## Comp. Sci. 478/EECS 478. Logic Circuit Synthesis and Optimization.## Section 001.## Instructor(s): Marios Papaefthymiou (marios@umich.edu)
This course covers digital logic synthesis and its underlying theory from an advanced perspective. Topics include basic switching and sequential systems and high-level synthesis. Emphasis will be placed on algorithmic techniques that are currently used in the design of integrated systems with millions of transistors. Assignments, Exams, and Grades - Five or six homework assignments (30% of final grade)
- Midterm exam (30%)
- Final exam (40%)
Textbook: Recommended textbook: Supplementary textbook: Both textbooks have been placed on reserve in the Media Union Library.
## Comp. Sci. 481/EECS 481. Software Engineering.## Instructor(s): John Sayler (jhsayler@umich.edu)
Pragmatic aspects of the production of software systems, dealing with structuring principles, design methodologies and informal analysis. Emphasis is given to development of large, complex software systems. A term project is usually required.
## Comp. Sci. 482/EECS 482. Introduction to Operating Systems.## Section 001.## Instructor(s): Donald Winsor (don@umich.edu)
Course Overview: EECS 482 is an introductory course in operating systems at the senior undergraduate level or first-year graduate level. The objective of the course is to familiarize you with the issues involved in the design and implementation of modern operating systems. The concepts in this course are not limited to any particular operating system or hard-ware platform. We will discuss examples that are drawn from historically significant and modern operating systems. We will cover topics such as processes and threads, concurrency and synchronization, CPU scheduling, virtual memory management, communication in distributed systems, secondary-storage management, file systems, and se-curity. In order to more fully understand operating systems, you will implement several projects that expose you to much of the core functionality in modern operating systems. These projects will give you practical exposure to topics such as threads, efficient resource usage, caching, and client-server systems. To further your understanding of other topics, we will provide practice questions that will be presented in the discussion sections. In discussion sections, we will also present material on the practice of programming, including elegance in design and coding, the process of testing and debugging, and how to effectively work in teams. Prerequisites Students must have obtained a grade of C or better in each of EECS 370 and EECS 380, or have equivalent knowl-edge of computer architecture, data structures, and C/C++ programming. Students are expected to have had exten-sive 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 instructors as soon as possible. Due to the over-whelming number of students interested in this course, we will strictly enforce the prerequisites. Course Projects: Four projects will be assigned during the term. These projects will require a substantial time commitment on your part. Many students find the work load in this course to be heavy. However, we expect that effort spent on pro-gramming projects will be conceptual rather than brute-force; none of the projects are excessively large in terms of lines of code. Exams There will be two exams for this course. The second exam will only cover material from the second half of the course; it will not be comprehensive. There will be no final exam. 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 fo-lows: - Projects 40%
- First Exam 30% (October 26)
- Second Exam 30% (December 12)
Reading List:
This course has one required text:
## Comp. Sci. 482/EECS 482. Introduction to Operating Systems.## Section 006.## Instructor(s): Brian Noble (bnoble@umich.edu)
Course Overview: EECS 482 is an introductory course in operating systems at the senior undergraduate level or first-year graduate level. The objective of the course is to familiarize you with the issues involved in the design and implementation of modern operating systems. The concepts in this course are not limited to any particular operating system or hard-ware platform. We will discuss examples that are drawn from historically significant and modern operating systems. We will cover topics such as processes and threads, concurrency and synchronization, CPU scheduling, virtual memory management, communication in distributed systems, secondary-storage management, file systems, and se-curity. In order to more fully understand operating systems, you will implement several projects that expose you to much of the core functionality in modern operating systems. These projects will give you practical exposure to topics such as threads, efficient resource usage, caching, and client-server systems. To further your understanding of other topics, we will provide practice questions that will be presented in the discussion sections. In discussion sections, we will also present material on the practice of programming, including elegance in design and coding, the process of testing and debugging, and how to effectively work in teams. Prerequisites: Students must have obtained a grade of C or better in each of EECS 370 and EECS 380, or have equivalent knowl-edge of computer architecture, data structures, and C/C++ programming. Students are expected to have had exten-sive 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 instructors as soon as possible. Due to the over-whelming number of students interested in this course, we will strictly enforce the prerequisites. Course Projects: Four projects will be assigned during the term. These projects will require a substantial time commitment on your part. Many students find the work load in this course to be heavy. However, we expect that effort spent on pro-gramming projects will be conceptual rather than brute-force; none of the projects are excessively large in terms of lines of code. Exams There will be two exams for this course. The second exam will only cover material from the second half of the course; it will not be comprehensive. There will be no final exam. 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 fo-lows: - Projects 40%
- First Exam 30% (October 26)
- Second Exam 30% (December 12)
Reading List:
This course has one required text:
## Comp. Sci. 483/EECS 483. Compiler Construction.## Instructor(s): Trevor Mudge (tnm@umich.edu)
Introduction to compiling techniques including parsing algorithms, semantic processing, and optimization. Students implement a compiler for a substantial programming language using a compiler generating system. This is a fair description of what we will be covering, but the subject of compiler construction is a large one, and time limitations mean that we will not cover everything mentioned in the description in great depth. The goal will be to introduce the basics of compiler construction with an emphasis on using tools to construct a simple compiler. Homework: Homework will be set on a regular basis. It will not be graded. The solutions will be discussed in class. The homework material will be typical of the questions that will be on the exams. Exams: There will be two written exams, but no final. Projects: The main grade will come from five projects that will require you to write parts of a compiler. Books: There are two books that you should purchase. The first one is a classic, which is often referred to as the dragon or dinosaur book (I think it's a dragon on the cover). - Title:
*Compilers: Principles, Techniques, and Tools*Authors: Aho, Sethi, and Ullman. Publisher: Addison-Wesley Pub Co ISBN: 0201100886 - The second book is:
Title:
*Lex & Yacc*Authors: John R. Levine, Tony Mason, Doug Brown. Publisher: O'Reilly & Associates ISBN: 1565920007
## Comp. Sci. 484/EECS 484/IOE 484. Database Management Systems.## Instructor(s): Jignesh Patel (jignesh@umich.edu)
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 380: 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:
## Comp. Sci. 486/EECS 486. Object-Oriented Software Development.## Section 001.## Instructor(s): David Chesney (chesneyd@umich.edu)
Object-oriented programming concepts such as data and program abstraction, encapsulation, polymorphism, single and multiple inheritance, and reusable objects. Techniques for object-oriented system decomposition and class design. Study and use of class libraries and application frameworks. Programming projects in an object-oriented language currently standard in industry.
## Comp. Sci. 487/EECS 487. Interactive Computer Graphics.## Instructor(s): Jon Harris (harrisjw@umich.edu)
Computer graphics hardware, line drawing, rasterization, anti-aliasing, graphical user interface (GUI), affine geometry, projective geometry, geometric transformation, polygons, curves, splines, solid models, lighting and shading, image rendering, ray tracing, radiosity, hidden surface removal, texture mapping, animation, virtual reality, and scientific visualization.
## Comp. Sci. 489/EECS 489. Computer Networks.## Section 001.## Instructor(s): Sugih Jamin (sugih@umich.edu)
Protocols and architectures of computer networks. Topics include client-server computing, socket programming, naming and addressing, media access protocols, routing and transport protocols, flow and congestion control, and other application-specific protocols. Emphasis is placed on understanding protocol design principles. Programming problems to explore design choices and actual implementation issues assigned.
## Comp. Sci. 492/EECS 492. Introduction to Artificial Intelligence.## Instructor(s): Michael Wellman (wellman@umich.edu)
Fundamental concepts of AI, organized around the task of building computational agents. Core topics include search, logic, representation and reasoning, automated planning, decision making under uncertainty, and machine learning.
## Comp. Sci. 493/EECS 493. User Interface Development.## Section 001.## Instructor(s): David Kieras (kieras@umich.edu)
Usefulness and usability of software is becoming more critical, as we see hard-to-use e-commerce sites frustrating millions, 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 & techniques for user interface design and evaluation. Because this is the first offering under the new description and credit hours, the coverage of interface implementation programming will depend on the background and interests of the enrolled students. Because no TA will be available, the enrollment will be limited and will include only students who have an appropriate background and who will clearly benefit from the course. Thus, instructor's permission is required to register.
## Comp. Sci. 494/EECS 494. Computer Game Design and Development.## Section 001.## Instructor(s): John Laird (laird@umich.edu)
In this course we will study the technology, science, and art involved in the creation of computer games. The course will emphasize hands-on development of games. We will study a variety of software technologies relevant to games including programming languages, scripting languages, operating systems, file systems, networks, simulation engines, and multi-media design systems. We will also study some of the underlying scientific concepts from computer science and related fields including: simulation and modeling, graphics, artificial intelligence, real-time processing, and game theory. Finally, we will study the art and design principles for developing useable and engaging games including: software engineering, human computer interaction, thematic structure, graphic design, choreography, music and sound effects, and game aesthetics. The course will include visiting lectures and a variety of group projects. The group projects will involve system implementation, but emphasize design and use of existing tools. The final group project will require the students to go through all phases of system conceptualization, specification, design, implementation, and evaluation. Required texts:
## Comp. Sci. 499(500)/EECS 499. Directed Study.## Section.
No Description Provided Check Times, Location, and Availability ## Comp. Sci. 543/EECS 543. Knowledge-Based Systems.## Instructor(s): Edmund Durfee (durfee@umich.edu)
Knowledge-based systems (also called just knowledge systems) are sophisticated AI programs that solve
complex problems. These programs have found considerable use in industry, and are finding exciting new
applications in cyberspace The goal of this class is provide students with an understanding of the principles and system-building experience needed to create a knowledge system by introducing the student to programming languages and techniques that promote a knowledge-based, or declarative, approach to software development. Although a rigorous characterization of what this means is elusive (though we will attempt to accomplish this in the course), what it amounts to practically is emphasis on programming constructs that facilitate: - building levels of abstraction and interpretation
- modular specification of functionality
*(e.g.,*object orientation) - representations of propositions and inference
*(e.g.,*logic).
Historically, researchers in the field of Artificial Intelligence have identified these properties as important for development of "intelligent" (whatever that means) programs, and thus have developed languages embodying them. We will explore this "knowledged-based" programming methodology through substantial exercises in three "AI" languages: - Common Lisp (including its object-oriented extension, CLOS)
- Prolog
- SOAR (a problem solving architecture based on production rules)
Successful students will complete the course with a working knowledge in each of these languages, and more importantly, with a broader perspective on programming itself. Textbooks: *Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp*by Norvig (see also here).- PROLOG Programming for Artificial Intelligence by Bratko.
## Comp. Sci. 570/EECS 570. Parallel Computer Architecture.## Instructor(s): Steven Reinhardt (stever@umich.edu)
Pipelining and operation overlapping, SIMD and MIMD architectures, numeric and non-numeric applications, VLSI, WSI architectures for parallel computing, performance evaluation. Case studies and term projects. Course Objectives: - understand the fundamental issues of parallel computation (communication, synchronization, naming,
*etc.)* - understand the various ways in which hardware and software can interact to address these issues in parallel systems
- understand the basic cost, performance, and programmability tradeoffs involved in these interactions
Prerequisites: EECS 470 (Computer Architecture). In particular, you should feel comfortable with caches, virtual memory, dataflow concepts, and instruction-level parallelism.
## CMPTRSC 571/EECS 571. Principles of Real-Time Computing.## Section 001.## Instructor(s): Kang G. Shin (kgshin@umich.edu)
Principles of real-time computing based on high performance, ultra reliability, and environmental interface. Architectures, algorithms, operating systems, and applications that deal with time as the most important resource. Real-time scheduling, communications, and performance evaluation. Textbook: C. M. Krishna and Kang G. Shin,
## Comp. Sci. 574/EECS 574. Theoretical Computer Science I.## Instructor(s): Kevin Compton (kjc@umich.edu)
Fundamentals of the theory of computation and complexity theory. Computability, undecidability, and logic. Relations between complexity classes, NP-completeness, P-completeness, and randomized computation. Applications in selected areas such as cryptography, logic programming, theorem proving, approximation of optimization problems, or parallel computing. Text: Homework is due in class one week after it is assigned. No late homework will be accepted. I will pick one or two problems from each assignment to grade. Your homework score will be based on the best 6 scores (out of 8) throughout the semester. You may work with others in the class on homework and consult any source you like, but the answers you turn in must be written (or typed) in your own hand. There will be three take-home exams handed out in class Oct. 6, Nov. 3, and Dec. 11. They will be due one week after they are handed out. You may use the textbook and course notes on these exams, but no other source. In particular, there may be no collaboration between students on the take-home exams. Grade: Exam 1 28%; Exam 2 28%; Exam 3 28%; Homework (best 6 of 8) 16%.
## Comp. Sci. 579/EECS 579. Digital System Testing.## Section 001.## Instructor(s): John Hayes (jhayes@umich.edu)
This course examines in depth the theory and practice of fault analysis, test generation, and design for testability for digital integrated circuits and systems. The topics to be covered include: circuit and system modeling; fault sources and types; the single stuck-line fault model; fault simulation methods; test generation algorithms for combinational and sequential circuits, including PODEM; testability measures; design-for- testability techniques; scan design; test compression methods; logic-level diagnosis; self-checking circuits; built-in self- testing (BIST); system-level diagnosis; processor and memory testing; VLSI and system-on-a-chip (SOC) testing; design verification and its relation to physical fault testing. A term paper or small experimental/research project will be part of the course. Current research issues, including topics suitable for M.S. or Ph.D. thesis research, will be discussed. Text: Digital System Testing and Testable Design, by M. Abramovici, M. A. Breuer and A. D. Friedman, New York, IEEE Press, 1990. (Required text). Additional reference material will be placed on reserve in the Media Union (Engineering) Library.
## Comp. Sci. 583/EECS 583. Programming Languages.## Section.## Instructor(s): Gary Tyson (tyson@umich.edu)
No Description Provided Check Times, Location, and Availability ## Comp. Sci. 584/EECS 584. Advanced Database Systems.## Section 001.## Instructor(s): H.V. Jagadish (jag@umich.edu)
Survey of advanced topics in database systems. Distributed databases, query processing, transaction processing. Effects of data models: object-oriented and deductive databases; architectures: main-memory and parallel repositories; distributed organizations: data management for emerging areas: Internet applications, OLAP, data mining. Case studies of existing systems. This is an advanced database course that will give you a good understanding of the pieces of a database system and what is involved in building one. I will also try to give you a feeling for the role of databases in today's computing infrastructure and how this has evolved. This is NOT a course on how to use databases, though you will arguably be a better user if you have an understanding of what is going on "under the hood". Also, this is NOT a course on XML, even though XML and the inernet will be mentioned frequently. 2 midterm exams. Both in-class. No make-ups for missed midterm exams. No final exam. Term Project: A course project is required.
## Comp. Sci. 595/EECS 595/Ling. 541. Natural Language Processing.## Section 001.## Instructor(s): Richmond Thomason (rthomaso@umich.edu)
## Comp. Sci. 598/EECS 598. Special Topics in Electrical Engineering and Computer Science.## Instructor(s):
Topics of current interest in electrical engineering and computer science.
## Comp. Sci. 598/EECS 598. Special Topics in Electrical Engineering and Computer Science.## Section 001.## Instructor(s): Demos Teneketzis (teneket@umich.edu)
No Description Provided Check Times, Location, and Availability ## Comp. Sci. 598/EECS 598. Special Topics in Electrical Engineering and Computer Science.## Section 002 – Web Technologies. (credits?) Prereqs: CS 482 or 484.## Instructor(s): Atul Prakash (aprakash@umich.edu)
Provides an overview of the current work on web-related infrastructure and applications. Topics will include the following: - HTTP protocol performance issues; client architecture; web server architecture
- web proxies: Security and performance issues, web caching, data distillation to support mobile web clients
- scalability issues in web servers
- security: cookies, certificates, secure socket layer, secure http, authentication, anonymity, firewalls, safe-guarding web sites against malicious attacks
- XML, server-side technologies such as servlets, JSP, ASP, database/web integration.
- design of web search engines and information filtering/classification
- electronic commerce-related topics
- virtual communities
Grading: This will be a interactive, discussion-oriented class, with both lectures and discussions. The goal is to find out about cutting-edge technologies related to the web and share them with the class. Grading will be based on short quizzes; homeworks; class presentations of assigned readings and project work; and a term project. For the term project, you can work alone or in small groups. A project write-up and and in-class presentation on the project is required.
## Comp. Sci. 598/EECS 598. Special Topics in Electrical Engineering and Computer Science.## Section 003 – Control of Motion in Animals and Machines. (Credits ?).## Instructor(s): Dan Koditschek (kod@umich.edu)
This course will explore the connections between biological and engineering theories of motion control. We will focus on problems of legged locomotion, developing the relevant mechanics models, exploring in that context the efficacy of various biological theories of neural control, and contrasting their explanatory power with various ideas from engineering control theory. Format: There will be twice weekly lectures with reading assignments and a required project. Projects, to be arranged with the instructor's consultation and approval, will involve a combination of - readings,
- numerical or analytical follow on,
- class presentation.
- culminating in a written report according to the individual agreement with the instructor
Pre-requisites: The instructor welcomes all interested students with advanced
This page was created at 3:55 PM on Wed, Dec 13, 2000. 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
© 2000 The Regents of the University of Michigan,
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. |