This site explains the computer science curriculum, both for majors and non-majors. It describes the courses and their sequence, and recommends courses or sets of courses for non-majors interested in taking one or more course from us. Math majors can also find guidance for choosing their computer science supporting course in the section for non-majors.
Courses in the program fall into five categories: (1) foundation courses, which provide the prerequisite background to the curriculum; (2) core courses, intermediate in level and required for the computer science majors; (3) elective courses, advanced in level and going in depth in their individual topics; (4) the liberal arts capstone, CSCI 494; and (5) courses for non-majors only (that is, courses that don't count towards the CSCI major).
Wheaton College's computer science program is comprised of the following courses (courses which do not count towards the CS major are parenthesized). The blurbs below are not catalog descriptions---you should read those too before enrolling in a course. These are meant to give an informal run-down of each course and place it in the curriculum as a whole.
| ( CSCI 215 ) | ( CSCI 231 ) | CSCI 235 | ( CSCI 240 ) | CSCI 243 | CSCI 245 |
| ( CSCI 250 ) | CSCI 335 | CSCI 345 | CSCI 351 | CSCI 355 | CSCI 361 |
| CSCI 365 | CSCI 371 | CSCI 375 | CSCI 445 | CSCI 455 | CSCI 494 |
CSCI 215. Web Design and Programming.
CSCI 231. Introduction to Computer Science Concepts.
CSCI 235. Programming I: Problem-Solving. This course is our basic first course in programming. While we emphasize that computer science is a whole lot more than programming, programming is certainly a prerequisite skill to do anything interesting. The main goal of this course is the improve the problem-solving skills of the students. Second, students learn to express solutions to problems in a programming language (in our case, Java). We also begin learning the fundamentals of object-oriented programming: encapsulating data and functionality together into classes, writing classes that implement the same interface, and making use of subtype polymorphism in program design.
CSCI 240. Introduction to Scientific Computing.
CSCI 243. Discrete Mathematics and Functional Programming. This course's slogan is "Computer science majors should learn to write proofs and math majors should learn to write programs together." It intertwines two otherwise distinct streams of topics: On the one hand, it covers the discrete mathematics needed in CS courses later in the curriculum: logic, proof, sets, relations, functions, and graphs. On the other, it teaches programming in a language called ML that differs from conventional languages in that it views a program as a collection of interacting functions rather than a sequence of instructions. The goal of this course is to teach logical, categorical, and recursive reasoning (perfect for any liberal arts major); the vehicle for this is topics on the boundary of mathematics and computer science.
CSCI 245. Programming II: Object-Oriented Design. This course, a continuation of CSCI 235, is pivotal in the curriculum. Although a programming course, it teaches programming in a way that points ahead to future courses. It has four purposes: (1) A "postrequisite" for CSCI 235, finishing the basic object-oriented programming features with subclassing, inheritance, and class hierarchies; (2) a prerequisite for CSCI 245, introducing data abstraction, basic data structures, and algorithm analysis; (3) a prerequisite for CSCI 335, teaching software development practices and design patterns; and (4) a prerequisite for CSCI 351, exposing students to computer organization, data representation, and programming in the C language.
CSCI 250. Computer Modeling.
CSCI 335. Software Development. This course explores the practical and professional issues of developing large software systems. This includes honing programming skills, but also learning good teamwork and communication. This course also gives exposure to various topics not otherwise covered in the core courses; these may include data bases, GUI and event-driven programming, programming language concepts, formal languages and regular expressions, distributed computing, web programming, and scripting languages.
CSCI 345. Data Structures and Algorithms.
CSCI 351. Introduction to Computer Systems.
CSCI 355. Computer Organization.
CSCI 361. Computer Graphics.
CSCI 365. Programming Language Concepts. This course studies programming languages in two ways. The first is formal: What semantic models can we formulate which capture the meaning of a programming language and prove properties of programs? The second is practical: How can we implement compilers and other language systems to analyze, translate, and interpret programs? Thus this course is both a theory course and a systems course. In it we both prove theorems and build language systems.
CSCI 371. Databases.
CSCI 375. Artificial Intelligence.
CSCI 445. Analysis of Algorithms. After reviewing techniques for proving an algorithm's correctness and analyzing its efficiency, this course explores a catalogue of advanced algorithms and algorithmic techniques, data structures, and analysis methods. At the end of the course, we consider the formal issues of computability and tractability of problems, particularly the concept of NP-completeness.
CSCI 455. Operating Systems.
CSCI 494. Social and Ethical Issues
As explained above, the courses for majors are categorized into foundation courses, core courses, electives, and the capstone. In addition, there are three supporting courses that are required.
Supporting courses: Computer science students are required to take two math courses and one physics course. These include MATH 231 (Calculus I) and PHYS 231 (Classical Physics I). Note that PHYS 231 is calculus-based physics, which means (a) PHYS 221 (General Physics) does not fulfill this requirement, and (b) MATH 231 is a corequisite. Finally, computer science majors are required to take another math course above the 200 level. Because of the prerequisite system in the math curriculum, your likely options are MATH 232 (Calculus II) or MATH 245 (Linear Algebra); MATH 245 is highly recommended---but it wouldn't be a bad idea to take MATH 232 also.
Special note about AP credit and supporting courses: If you have AP credit for calculus or physics, make sure that it aligns properly with the required courses---do not assume that you automatically have credit for them. The Mathematics program requires at least a 4 on the AP Calculus AB test or at least a 3 on the AP Calculus BC test in order to receive credit for all of MATH 231. The Physics program does not accept the AP Physics B test for credit for PHYS 231.
Foundation courses. You should complete the foundation courses (CSCI 243, CSCI 235, and CSCI 245) and the MATH 231 supporting course in your first three semesters---in fact, completing them in your first year would be preferable, but this might not be possible. It will depend on how much background in mathematics and computer science you have coming in. If you have credit for all of MATH 231 (for example, from the AP Calculus exam), you should register for CSCI 243 (Discrete Mathematics) in the fall of your freshman year; otherwise, take MATH 231 that fall, and take CSCI 243 in the fall of your sophomore year.
CSCI 235 and CSCI 245 (Programming I and II) form a unit which you should complete your first year. Because of AP credit or previous experience, you may be placed in CSCI 245 (that is, you don't have to take CSCI 235), in which case you may take CSCI 245 in the fall or the spring. If you are not placed out of CSCI 235, your should take CSCI 235 in the fall and CSCI 245 in the spring.
Core courses. There are three required courses which comprise the core body of knowledge of the major. CSCI 351 (Introduction to Computer Systems)is offered every fall; CSCI 345 (Data Structures and Algorithms) and CSCI 335 (Software Development) are offered every spring. Preferably you would complete these in your sophomore year, but many of you might find it necessary to postpone one or two until your junior year. They may be taken in any order, but if you have to choose one to postpone for a year, you should take the curriculum's prerequisite chain into consideration, so that this postponement will not prevent you from taking an elective you are interested in.
Electives. CSCI majors are required to take three electives. It must be emphasized that this is a minimum requirement. Most students who are serious about a career built upon a computer science major or interested in graduate studies will need to take four or five electives to set them on the right track. Remember, students who have completed a computer science major at a large university (who may be your competitors for employment positions or entrance into graduate schools) will have many more major hours required of them than students graduating from a liberal arts college like Wheaton.
In choosing electives, all students should consider where their interest lies and what courses would be particularly useful in their desired career. Double majors should think about which electives would best complement their other studies. For students interested in graduate school, CSCI 445 (Analysis of Algorithms) is essential; it is also recommended that they take all of CSCI 355 (Computer Organization), CSCI 365 (Programming Languages), and CSCI 455 (Operating Systems).
Capstone. Senior standing is required to take the capstone course, CSCI 494.
The requirements for a minor in computer science are 20 hours in courses numbered in the 200's or higher (so, any five courses described here, except that CSCI 231 and CSCI 215 would each only count for half, since they're 2 hour courses). However, before you decide to "minor" in computer science or anything else, you should make sure you're doing it for the knowledge, not for the sake of checking a "minor" box on your transcript or resume.
The courses you take which aren't part of your major or your general education requirements should fit together in a useful way. If they calculate out to fulfilling the requirements for a minor, great. If they turn out to be 2 hours short of an official minor, don't sweat it. If a course or two more than an official minor would be useful to you, then don't stop taking courses just because you have already "finished" your minor. In other words, make up your own minor (which some guidance from this site, the catalog, and your advisor), and don't be too concerned about the official requirements.
What we present here are sets of courses that are relevant as supporting courses for students in other majors who would like some computer science background---standard minor or mini-minor packages. Of course you may want to tailor some of these for your own interest.
First off, you folks are required to take a course from us to complete the math major. Here's an explanation of your options -- see the courses' respective descriptions for more information.
Now, we love having math majors take a few more courses with us-- no other major goes along as well with CSCI as math. However, we don't have a minor track just for you, and that's because several of the other tracks would be relevant for you, depending on what areas of math you're more attracted to. For those of you with a taste for pure math, we suggest you first look at the track for economics majors. The applied mathematicians might consider a track for natural science majors.
Our introduction to programming sequence, CSCI 235 and CSCI 245, is the typical choice for students in Wheaton's Liberal Arts Engineering program and will transfer to meet the programming requirements at most engineering programs. For further study, you may be interested in CSCI 243 (Discrete Mathematics) or our minor track with a systems emphasis.
| If you simply want to know what the field of computer science is (how it differs from, say, information technology or just programming), this track will expose you to the main ideas of the discipline with minimal time commitment. CSCI 231 discusses how computer systems work and takes a look at various applications of computing; CSCI 243 presents the mathematical foundations with a bit of programming. |
| Whether you're majoring in mathematics or economics, the goal of this track is to get you into CSCI 445 (Analysis of Algorithms). 445 takes a good deal of mathematical maturity, and many of its concepts tie nicely into economic theory (amortization, network flow). If you don't have time in your schedule to complete the whole track, taking through CSCI 345 with give you a fair amount of the benefit. |
| Of course, to program well, you'll need to know some CS theory too. But that's all built into the courses in this track, which focus on developing and honing your programming skills. Of course this includes the introductory programming sequence (CSCI 235 and CSCI 245). You'll also need to know data structures and algorithms (CSCI 345, with CSCI 243 as a prereq). CSCI 335 (Software Development) will put you with a team working on a large programming project. Finally, you may also want to take CSCI 215 (Web Design and Programming) to learn the programming involved in web site production. |
| CSCI 240 (Introduction to Scientific Computing) is itself a one-course mini-track for natural science majors. It also provides the (minimal) background necessary for CSCI 250 (Computational Modeling), a great tool for research in chemistry, biology, and physics (as well as a tool for related work in mathematical modeling). |
| This track is similar to the smaller track for science majors (featuring CSCI 250 (Computational Modeling)), but it provides a full background in programming (CSCI 235 and CSCI 245) and theory (CSCI 243 and CSCI 345) which will enrich the experience of CSCI 250. |
| This is for home-grown hackers who want more insight into how to play around with their Linux boxes (sorry, boxen), or for those in physics or engineering who have some interest in computer engineering. This track contains courses for computer systems and organization (architecture), bypassing the math stuff. |