CIS 501 - Architecture (Offered in Fall)
CIS 505 - Software systems (Offered in Spring)
CIS 502 - Analysis of Algorithms (Offered in Spring)
CIS 511 - Theory of Computation (Offered in Spring)
CIS 500 - Software Foundations (Offered in Fall)
CIS 520 - Artificial Intelligence (Offered in Fall)
Semester: Fall
Homepage: http://www.seas.upenn.edu/~cis500/
Newsgroup: news://upenn.cis.cis500
CIS 500 is a study of type theory. Prof. Benjamin Pierce's book Types and Programming Languages has been used as the text book. The course is heavily based on lambda calculus and inductive proofs. In Fall 2004 it was taught by Stephanie Weirich. Understanding the material really comes from working through examples and proofs, not just from hearing lectures or reading the book, so remember that your teaching assistants and fellow students are good resources, too. Attending recitation, being part of a study group, and going to office hours when necessary can all be very helpful. In the past, the newsgroup has featured more discussion about the course material any other core course's newsgroup has, so plan to read it and be willing to post a message there if you have a question.
Some people consider this WPE-I to be the easiest, others, the hardest. It's pretty hard to understand the material in this course partway, although you might have some problems writing out proofs but still understand the mechanics of the systems being studied pretty well. Often students will either "get it" or not.
Recitations and study groups are a must unless you're a programming languages student already and don't need to be taking the course. If you're in that category, there may be advanced recitations offered to hold your attention, and hopefully there will be opportunities, on the newsgroup or in person, for you to understand the material even better by explaining some of it to others who need help.
Someone from another university told me that this sort of course was a good bit easier the second time. I found that to be true, so if you end up needing that consolation, there it is.
The particular language you may know is not important, but you'll be much better off if you can program well in a functional manner, and are able to think about programs as being evaluations of expressions. Some students have said that being a good functional programmer is the main factor correlated with success in the course. Of course, that may be because the same set of people who know functional programming also know how to do type derivations, but whatever the case, you'll definitely be in better shape if you know how to:
The principle of induction is essential to almost every one of the (many, many) proofs in this class. Even if you understand induction thoroughly, applying the principle to prove things based on derivation trees and the structure of terms is not straightforward, at least at first. If you're unclear on how to do inductive proofs, it may help to go through some proofs on graphs, or on the natural numbers, that proceed by induction. However, proofs by induction will be the focus of the first few weeks in this year's course, so if you have trouble figuring out how to review or study this, you might look to review something else.
This course is not about logic, but a principle called the Curry-Howard correspondence relates the derivation of a particular term's type to a proof of a logical proposition. It's not just an abstract principle: the types of thinking that you do in logic and in type theory are quite analogous. Cracking open your logic book during the course, or immediately before it, is not likely to be of much help, however. Still, some of the thinking you've done in a previous logic course should correspond to thinking about type systems, so pat yourself on the back if your background in logic is good.
People don't tend to study the λ-calculus because they want to program an NES emulator or something; it's only in courses such as this one that you would be exposed to Alonzo Church's programming language from the 1920s. LISP corresponds rather closely to the λ-calculus, so if you know LISP, you might look at what features of it haveλ-calculus analogs. If you've studied the λ-calculus before, you might review that material, although, if you've studied the λ-calculus before, you may be well-prepared for this class and not need to review at all.
The course concludes with a section about a system that is a simplified version of Java. Great familiarity with the Java API is unnecessary, but it's essential to know (or learn) what a downcast is. See chapter 19 of Types and Programming Languages.
You're encouraged to typeset your homework using computer science's own hazing ritual, LaTeX. While spending a lot of time learning how to typeset things, it's possible to fool yourself into thinking that you're accomplishing something, using this as an excuse to not study the course material. Learning LaTeX along the way may leave you with a handy skill, but it's worth remembering that it can't possibly help you pass the WPE-I: that exam is about type systems, not typesetting systems.
Reminder: Most students shouldn't need to do anything special to prepare or review beforehand. This list is included for those who feel like they could use to prepare further in this particular course.
Study and do proofs by induction. Meet once or twice in a study group, present proofs to one another. (2-6 hours)
Review of/crash course in functional programming. In a study group, devise short programming assignments, ask each other for help with syntax and setting up the programming environment, compare results. For instance, you might download Dr. Scheme and do a bit of functional programming in Scheme. (4-8 hours)
You could pick exercises from:
Read the "Lambda Calculus" Wikipedia article. In a study group, discuss the system and talk through basic aspects of it that are unclear. What you'll need to know about the system will be covered in the course, but this introduction could help. (2 hours)
After this, or if you're well-prepared on the topic above but still want to study anyway, you could carefully read through the first few chapters of the textbook, doing exercises and marking where you have questions. (NM)
Semester: Fall
Homepage: http://www.cis.upenn.edu/~cis501/
Newsgroup: news://upenn.cis.cis501
CIS 501 is a thorough introduction to microarchitecture and in particular the following topics: Caches, main memory, disks and I/O, pipelining, out-of-order execution, multiprocessors, and some advanced topics.
Most people I talked with have said that they got a lot out of the course.
For those with little or no background the book that most recommend is by Patterson and Hennessy and is called Computer Organization and Design: The Hardware/Software Interface. (The book is now in its third edition, but the second edition should be helpful, if that's what you can find.) In particular sections 1-7 are a good intro. This is about 700 pages of reading, so you will have to pick and choose what to read and what to ignore. Most important are instruction sets, measuring CPU performance, and the memory hierarchy. Again, pipelining is less important since it is basically covered from scratch in 501.
Familiarity with old question papers were particularly helpful for CIS 501 WPE. However, things have changed and a different instructor (Prof. Milo Martin) will be teaching the course during Fall 2005. So, advice based on past experinece may not be relevant. (RM)
Semester: Fall
Homepage: http://www.cis.upenn.edu/~cis520/
Newsgroup: news://upenn.cis.cis520
This is a new kid in the WPE-I block. CIS 520 was introduced as a WPE-I component in Fall 2004. This course is mainly about mathematical foundations needed for advanced study in AI and machine learning. There are tons of topics covered in this course e.g. learning and inference in graphical models, reinforcement learning, Markov models, supervised and unsupervised learning etc. Unless you are already very faimiliar with the material, this course is a must for anyone who wants to pursue research in these areas. (Partha)
Semester: Spring
Homep Page: http://www.seas.upenn.edu/~cis502/
Newsgroup: CIS 502 newsgroup.
In years past, this course has covered a lot of the text Introduction to Algorithms, 2nd edition, by Cormen, Leiserson, Rivest, and Stein. The course is certainly not easy for everyone, but it does have a very well-defined curriculum. When I took the course, we reviewed all of data structures — the first 22 chapters — in the first two weeks. If you aren't pretty solid on this material, you may wish to at least read through chapters 1-22 and perhaps go through some exercises as well. (NM)
Semester: Spring
Homep Page: http://www.seas.upenn.edu/~cis505/
Newsgroup: news://upenn.cis.cis505
This pretty much covers "Distributed Systems," as the name of the textbook that has been used in past years suggests. The network architectures studied range from more traditional client-server systems (a Web server and clients) to various sorts of peer-to-peer and shared memory systems. Transaction processing, time, and RPCs are all covered. In the past, the course has mixed more rigorous theoretical discussion (with the guarantees of logical clocks and Lamport timestamps, for instance) with the sort of "quantitative approach" found in 501 (lots of arithmetic). There are many case studies of specific distributed file systems and shared memory architectures. (TS & NM)
Semester: Spring
Homep Page: http://www.cis.upenn.edu/~cis511/home05.html
Newsgroup: news://upenn.cis.cis511
This is a course in the theory of computation, and will probably be more algebraic than the undergraduate course you took, if you did take an undergraduate course. A good way to review for the course, or the WPE-I, is to simply study one of the good theory texts very thoroughly: Introduction to Automata Theory, Languages, and Computation by Hopcroft and Ullman (either the first edition from 1979 or the recent second edition, it doesn't matter) or Elements of the Theory of Computation (again, either the 1981 first edition or more recent second edition is fine). (NM)
Various WPE-I related useful information (e.g. past WPE-I statistics, previous papers, links to past course homepages etc.) can be found at http://www.cis.upenn.edu/grad/wpe.shtml.