The Computer Science department is based at 2063 Kemper Hall.

It offers two B.S. degrees: one in Computer Science, which is given by the College of Letters and Science, and one in Computer Science Engineering, given by the College of Engineering, as well as a 24-unit minor. CS majors are allowed more freedom in the courses they take, as, unlike Engineering majors, they do not have almost all 180 units planned out for them. They also don't have to take any Communication or English classes. The primary difference between the majors is that the CSE major focuses significantly more on software/hardware interactions, while the CS major is more software-oriented. They are very similar otherwise.

Current Faculty

An incomplete list — add the members you know of

Departmental Resources

The Difference Between Computer Science and Computer Science Engineering

The Computer Science Engineering (abbreviated CSE or ECS) major requires taking the Physics 9 series of classes, ECS 160 and also four Electrical Engineering courses:

  • ENG 17 - Circuits
  • EEC 100 - Circuits II
  • EEC 180a - Digital Design
  • EEC 172 - Microcomputer-Based System Design (i.e. Embedded Processors)

If its units were counted the way the College of Letters and Science counts units, it would be 140 units. It requires 33 units of General Eduation classes, which practically speaking means you're going to have to take 36 units because they've eliminated all of the 5 unit GEs except for sociology.

The Computer Science (CS) major is a B.S. in the College of Letters and Science. It requires you to choose from one of three science tracks Bio, Chem or Physics. It also requires a couple more math courses. If you want to learn about Bioinformatics, then do not major in CSE, becasue you won't have room for the Biology that you need to learn Bioinformatics.

  • I am an ECS major, and I found the ENG 17 and EEC 180a to be quite painful. I also found that EEC 180a was almost completely a repetition of things I had learned in ECS 154a and ECS 154b (see below). But EEC172 was a lot of fun, and practically requires these circuits courses as prerequisites. Given the choice again, knowing what I know now. I probably would have chosen CS instead. — KenBloom
  • I had the same experience — I was planning on an EE major until ENG 17. Eventually I ended up in CS. — StephenHudson

Courses

The department's descriptions of these classes are available at http://www.cs.ucdavis.edu/courses/exp_course_desc/index.html

Lower Division

ECS 10 - Basic Concepts of Computing: An introductory programming course intended for non-majors. This course used to teach Pascal,then Java, but they switched to Python sometime in late 2006 or early 2007. If taken with Professor Amenta, you can expect the course to go at a solid pace, and you will get into lots of graphical work.

  • At first I thought this class was interesting but after taking ECS 30 I realized ECS 10 was a huge waste of my time. ECS 30 covers all the same basics of programming that ECS 10 does except in much more detail. You actually get to apply what you learn to algorithms and whatnot. Don't bother with this class. Even if you are 100% new to programming take ECS 30 instead. - John McHugh

ECS 15 - Introduction to Computers: Another introductory course. This one appears to focus more on computers themselves instead of simply using them. If taught by Davis, you'll get a taste of programming in Python. Gives SciEng and Writing GE credit.

ECS 20 - Discrete Mathematics for Computer Science: A fairly simple logic course. Subjects covered include logical proofs, graph theory, and solving of recurrence relations; the kind of math to prepare you for analyzing algorithms in 122A.

  • Easy class if you are good at abstract mathematical concepts. Not you typical lower division math class. Nelson Max is an awesome professor in this class and you will learn a lot! I highly recommend you actually pay attention in this class since the concepts of set and graph theory are important if you are taking ECS 120/122AB. - John McHugh
    • This was a quarter-long torture chamber. Honestly, I didn't feel like I learned much of anything, and classes were boring and difficult. I heard it was easy if you get Sniegowski as a teacher, but Filkov was difficult simply because he was not good at teaching the material. The only thing useful I've gained from it was learning Big-Oh notation.. most of the other things seem to just be intros to upper divisional classes on algorithms and such. Overall I think it could have been a useful class, but I really did not like my teacher. — GiladGurantz
    • I have to disagree (having taken it from Filkov), as I found the class comparatively interesting, if he did perhaps go a bit too slowly over some of the material. Since it was intended as an intro into the math useful for CS, I found it succeeded at that. — AndreyGoder
    • Don't take it with Amenta. Many many people had problems with her. I know everyone that was in that class did not do well that i have talked to. I took it last year. It wasn't that it was hard to learn, but she had problems teaching it. I still don't know how to do inductive proofs corrently. get it with dean snegowski.—MarkMcDermott
    • This class is exceedingly easy, especially if you take it after ECS 30. Dr. Patrice Koehl is easily the best teacher to take this course with. On a side note if anyone has trouble with concepts in this course I'd be happy to help them out. —TusharRawat
    • I have to disagree with the above comment. ECS 30 is absolutely irrelevant to this course— no relation whatsoever. That being the case, I took CS 20 and CS 30 concurrently. If you haven't taken CS 30, don't worry. —TimJ
      • Did you take 30 with Davis? 20 with Koehl? If so, I'm sorry you feel that way. I found the classes, with those professors, very helpful in that order. Also, just noticed, but since you took them concurrently, doesn't my comment not apply to your situation...? —TR
      • I took 30 with Gusfield and 20 with Filkov. I took the classes concurrently, meaning I did not take 20 after 30 like you said. In general, 20 has nothing to do with 30... 30 is a programming course, while 20 is a discrete math (theory) course. You do no programming in CS 20, and no extensive algorithm work in CS 30. No need to apologize, I'm not attacking or anything, just putting it out there for the future students! —TimJ
      • I'm going to have to agree with Tim here, though I'm sure it depends upon what teachers you have. Together though, the two are great preparation for CS 40 and 60 (of course, being requirements). I also had Gusfield for 30 and Filkov for 20 (took it at the same time as Tim). I found Filkov to be an enjoyable and effective teacher —AndrewHarrison

ECS 30 - Introduction to Programming and Problem Solving: This is the first real programming course, normally taught in C. If you're lucky you'll have Sean Davis, Dave Buscaglia or Dean Sniegowski as your professor. It covers basics such as control structures, operators, functions, arrays, strings, and pointers. Buscaglia also goes over linked lists and such, plus has been known to make his students write a set of programs akin to tar.

  • First two weeks spent on how to use Unix so that you can do your programming assignments in it. Then most of the course just goes through the basics of programming: loops, conditional statements, etc. etc. Decent difficulty for beginners.. I started early on assignments and had no problems at all, although it seemed that non-CS majors would wait and suffer a little. By the time pointers are introduced some people start having problems, but overall if you're a CS major this class should not be a problem (at least, if you're taking it with Sniegowski). — GiladGurantz
  • I agree with the above. A good lecturer is Sean Davis. He's a hard teacher, but you'll know your stuff at the end. As long as you put a decent effort into the programs you won't really need to study for tests. I studied 30 minutes total and got a 91% on the final - and I was not the best in the class, by far. Easy class compared to ECS 40. —TusharRawat
  • Simple programming. If you have any programming experience, the book is mostly a reference and is where all the homework comes from. Unless programming concepts are new to you, this is a class that you don't really need to work that hard on. An hour or two once a week for homework, but no conceptually challenging problems at all. Lectures are fairly straightforward coverage of the textbook, so you can get some of the homework out of the way in class. —StephenHudson
  • I just finished TAing for Sean Davis for Summer Session 1 and I definitely recommend Sean for this class. His homework is very comprehensive. Each problem tests a different aspect of what you're learning. His tests are pretty good. —SebastianNg
  • Took this class with Bernd Hamann. Thank god I had experience programming going into ECS 30. Hamann is the worst professor I have ever had. He taught ECS 30 using obsolete graphics libraries from 1995 written by some guy who wanted to make the C programming language look as much like Java as possible. Literally a joke of a class. Not only can you not understand this guy but the homework is almost entirely graphics. I'd rather pay $4.5k and graduate a quarter late than ever have to take a class with him again. I got an A+ but that is simply because I knew how to program in C coming into this class. BEWARE! Do not take this guy if you have any intention of going on to ECS 40. - John McHugh

ECS 40 - Introduction to Software Development and Object-Oriented Programming: The logical extension of ECS30 into the realm of C++, this is generally considered a weeder class for the CS department. Students in ECS40 learn about all sorts of object-oriented tomfoolery like inheritance and polymorphism. If taught by Sean Davis, they can expect to make programs with mountains of weird, abstract classes to solve whatever ridiculous task he came up with that particular quarter. You won't sleep much and when you do, you'll have nightmares.

  • I really liked this course, though if you're not willing to put time (LOTS OF TIME) and effort into it, then expect not to do so well. Beginning of the course is also dedicated to learning Unix, but this time it's slightly more advanced so that you can make nifty shell scripts and the like. Programming assignments sometimes took awhile, and usually for the first few weeks you keep building off the same program that gets too complicated. However, towards the end the assignments lighten up slightly, and if you do the assignments the tests tend to not require too much studying. — GiladGurantz
  • This class was very educational, but time-consuming. You develop a more advanced understanding of UNIX, learn C++, and get an introduction to data structures. Following coding standards is a must in this class— you get points taken off for not commenting your code and the likes. Overall a good class, takes lots of time, but not overly difficult— TimJ
  • Somewhat time-consuming, occasionally challenging but mostly just getting used to producing a full-size program that actually works. With Ken Joy, he gives a big scary lecture at the beginning of the quarter that makes it seem like nobody will pass the class without working in large groups to conceptualize the problems, but it turns out not being too difficult. Expect to spend 5-10 hours per week writing and debugging. Although it's probably a good idea to go to lectures, you can get by without attending if you know how to use Google and Wikipedia. —StephenHudson

ECS 50 - Computer Organization and Machine-Dependent Programming: As much as the Professors who teach it may argue the point, this is basically "The Assembly Language Course". Depending on who's teaching it, you'll either code in straight x86 assembly (Norman Matloff) and learn a lot about real computers, or in the MIPS language on a simulator (everyone else) and learn a lot about fake computers. ECS50 is a required prerequisite for most upper division ECS courses, especially the ones that deal with hardware. The alternative is EEC70, but as it is often taught by Wilkens, is a load of crap. Don't go there.

  • Dr. Farrens teaches CUSP for most of the course, touching briefly on MIPS and x86 at the end. —TR

ECS 60 - Data Structures and Programming: Design and analysis of data structures for a variety of applications. Trees, heaps, searching, sorting, hashing, graphs. Extensive programming. This course replaced ECS 110 in Fall 2007. According to Sean Davis, the course content is the same as 110. Indeed, many of his handouts during the Fall 2007 quarter were still titled "ECS 110."

  • Conceptually, this class was very straight-forward for me. The quarter was pretty easy until we got to the challenge programs, where we had to beat his times. I probably spent about 60 hours on both challenge programs. This is the first time I really took advantage of his 5-minute-program-fix-time during OH. I also learned more in this class than any other lower division CS class. Our main programs were writing a Sudoku solver, implementing a BTree, and two challenge programs, one relating to the stock market (matching sellers to buyers and vice versa), and one relating to network flow. —TimJ

Upper Division

ECS 110 - Data Structures and Programming: The next logical extension in the "basic programming" track from ECS40, 110 is the software-side gateway to most upper division ECS courses. The course covers using basic data structures such as arrays, stacks/queues, trees, hash tables for applications like sorting and graph problems. Taking this class with Sean Davis is a lot harder than with any other instructor, as his programs are a lot harder and he grades submitted programs based on their running time. Nevertheless, those who survive Davis usually recommend it as a positive experience in hindsight. This class was replaced by ECS 60 in Fall 2007.

  • This class isn't as programming intensive as ECS 40, though there are some small written homeworks and two write-ups. Neither of the two "challenge" programs were far too difficult (NOTE: these are the programs where you have to beat his times), but I think we got lucky this quarter. I learned a fairly good amount. —GiladGurantz
  • I have to disagree, unfortunately I didn't take this class from Sean Davis, and my instructor did not do a very good job. The challenge programs were really challenging, and my partner and I had to put a lot of time into it. My group was the only group that even tried the very last program in the class. We obtained 37/50 points, and everyone else got 0's in the class. — Roozbeh

ECS 120 - Introduction to the Theory of Computation: THE ABSOLUTE MOST THEORETICAL COURSE in the CS department. No programming whatsoever. Students work their way from state diagrams to turing machines, finally ending with the question of decidability on a turing machine and its implications for algorithms on physical computers. Difficulty of the coursework can vary greatly by professor, as some require rigorous proofs while others are content if students just learn the core concepts.

  • Took this class with Professor Filkov. Really interesting, but also really hard too. Probably the hardest class I have taken in the CS department — SebastianNg

ECS 122A - Algorithm Design and Analysis: The second most theoretical course in the CS department. Analyze and design algorithms for problems like sorting, searching and graph traversal, and get introduced to the world of NP/NP-complete problems. Like ECS120, some professors will require more rigor than others. Students can expect a nauseous reaction upon having to sit through the same two weeks of sorting algorithm nonsense that they were likely already exposed to in ECS30, ECS110, and to a lesser extent 20 and 40.

  • I had professor Franklin for this class, there's no programming, lectures were boring, but it's an easy A. — Roozbeh
  • Dr. Martel is an extremely good lecturer for this course. The material is somewhat dense but the class itself is straightforward. — TR
  • Professor Gusfield was rather disorganized. Lectures were pretty hard to follow at times, but were interesting. No programming assignments - heavily theoretical class. You learn about a few very impressive/ingenious algorithms, such as the Z-Algorithm for string matching. — MysticHLE

ECS 122B - Algorithm Design and Analysis: This class is the sequel to 122A. According to the 2008-2010 course catalog, this class covers "Theory and practice of hard problems, and problems with complex algorithm solutions. NP-completeness, approximation algorithms, randomized algorithms, dynamic programming and branch and bound. Students do theoretical analysis, implementation and practical evaluations. Examples from parallel, string, graph, and geometric algorithms."

  • Was taught by Prof. Martel. Used the same book as 122A and was pretty much a continuation course. Depending on 122A prof, repeat of P/NP and approximation algorithms as. EdmundYan

ECS 124 - Theory and Practice of Bioinformatics: First two weeks of the quarter cover learning Perl and exploring alignment software. Then you move onto better ways to find the optimal alignment of a sequence (i.e. not using brute force), and explore algorithms like Smith-Waterman, and you also learn about dynamic programming. Class is more theoretical than practical, and there is an assumption that you've dealt with tools such as BLAST before.

  • Dr. Gusfield covers Markov and Hidden Markov models and some statistical analysis as well. Gusfield is well known in the field so if you're interested in Bioinformatics/Computational Biology it's worthwhile to take the course. The material hasn't changed much at all in 6 years. — TR
  • Overall an interesting course, although I felt like I didn't get much practical experience. Like Tushar said, the course material hasn't changed much, but Gusfield is a very smart man. A good primer course in bioinformatics, though I would recommend taking BIT 150 after CS 124 to gain more practical knowledge. — TimJ

ECS 130 - Introduction to Scientific Computation Course is focused on learning about algorithms that are used in scientific community such as interpolation, curve fitting, solving linear equations, quadrature, eigenpair calculations, SVD, etc... You also learn about implementation problems. The class is a mix of engineering 6 and Math 22A/67/167/128ABC. Programming is done in Matlab.

ECS 132 - Probability and Statistical Modeling for Computer Science: First offered in Winter 2008, this class is the CS equivalent to STA 131A; this class provides an introduction to popular models of probability and statistics. Students start at the basic one-variable discrete models and progress to multivariate continuous models. This class (since 2009) is a requirement for ECS majors; an elective for CS majors.

  • Norm Matloff teaches this course. One of the harder courses offered by the CS department, it's completely worth it. —TR
  • Took this course with Professor Matloff - pretty much your private school-quality professor teaching at the public university. To some people, he may talk a bit slow...but if you are patient and really care to learn the stuff, this class is for you. You are presented with lots of challenging and practical probability problems (makes STA 32 midterms/final exams look like jokes). Best $20 (from Bookstore) I've ever spent on any textbook. No regrets taking this class whatsoever. =) —MysticHLE

ECS 140A - Programming Languages: A somewhat nasty crash-course through several programming languages. Lecture and Lab are almost entirely disjoint for this one: you'll be expected to learn the languages on your own because what's covered in lecture is mostly the abstract concepts behind them. Typical languages covered are C++, Java, LISP and Prolog. Olsen is a pretty good prof and lets you use older versions of the texts, but will make you buy the packaged photocopied notes from the bookstore. You'll learn a lot from doing his programming assignments.

  • I took this class with professor Su, the programs arent very challenging nor very time consuming as in ECS40 or ECS110. — Roozbeh
  • Took this class with professor Olsson. Great guy and lecturer. Easy to follow - explains things well. Make sure you know your recursion really well - and be very attentive to details. The professor even came down to the dungeon once to help us on a program...outside of his/TA's office hours! Very difficult final exam, however. "A bullet" would be rather appropriate to describe its element of surprise and difficulty as opposed to "a curved ball." — MysticHLE

ECS 140B - Programming Languages: A continuation of ECS 140A. More exposure to various programming languages and the concepts behind the implementation of their features.

ECS 142 - Compilers: Probably considered the most obscurely technical class in Computer Science, this class teaches you to build a compiler in 5 easy steps. The only class that could conceivably compete for that title would be ECS 150, if its goal was to write an operating system. (1) Understand the language. (2) Lexical Analysis — find the tokens (3) Parse the tokens and determine whether they match the structure of the language (4) Check the semantics of the language (5) Generate code.

This course has been cancelled for 2005-2006 but a petition has been circulating to have it offered.

  • Took this class with Professor Sean Peisert and turned out a lot easier than I thought. The projects are a lot of work, but it really isn't all that bad in terms of difficulty. Tests are pretty straightforward— SebastianNg

ECS 145 - Scripting Languages: First offered in Spring 2005. Mainly focused on Python with small coverage of Perl in the last couple weeks of class. A great, educational class. No word on when it will be offered again.

  • Took it with Prof. Matloff in Spring '09. Excellent class, highly recommend. The class focused on Python and R. —TR

ECS 150 - Operating Systems: An interesting class if you're into this kind of thing, and goes over scheduling processes, semaphores, memory, page tables, etc. This is an easy class if you take it with Wu. He's a nice guy, knows his stuff, and will tell the occasional story/joke plus the occasional slip (blahblahblah where I met my first wife, I mean, ONLY wife, ONLY wife, heh...). His tests however are multiple choice and each question is worth about 2% of your grade. Also, the little boxes on just about each slide of his slide presentations make absolutely no sense until he explains them. And if you don't take notes, the little boxes will make absolutely no sense to you again when you take your printouts to the tests. The best TA ever was Sophie.

  • Professor Wu has taught the class many times, and is very knowledgeable about the material. The programs arent very hard, although the operating system we used was FREEBSD, I personally used VM-Ware, and my FREEBSD crashed a lot, which got kind of annoying. The grading is very fair, and should be an easy A. — Roozbeh

ECS 152A - Computer Networks: An introduction to the lower levels of computer networking. Starting with signaling techniques at the physical layer, and then discussing error correcting techniques and protocols at the link layer, all of the good stuff about TCP/IP is left for ECS 152B.

  • I had professor Ghosal for this class, although I didn't find the class very interesting, I ended up doing research for professor Ghosal. — Roozbeh
  • I would skip this course and just start with 152B. This is not a big programming class. It's more focused on solving high school algebra word problems and memorizing terms. — SebastianNg

ECS 152B - Computer Networks: Rather than going over the concepts of the networking stack, actually gain some experience writing client/server programs and utilizing TCP/IP.

ECS 152C - Computer Networks: Wireless networks.

ECS 153 - Computer Security: An interesting class if you're into that kind of thing. Contrary to what most people might think, this class does not teach you how to hack (sorry). The vulnerabilities used as examples should have been fixed long ago (at least we'd expect so). With an academic view of security, it goes over different security models, spotting bad coding habits, legal issues, Sun Tzu, encryption, authenticating messages, viruses, worms, etc.

ECS 154A - Computer Architecture: An introduction to computer architecture at the logic-gate level. Learn to build flip-flops out of logic gates, and use those flip-flops to build things like registers and ALUs. Content can vary by professor.

  • Professor Farrens is one of the best professor I have had in UC Davis, and he did a great job in this class. The projects were fair and the exams were identical to the practice ones. — Roozbeh
    • I second this. — TR
  • Had professor Ghosal for this class. He was not very fluent in the subject and stuttered a lot. He was hard to follow and often digressed to his field of networks. Easy midterm and final though. Auditing professor Farren's class this quarter, I would much rather have had him. If you're ECS though, you will get an opportunity to revisit most of this stuff in EEC 180A/ECS 154B. — MysticHLE

ECS 154B - Computer Architecture: Computer Architecture on a more macroscopic level than 154A. Use some of the big parts you designed in 154A (registers, ALUs, multiplexers...) to build even bigger things, like simple CPUs. Then pipeline them. It's good fun.

  • This is one of the most time consuming ECS classes ever. The projects took for ever! We had implement a single cycle CPU for our first project, a multi-cycle CPU for the second, and a pipelined cpu for the third, and the it keeps getting harder! The fourth project was a simulation which was pretty easy and straight forward! — Roozbeh
  • Had Prof. Farrens for this. Projects were very challenging but class is amazing if you like Architecture. Projects same as above —TR
  • Had professor Farrens too. He is a good lecturer, but was not very on top of things in terms of class organization. We didn't have a web page set up nor had any homeworks until about 4th week into the quarter, in which he announced that we would have weekly quizzes and told us we would need to design 3 CPUs in the remaining weeks. Work load was quite heavy. Quizzes were open book/notes, midterm and final allowed 1 and 2 sheets of notes (respectively). Class is not to be taken lightly.—MysticHLE

ECS 160 - Introduction to Software Engineering: We spent the first half of the quarter learning how to mathematically specify our programs in a language called Z (Zed), which nobody seems to use. Thereafter, we learned about testing software, formal verification, and symbolic execution as techniques for testing programs and ensuring reliability. We had a rather painful software engineering project specifying and writing a package delivery system (Fall 2004), which required us to learn several technologies (like SQL databases) on our own that are covered in other classes, but those classes aren't required as prerequisites.

ECS 163 - Information Interfaces: The GUI class, a breath of fresh air for those sick of making console programs. This class was intended to focus on the principles of visualizations and the principles of human-computer interaction. Offered for the first time in Spring 2005, the class was composed of two projects: first, to make a program that visualizes a directory structure (most people did a Treemap), second, to form a group of 4 or 5 and make a website. The guidelines for the second project were very loose.

  • The projects in this class were actually fairly educational but Ma is the worst lecturer I've had in recent memory. - TravisGrathwell

  • I don't feel like the class accomplished its goals very well. I think it needs to have some homework assignments that force us to get breadth in our experience, beyond just where we choose to take our projects. One good thought would be to give us a couple dozen examples of bad interfaces and have us explain what's wrong with them. We wound up totally unprepared for our midterm. I personally hope that the TA, Steve Haroz will teach this class next time (he claims to be the usability guy in our department), and that he teaches based on a basic usability text, such as Usability Engineering. — KenBloom

  • ECS 165A - Database Systems: Database design, entity-relationship and relational model, relational algebra, query language SQL, storage and file structures, query processing, system architectures.

    • A straightforward class on the theory and implementation of databases. The language of choice seems to have moved from Oracle to MySQL, although it may depend on the year taught or professor. A lot of students outside of purely Engineering and Computer Science take this course. — TR

    ECS 165B - Database Systems: Advanced database systems: object-oriented and object-relational database systems; distributed and multidatabase systems; advanced database applications: Web-based database access, data warehouses.

    • This is a project class. About 80% of your grade will be in projects. The project will be building a database system from scratch. Make sure your C/C++ skills are decent. Also, if you're taking this with Prof Green, he seems to not like the STL (which is why I added the C part). —SebastianNg

    ECS 166 - Scientific Data Management: Relational databases, SQL, non-standard databases, XML, scientific workflows, interoperability, data analysis tools, metadata.

    ECS 175 - Introduction to Computer Graphics: The gateway to UC Davis' somewhat extensive selection of Graphics Courses, consisting of the 17x series in the undergraduate level and the 27x series on the graduate level. Content varies a LOT by professor. Depending on who's teaching, the workload can be light years above the typical CS class, but some would argue the rewards are greater, because pretty stuff shows up on the computer screen. 175 can be a refreshing experience for a student who's traveled through the ECS30/40/110 track and is sick of being reintroduced to bubble sort. 175 is a classic recruitment class, do well, and you have a good shot at an undergraduate research position.

    OliverKreylos taught this for his first time in Spring 2005 and worked his students to death. Basically they had to implement a full rendering pipeline, ending with hierarchical models and an advanced graphics project of the student's choosing (not unlike ECS275).

  • Took the class with Bernd Hamann in Winter of '07. I remember the times when I was in the lab from opening to closing during the weekend to get work done. It's a lot of work, but it's pretty fun if you're into that sort of stuff. — SebastianNg

  • ECS 177 - Introduction to Visualization: Basics of Volume Data visualization (3d data like CT scans, or fluid simulations). Typically students learn about and implement all of the standard methods: a slicer, an isosurfacer, a direct volume renderer, and some sort of vector field visualizer.

    • This class is terrible. Professor Ma is one of the worst lecturers ever. Everything you learn will be from reading the research papers, not from lecture. While the projects are interesting, they take an ungodly amount of time in order to complete. A component of your project grade is based off of "impressing" Professor Ma. This engendered a very cut-throat atmosphere where students would no longer help each other as this would be helping the competition. - AlexGarbutt
    • Took the class with Professor Amenta. It was a fun class. You do three projects with different groups each time. You have three different visualization projects that deal with different types of Scientific Visualizations. —SebastianNg

    ECS 178 - Introduction to Geometric Modeling: This class is about Non-Uniform Rational B-Spline Surfaces (NURBS). This class is math heavy. It takes the whole quarter, but you eventually learn all the mathematical under pinnings and implement the basics of NURBS. Heavy programming load. Good class for those who want to work on CAD systems or modelling packages.

      This course has been cancelled for 2005-2006, no petition has yet been started. There definitely should be one though.

    • Professor Bernd Hamann taught it winter of 2008.

    ECS 188 - Ethics and the Information Age: CS and CSE require a "Professional Responsibilities/Ethics" class. This fills that requirement. This deals with philosophy of ethics and the ethical issues that may be involved in Computer Science applications.

    • Do not take this class. Take ENG 190 instead. — KenBloom
    • I enjoyed this class. There is more work than is expected of a 3 unit class, but Earl is a nice guy. Easy to talk to. He provided plenty of feedback on the paper and presentation that we gave at the end of the quarter. Thumbs up, - AlexGarbutt
    • I took this class with Professor Franklin. The class consisted of discussions, weekly write-ups, and a term paper/presentation. The discussions were very enjoyable, the readings interesting, and the grading straight-forward. Recommended if you just need a break from the other CS classes.— TimJ
    • I took this class with Professor Rogaway. His expectations are very clear: Do the reading, the quizzes are easy. Participate in discussion. Oh there's a paper and project at the end and a final quiz as well. A good complement to more difficult classes. —TR

    Graduate Courses

    ECS 201A - Taught by Professor Farrens. You take what you learn in ECS 154B and expand upon it. You look into problems like interrupt handling, improving performance by numerous methods like instruction reordering, branch prediction logic, etc... ECS 220 - It was taught by Franklin when I took it. Only theory on complexity, very,very heavy stuff and tough reading. ECS 235 - When taught by Bishop, much like his undergraduate course, and even uses the same book that was written by him, but is heavier on the theory and proofs. 50/50 hw/project. The project is interesting because you get to do whatever you want to do that is security related for the quarter and then write up a report at the end.

    ECS 243 - This class is taught by Kent Wilken in the ECE department. Class is a continuation of ECS 142(Compilers). You definitely don't need to take Compilers to take this one since they are independent to each other. In Compilers, you learn about the front-end of the compiler (basically, taking a program written in a high level language and converting to assembly). In this course, you will be taking the assembly and optimizing it, so that it runs faster. The projects for this course will follow what you learn in class.

    • When I took this course, we were writing a register allocator. Previous times, they were writing a instruction scheduler. —SebastianNg

    ECS 251 - Operating System Models - When taught by Wu, focuses on BSD for examples. Homeworks include creating an antivirus kernel loadable module using clamAV and lots of hackery.

    • "For ecs251 of spring 2011, we will be studying both traditional OS topics (balanced between single OS kernel and distributed system) and some more advanced topics such as online social network (e.g., Diaspora, DavisSocialLinks, Facebook API) and social informatics for OS kernel (e.g., what is the social informatics view of a piece of FreeBSD virtual memory, which might contain, directly or indirectly, network packets/TCP sessions during a period of time). The students should know C really well and ready to self-learn PHP if you don't know it already — sfelixwu"

    ECS 275A - Advanced Computer Graphics - When taught by Staadt: Primary focus on hierarchical scene graph rendering, visibility and occlusion culling, and level of detail techniques for both models and terrain. Discussion of other advanced topics such as image-based rendering, collision detection, shaders, environment mapping, etc. The last 2/5ths of the class was presentations given by students. Final project was to make a game-like program of your choosing that showed off advanced graphic features learned in class. This is a great class to take if you've taken ECS175 and want further motivation to make shiny computer graphics projects.

    ECS 277 - Advanced Visualization - This class is pretty much a continuation of ECS 177. A lot of what you learn in 177 be will completely demolished as you will learn better techniques of visualization. This class seems to be very focused on better ways of interpolating data.

    • I took this course with Bernd Hamann and it was very time consuming. It was a good class and I learned a lot. I would recommend doing a GSR while taking this class. —SebastianNg

    Other Classes required for the major

    ENG 190 - Professional Responsibilities of Engineers: Described here. Fills CS and CSE's "Professional Responsibilities/Ethics" class requirement. This is ECS 188's more useful and practical twin.

    • I don't think you can take this class in place of ECS 188 anymore
      • But you can the other way around, ECS 188 in place of ECS 190. 190 is probably easier though. - TR

    Other Classes that may be of interest to Computer Science majors

    LIN 177 - Computational Linguistics: Can give you GE credit while programming.

    Computer Science Club

    There is also a Computer Science Club for CS students.