README 

A Guide to Cornell Computer Science

Written by Students for Students

2018 Edition

FOREWORD

In one fateful winter break, a few students involved with Association for Computer Science Undergraduates (ACSU) wanted to provide a resource that not only addresses a handful of frequently asked questions but also serves as a more comprehensive guide to the Computer Science major at Cornell University than what the Unofficial CS Wiki offered. We hope that this guide will (1) serve as one of the many useful resources that underclassmen can use to acclimate to Cornell University as a CS major or minor and (2) be further improved by experienced upperclassmen who have accumulated helpful perspectives being in Cornell’s CS community.

Disclaimer:  This readme was written by students and is not officially endorsed by the Cornell University Computer Science Department. Although every effort was made to ensure the accuracy of its contents, we can make no guarantees.

If you have any questions, comments, or suggestions, please do not hesitate to email us at acsu@cornell.edu!


FREQUENTLY ASKED QUESTIONS

General

Are there any benefits of majoring in Computer Science through the College of Arts and Sciences instead of the College of Engineering, and vice versa?

The general consensus for this question is that there is no significant difference. There appear to be a lot of students asking this, and most of them seem to have the wrong impression that majoring in one college over another is more “prestigious”; however, this is not the case. The only difference between the schools you major from is all of the requirements outside of the Computer Science major. For example, the College of Engineering requires students to take PHYS 1112 and 2213, whereas the College of A&S does not. However, the College of A&S requires students to take a language course and fulfill other “distribution” requirements. Yet, to complete the CS major, they need to take the same set of core classes (CS 2800, CS 3110, CS 3410/3420, CS 4410, CS 4820), 3 4000-level CS classes, 3 external specialization classes, and a few other requirements.

It should also be noted that Engineering students graduate with a Bachelor of Science and Arts students graduate with a Bachelor of Arts.

Some reasons that have been observed in the past to transfer from one school to another are the following:

  • a student in CALS (or any other college), who does not have a CS major, transfers to CAS or CoE to earn a Computer Science major
  • a student with a lot of AP credits (say ones that fulfill PHYS 1112 and PHYS 2213) cannot have them count towards graduation in one college (CAS), but can in another (CoE)
  • a student does not want to fulfill a certain requirement (does not want to take a language class - go to CoE!, or hates Physics with an extreme passion - go to CAS!)
  • a student wants to double major in a field, but the second major is not offered in the particular college they are currently affiliated with (e.g. Mathematics is offered as a major in CAS but is not offered as a major in CoE)

Do I NEED a Mac? Can I get by with a PC? Will my choice of laptop affect my ability to become a Computer Science major? Which laptop would you recommend to a prospective CS major?

A CS major at Cornell University can DEFINITELY get by with either a PC or a Mac. If you have familiarity, Linux is also a perfectly workable option. Most classes use Virtual Machines to provide students with the required software that is needed for the class. For classes that don’t, their course staff usually try their best to accommodate both. However, if you have interest in developing iPhone applications, a Mac is the way to go. A Mac is also nice in that it has a Unix environment, which makes many kinds of development easier. Bearing all these in mind, however, most people choose based on their personal preferences.

I don’t have prior CS knowledge; am I screwed?

Not at all! Although it is common for students to have had exposure to Computer Science before their first year at Cornell, it is perfectly okay for students to have no prior experience whatsoever. In fact, introductory classes such as CS 1110 and CS 1112 are geared towards students with no prior background. There have been many students who excel as Computer Science majors at Cornell University who had no experience before college, and you can be one of them!

When should I affiliate? What are the benefits of affiliating?

You should affiliate as soon as you are eligible if you have committed to the major. For most students, applying for affiliation occurs during sophomore year, but in some cases it’s possible to affiliate even earlier. College of Engineering students have no choice but to apply before the end of sophomore year or they will be withdrawn from the college, but CAS students are free to begin the process during their fourth semester. You submit the paperwork to affiliate during the semester that you take the last of the required courses.

The requirements for affiliation are as follows:

  • cumulative GPA >= 2.0 (CoE-only requirement)
  • at least a C in all completed CS and math courses
  • GPA >= 2.5 in CS 2110/2112 and CS 2800
  • GPA >= 2.5 in MATH 1120/1220/1920 and CS 2800

If you don’t meet these requirements, don’t despair! Some deficiencies can be offset by excelling in other areas. Check out the CS Major website  for more information.

It’s definitely good to affiliate by your third semester if you can; if you can’t, don’t worry too much about it. One of the few differences the timing can make is in pre-enrolling for fourth semester classes. Many 4000+ level CS courses are available only to CS/IS majors during pre-enroll, so there is a slight advantage to sophomores who are already affiliated by then. More perks that are offered to CS majors are access to the undergraduate computing lab (UGClab) in Gates G33, official access to the CIS undergraduate lab (although the door is usually open anyway), and CS-related emails from the awesome Nicole Roy!


I want to double major; is this a good idea?

Double majoring for the sake of double majoring is not the best idea. You should do this only if you have vested interest in both subjects! Note that the Computer Science major offers good opportunities for you to explore other subject areas through the External Specialization requirements, many university-wide minors and probably technical electives.

It is definitely good to decide the double majors as early as possible (especially with Computer Science) because then you can plan the courses ahead and don’t have to panic as you become an upperclassman.

For students with Computer Science major in College of Arts and Sciences, you can choose to count courses in a second major or minor as electives.


Academics

Should I take CS 1110 or CS 1112?

CS 1110 teaches you the basics of Computer Science in using the Python programming language, whereas CS 1112 teaches you the basics using the Matlab language. Because writing code in Python is less complex, more readable, and is easier to transition to learn how to write code in other popular languages such as Java, most prospective CS majors elect to take CS 1110. However, CS 1112 would be a good choice for students who are interested in classes associated with Computational Science & Engineering (CS 4210, CS 4220) or have interest in other science fields outside of Computer Science because it is useful for mathematical computations.

Should I take CS 2110 or CS 2112?

Both courses cover similar material. However, CS 2112 is well-known for its extensive projects. If you are looking to getting experience on working on a significant codebase and have the time to afford to, CS 2112 might be the course for you. Also there is an option to switch back to CS 2110 from CS 2112 within the first three weeks, so if you find the assignments and the overall pace of CS 2112 to be a bit much, switching back to CS 2110 is always an option.

With that said, CS 2110 also covers a significant breadth of material, and by the end of it, students should be exposed to a variety of technical concepts that are not only covered in other higher-level CS courses but also prepare students to begin preparing for technical interviews. So in terms of the material covered, students enrolled in CS 2110 are not missing out on anything significant. For students who have taken CS 2110, they are generally able to invest more time into other courses as well, as CS 2110’s projects are not on the scale of CS 2112.

Should I take CS 3410 or CS 3420 / ECE 3140?

This answer partially depends on whether you can fit ENGRD/ECE 2300 (a prerequisite for 3420) into your schedule. Because CS majors in the College of Engineering are required to take 2 engineering distributions, ENGRD/ECE 2300 is a popular choice due to its material being most relevant to the CS major out of other ENGRD options (the other being filled by ENGRD 2110 or ENGRD 2112, which is required for the major). If you can manage to fit ENGRD/ECE 2300 into your schedule and want to avoid overlapping content, taking CS 3420 (crosslisted as ECE 3140) may be the better option. However, if you want to reinforce the material taught in ENGRD/ECE 2300, taking CS 3410 might be better.

Now that CS 3410 is offered in both the Fall and the Spring, fitting that into your schedule is much more flexible than trying to fit in CS 3420, which is offered only in the Spring semester. If this is of concern to you, taking CS 3410 might be a better option.

In terms of comparing the courses themselves, CS 3410 is pretty well known to be filled with projects that are very time consuming. CS 3420 on the other hand have very reasonable projects up until the final project (open-ended), in which the time commitment can vary wildly depending on the type of projects students wish to pursue. CS 3410 also squeezes in a lot more material than CS 3420 does. This, however, is more like comparing to apples to oranges, as the combination of ENGRD 2300 and CS 3420 covers all the material covered by CS 3410 and more. In that sense, if you want to spread out the material you want to learn in the duration of a year rather than the semester, the ENGRD 2300-CS 3420 might be of more interest (and vice versa).

Lastly, CS 3420 places more emphasis on I/O and hardware-related material (hence its name, Embedded Systems). In fact, most projects in CS 3420 involve coding logic onto a microcontroller (MSP430). This is highlighted by the final project which gives student freedom to pursue whatever project they wish to with their MSP430s. Therefore, if you have more interest in hardware systems, CS 3420 might be for you.

What is a practicum? What separates it from a regular course?

With the exception of CS 2111, practicums are classes that are based entirely on projects. Usually, given a class CS xxx0, its associated practicum will be offered as CS xxx1. Every CS major is required to take one practicum, and can choose to enroll in multiple practicums if they wish. The practicums are meant to be extensions of the associated course, and usually students get to implement a variety of things covered in lecture but are not explored in other parts of the class. For example, for CS 4320: Intro to Database Systems, lectures encompass various components of databases, and in CS 4321, students get to implement a SQL-interpreter in Java where they actually code up and learn the ins-and-outs of the discussed components. For some classes, the practicum must be taken along with the actual course (e.g. CS 4120 + 4121).

Why are some 4000-level classes cross-listed as 5000-level classes?

If a 4000-level class is cross-listed as a 5000-level class, that means that the same course is offered to both undergraduate students and graduate students. Therefore, unless you are a graduate student, you should sign up for the 4000-level class as CS 4xxx instead of CS 5xxx. The class and all requirements are generally the exact same.

What is a vector? Is it important in any way? Is one more prestigious than another?

Think of vectors as a guideline of which courses to take if you are interested in a certain subject (like a concentration). Fulfilling a vector is optional, but note that vector requirements can double count. Outside of the context of Cornell Computer Science, vectors are not too important and don’t even show up on your transcript. However, they can be very useful in trying to shape your future coursework and determine which courses to take. Keep in mind that vectors are not hard requirements as much as they are a checklist of courses, so a class taken as a CS major requirement can double count as a vector requirement.

More information about vectors can be found here.

More information about the checklist: for Engineering students ; for Arts students.

What are prerequisites? Are they actually enforced?

Many courses build off the material in prior courses, either directly or indirectly. In order to ensure that all students have the same background, departments designate certain other courses as prerequisites that must be completed before enrolling in a subsequent course. Historically the CS department has allowed students to take classes for which they did not have the prerequisites, though doing so is not recommended. If you do not meet the prerequisites for a certain course it is recommended that you speak with the instructor, since sometimes they serve only as a way to ensure that you have some previous experience with the topic.

I am struggling as a CS major, and I need additional resources for help; how can I go about doing this?

If you are struggling with a particular CS class, the first approach would be to try to go to Office Hours and seek help from TAs. Professors will generally also hold an hour or two of office hours, but if they are at a time you can’t make then free to try to arrange a meeting with a professor by catching them after class or through e-mail. Professors and TAs are here to help your learning experience, and can be surprisingly helpful in pinpointing the source of your struggles. In some cases, Professors may help find you a personal tutor for the course.

In addition to the course staff, introductory classes have external resources that can help. For example, CS 1110, CS 1112, and CS 2110 all have on-call peer tutors  and Academic Excellence Workshops  which are 1-credit supplemental courses. In addition, CS 2110 has recently been offering a Programming Practicum  as a supplemental course.

The nice thing about Computer Science is that a lot of information can be found online as well. If you don’t understand a certain concept presented in lecture and staring at the slides doesn’t help, Googling for understanding can yield surprisingly helpful resources. Stack Overflow is especially useful.

For the checklist requirements, can I replace CHEM 2080 with any other class?

CHEM 2080 can be replaced by BTRY 3080, ECON 3130, MATH 2930, MATH 4710, PHYS 2214, or PHYS 2218. However keep in mind the MATH 2930 is a prerequisite of PHYS 2214.

Can I use the same class for different requirements for the CS checklist?

Unfortunately, you cannot have the same class listed for any of the requirements that require you to fill in the class name, semester you took it, and your grade. For example you cannot use MATH 2930 to replace both CHEM 2080 as well as use it as a Technical Elective. However, you can use a statistic/probability class for a requirement on a checklist. For example you can use ENGRD 2700 as a probability class as well as an ENGRD requirement (because the probability class is only a checkbox. As long as you took one, it doesn’t matter which class it is or whether it satisfies another requirement.)

What is an external specialization?

An external specialization is three 3000+ classes that are all related in some way. The easiest way to complete an external spec would be to find three class in the same category (MATH, CHEM, MECHE, ECE etc) that are 3000 or above. You could also have a very thin connection between the three classes. As long as you’re able to explain how those three classes are connected, then anything is valid.

What classes qualify as Technical Elective classes?

Any 3000+ course that engage the student in computation reasoning and analysis or in any quantitative way qualify. They are usually in application areas such as BIO, BEE, CHEM, PSYCH, PHYS, MATH, ECON, any Engineering fields including CS and MAE, or related subjects. However, some of these areas may involve writing or theoretical courses, such as PSYCH 3050 (theory). No classes that involve writing only about science, math, technology, etc, qualify.

How can I fulfill the technical writing requirement in the College of Engineering?

The College of Engineering website  lists ways to meet the Technical Writing Requirement at Cornell University. Some common ways to get technical writing credit are: CS 4999  (Undergraduate Research), ENGRC 3024  (Co-ops and Internships). Classes such as CS/INFO 3152 (Introduction to Game Design) also have one-credit attachments that will fulfill the requirement.

It’s a good idea to double-check with your CS advisor or one of the CS Undergraduate Advisors if you’re unsure if a course fulfills this requirement. If it’s not listed on the website, there’s a good chance if doesn’t count, but there is a process for petitioning an unlisted course for credit.

Are there classes that can fulfill multiple liberal arts/breadth requirements?

There are classes that fulfill both Historical and Geographical Breadth requirements that you can take if you can’t manage to fit two separate classes into your schedule. Departments that usually offer these are the Near Eastern Studies department. The same applies for A&S liberal arts requirements. Overlap is commonly found in Latin American Studies and Philosophy.


Internships & Jobs

Why and how do people apply for internships?

Internships are a great way for students to explore potential career paths and interests, learn more about the company that they are interning for, and learn what being a software developer is like in the real world. People usually apply for internships through the career fair and Handshake. This is not the only means, however, as most companies have links on their websites specifically for internships applications. Generally, an applicant needs to fill out basic information about themselves as well as a resume that highlights their technical skills, coursework, and achievements. If you perform well at an internship, most companies will give a return offer to either come back as an intern the next year or as a full-time employee - depending on your graduation date.

What type of information should my resume contain?

Typically, a resume for a software-related intern position contains information such as…

  1. Previous employment/experience
  2. Coursework/GPA/Education information
  3. Personal or significant class projects
  4. Awards (e.g. from hackathons)  
  5. Technical skills (e.g. programming languages, frameworks, etc.)

This link also gives really good advice on how to craft your resume.

What is a typical technical interview like for a CS major applying for a Software (Development) Engineering Internship position?

Typically after a brief conversation to introduce yourself, most Software Engineering internship positions will require the candidate to solve one or more technical interview questions. This will most of the time involve concepts introduced in CS 2110/2. Depending on the set up, this is usually done on the whiteboard (in-person interview) or on a website that provides code-friendly platform (phone interview). A sample question can be something like:

Given two lists of numbers A and B in which B contains all of the elements of A and one additional element, return the element that belongs in B but not in A.

Afterwards, interviewers typically take some time to talk more about the company, the work they do, and open up time for questions.

I am a freshman/sophomore interested in applying for internships; are there any programs geared towards underclassmen like us?

If you are an underclassmen considering computer science as a career or if you just want to learn more about working in the tech industry, you should definitely check out the following summer programs specific to freshmen and sophomores:

Google Engineering Practicum

Application Period: October - early December (rolling)

Eligibility: For current freshmen and sophomores

Notes: The Engineering Practicum program is a 12-week developmental opportunity for first and second-year undergraduate students with a passion for technology -- especially students from historically underrepresented groups in the field. During the summer you will work alongside other Practicum interns on a software project, attend skills-based and professional development trainings, and receive mentorship from Google engineers.

Microsoft Explore

Application Period: late August - November (rolling)

Eligibility: For current freshmen and sophomores

Notes: Explore Microsoft program is a 12-week summer internship intended for students who are beginning their academic studies and would like to learn more about careers in software development through an experiential learning program. By providing formal training as well as a group project experience working alongside other Explorers, the Explore program offers a rotational experience that enables interns to gain experience in both core software engineering roles (Program Manager and Software Engineer), rather than specializing in just one.

Facebook University

Application Period: early January - late February

Eligibility: For current freshmen

Notes: Facebook University is a paid 8-week training program designed to provide mobile development experience to students who are historically underrepresented in computer science. The eight-weeks is broken down by two weeks of mobile development training in either iOS or Android, followed by six-weeks of hands-on project experience in a small team setting.

What if I want to get involved in research over the summer instead?

Check out research opportunities at Cornell or at other universities around the US.

If you want to do research at Cornell, you can send an email directly to the professor you want to work with, or visit him/her in his/her office. Most professors are really open to students seeking research opportunities over the summer, and will be happy to talk to you about their research and how you can get involved.

Engineering Learning Initiatives (ELI) at Cornell provides student grants for undergraduate engineering research projects. Based on their website (http://www.engineering.cornell.edu/research/undergraduate/student_grant/index.cfm ) they have a funding cycle for the summer with applications in Early March.

The National Science Foundation (NSF) provides paid research opportunities at universities around the US called Research Experiences for Undergraduates (REUs) At their site (http://www.nsf.gov/crssprgm/reu/ ) you can find out more about the program and search for an REU based on discipline and REU location. You'll most likely work with a professor over the summer on a project with a couple of other students as well.


GRADUATE SCHOOL

Master's Degree (CS MS)

The overview for this degree and what it entails can be found starting from the main landing page . For more specific application details, see the requirements page  on the graduate school website.

To summarize, the Master of Science in Computer Science program lasts 4 semesters and requires 34 credits to graduate, 6-12 of those credits dedicated to your thesis research. It’s required that you work as a TA for each of those semesters. However, you do receive full tuition and a housing stipend while you are in the program. To be accepted into the program, you will need your college transcript, 3 letters of recommendation, a statement of purpose, and an essay describing how a CS MS aligns with your career plans; all of which are due in mid-December.

MEng

This program lasts 2 semesters and typically covers 6 courses and a project. Applications become available 2-3 months before the deadline and are due at the beginning of February for the following fall or the beginning of October for the following spring.

For a comprehensive look at the MEng program, check out the website.

Ph.D.

A lot has been written on the topic of applying to PhD programs and what it takes to succeed in them. One excellent source is this document  written by a professor at CMU.

A Ph.D. is a roughly 6-year commitment, which is almost entirely devoted to doing research. Applications are typically due mid-December of your senior year, and typically require 3 recommendation letters, a statement of purpose, transcript, and GRE scores. Unlike undergrad, there is really only one main criterion for admission: whether the university believes that you can excel at doing research. Naturally the best way to demonstrate this is to have undergraduate research experience, which you can read more about below.


COURSE INFORMATION

Disclaimer Addendum: Because the world is constantly innovating and changing, you can expect that courses at Cornell will be changing as well. All information in this section is based on previous semesters’ experience and may not be accurate with respect to the current or future semesters.

The Major

The CS major is open to students in the College of Arts and Sciences and the College of Engineering. For more information on the difference between the colleges, see the section in the FAQ above .

Below is the major flowchart from the 2016 Engineering Handbook, which provides a sample schedule for when to take requirements for the major under the assumption that you are a Engineering student who has no prior AP credits:

Please see the following links for information about the CS major:

General major requirements

College of Arts and Sciences requirements

College of Engineering requirements

2016 College of Engineering requirements handbook

The Minor

The CS minor can be completed by any student from any college. More information can be found on the department’s website .

Core Classes

These classes are required for anyone majoring in computer science. With the exception of CS 2110 and CS 2800 (which are often taken together), it is generally recommended that students should take one core class each semester. However, that isn’t to say taking more than one (say, CS 4820 and CS 3410) is impossible. See the Alternatives to the Core Classes section below for alternate classes, and why you might want to take them instead.


CS 1110: Introduction to Computing Using Python

The first course in the computer science sequence, this is a recommended course to take for all newcomers. It will cover all the necessary skills that every coder has with them, from variables to functions and beyond. Can be waived with AP Computer Science credit (may vary in CAS and CoE departments, however).

The class is historically taught by Walker White in the fall and then a pair of professors in the Spring. Because the Spring curriculum is based off Professor Walker’s personally designed Fall curriculum, there shouldn’t be any major differences in taking it in either semester. Also because it is an introductory class into the CS world, the class tends to have a large number of consultants whose jobs are also to give advice and insight into the rest of the CS major. There are one-on-one meetings designed into the class for any questions you may have, so make sure to take advantage of those resources if you need them.

The projects are very straightforward and as long as you’re paying attention in class/lab and reading instructions carefully, you’ll do well. The most noteworthy project is the last one where you’ll be tasked to build your own version of Breakout.

Projects can be done in pairs of two or alone. While it might be beneficial to have a partner to talk with, be careful in dividing up work--since this is an introductory class, you definitely want to get good grasp of the course material.

Offered: Every semester

Prerequisites: No programming experience but some high school math (no calculus)

Historical Median Grade: B

Workload: Moderate (3 to 7 hours per assignment)

Notes: The class expects no programming experience.


CS 2110: Object-Oriented Programming and Data Structures

This is the second course in the introductory computer science sequence. It teaches basic computer science topics including sorting and searching, asymptotic complexity, recursion and data structures. Almost all material in this course is used in later courses or interviews.

Typically taught by David Gries and one other CS professor, this class forms the core of many CS topics and forms the basis of general CS knowledge. Many 4000 level courses will have this class as their highest requirement. A very large portion of programming interviews use material from this class.

This class has a lighter amount of work compared to other CS classes. There are seven projects which can be completed with a partner. There are two prelims and an optional final. Grades in homeworks are typically very high (~90) while prelim grades follow a normal distribution (average between 65 and 75). This means that prelims are weighted heavily when deciding grades, so study up.

Offered: Every semester

Prerequisites: CS 1110, CS 1112, or AP credit

Historical Median Grade: B

Workload: Moderate (5 to 8 hours per week)

Notes: This course does assume some programming experience (at the level of CS 1110), but the majority of students will not have background in Java.


CS 2800: Discrete Structures

The purpose of this course is not to learn about structures that are discrete, as the name implies, but more to introduce basic mathematical concepts and get students to write good proofs. Topics covered include…

  • finite automata
  • functions (injective, surjective, bijective)
  • number theory (Euclid’s algorithm,Euler’s theorem, RSA)
  • graph theory (basic definitions and properties)
  • logic
  • discrete probability
  • induction (strong, weak, structural)

The course has been known as a class in which people could get by with little-to-no effort in the past, but this seems to be no longer the case since 2013-2014 when Professor Kozen and Professor Bailey taught it in the Fall and Spring respectively. Although different professors have been teaching it since, the problem sets remain somewhat difficult and much more advanced concepts, such as Turing machines, context-free grammar, computability, and NP-complete problems have been discussed in class in the past year. Prelims have generally been in-class prelims for the past semesters. This last semester, however, prelims were changed to regular evening exams. Depending on the professor, the lecture material may vary, but regardless, a student who is planning to take CS 2800 should expect to…

  1. write lots of proofs!
  2. be exposed to material that they will see in other classes, whether they be Computer Science related (CS 3110, CS 4820) or not (MATH 2940, MATH 3360)
  3. not write a single piece of code
  4. not buy any textbooks (because there isn’t an official one!)

Some helpful links for the class include…

  • notes written by professors who have taught the course previously
  • these concise notes on probability

Other general advice about the course…

  • The problem sets can be difficult at times but they are excellent materials to help you study for exams. By fully understanding the materials in the problem sets, you should be okay taking the exams.
  • Because the material varies from the professors teaching it, don’t rely on previous prelims to be a good indicator of what the prelim for your semester will be like (unless the same professor is teaching it).  
  • If you haven’t used LaTeX much until this course, this is a perfect place to start using it!

Offered: Every semester

Prerequisite: One programming course or permission of instructor.

Historical Median Grade: B+ (this seems to be pretty consistent regardless of the professor teaching that semester)

Workload: Can vary from an hour to how long it may take you to LaTeX your proof nicely!

Realistically speaking, it will vary wildly depending on the length of the problem sets. Problem set questions can vary from two or three questions to ten or more questions from textbook. Some questions might be straight-forward calculations and answers while others can be proof questions that often can be rather challenging. But if you ever get stuck and need help, there are office hours throughout the entire weeks that you can go and get help.


CS 3110: Data Structures and Functional Programming

This course introduces you to the paradigm of functional programming in a language called OCaml, which may be quite different from anything you’ve seen until now. The goal of the course is not to just teach you a fancy new programming style but to use it as a tool to help you learn to be better software engineers overall. Topics covered include:

  • Functional programming
  • Writing and using specifications
  • Modular programming and data abstraction
  • Reasoning about program correctness
  • Reasoning about system performance
  • Useful and efficient data structures

Usually the course is a general introduction to functional programming concepts and how they can be applied to real software engineering, but sometimes the course is more mathematical/theoretical, going into depth on topics such as type theory and the constructive real numbers.

The course consists of lectures as well as but also two weekly recitations taught by undergraduate TAs. The recitations are a fantastic resource for not only asking questions and clarifying concepts with peers, but also gaining hands-on experience, as some recitations involve coding. Recitations will not only go in-depth of important topics covered in lecture, but also cover topics more directly related to problem sets.

This course, like CS 3410, is a significant jump in difficulty/workload from CS 2110, so it would definitely be wise to start projects early and stay on top of the material if you haven’t gotten into this habit already. There are usually 5-7 projects that consist mostly of programming in OCaml. In the past, the course has varied with regards to working with partners. Last time it was taught by Constable, for example, it featured mostly individual projects; only one was in pairs. There has also been semesters where all projects were pair or group projects. In Clarkson last offering the first few projects were individual, while the next few were (optionally) done with a partner, and the final project was a group project (mandatory) with 3-4 team members. Historically, this final project allows each group more freedom in their software engineering choices, but also expects much more creativity and ingenuity to come from the assignment.

Helpful links:

  • Real World OCaml, a book available for free online that is often used as a supplementary text in the course
  • Depending on your background experience, this might be the first course in which you will be exposed to Git, a system that allows remote users to work on coding assignments together. Git can be very scary and confusing for the first time, so brushing upon the basics  before the course begins may save some headaches during the semester.

Offered: Every semester

Prerequisites: CS 2110 (or equivalent programming experience).

Corequisite: CS 2800

Historical Median Grade: B in Fall 2017

Workload: Moderate/Heavy (seems to be around 9 hours based on course evals) (5 to 7 projects a semester, with around 2 to 3 weeks to do each one)


CS 3410: Computer System Organization and Programming

This course aims to bridge the gap between software and hardware through topics such as computer organization, systems programming, and hardware/software interface. In terms of the work, you are required to work individually for some of the projects and in a pair for others. The labs are done individually. You may also have written homeworks depending on which professor is teaching the course.

PA1-3 require you to make a MIPS pipelined-processor through a simulation program called Logisim, which is used to build circuits. You will get familiarized with Logisim through PA1, where you will build an Arithmetic and Logic Unit (ALU) that performs basic calculations. In PA2 and PA3, you will build a functioning five-stage MIPS processor that executes various instructions. PA3 builds on PA2 but is considered to be harder than PA2 since it can be tricky to figure out all the edge cases. PA4 is a friendly hacking challenge which requires you to craft some input to a simplified browser and cause it to print out a different message as its default one. You will essentially be performing a buffer overflow attack on the browser. The last projects, PA5-6, involve writing tests for dynamic memory allocator (malloc) in C and then implementing malloc. A lot of problems arise due to the fact that students are still unfamiliar with commons errors found in C.

Naturally, this class moves fast since it has to cover materials covered in both ECE 2300 and CS 3420. Reading the book will be a very good supplement. Overall, the materials covered in the class are important to master for any choice of career in CS. The course is also good to know for CS 4410 (Operating Systems), since the material continues approximately where 3410 left off and students use the same tools that you’ve learned here for OS projects.

Historically there have been 2 prelims and no final exam (final project instead). Projects and Labs are worth ~50% of the final grade, while exams and homeworks are worth the other ~50% (subject to change).

Offered: Every semester

Prerequisite: CS 2110. Prior knowledge of C is not required, but does help.

Historical Median Grade: B+

Workload: Moderate/Heavy. In Spring 2016, new assignments were released every week, and due every 2 (sometimes 3) weeks. The class is split into labs, projects, and written homeworks, which may require at least 10-15 hours of work for non trivial assignments. Larger projects have been known to take longer than 30 hours.


CS 4410: Operating Systems

This class covers the design and implementation of operating systems. Key topics are as follows:

  • Concurrency
  • Synchronization
  • Scheduling
  • Memory Management
  • Filesystems
  • Networking

If you are NOT signed up for CS 4411  concurrently while taking CS 4410, then you will be required to do what is known as Miniprojects (MPs). Even if you are signed up for CS 4411, there will usually be 1 or 2 MPs you are still required to do. In the past, there have generally been 4 MPs on the following topics:

  • Synchronization questions involving semaphores and monitors, and race conditions (done in Python)
  • Implementing malloc (done in C) [may change in fall 2017 due to this now being covered in CS 3410]
  • Implementing a given protocol (done in Python)
  • Implementing a part of a file system (has been done in both Python and C before)

The projects themselves aren’t too difficult. The first one will be very helpful for preparing for the first prelim and provide students exposure to synchronization questions. For the rest, try to read over the writeup for the projects very carefully, as even overlooking a minor detail may cost you a significant amount of points, especially as grading for many of the assignments is completely decided by the autograder test cases. Never break the 12 commandments of synchronization!

Another general advice for the MPs would be to try to sketch out what you will be doing before actually implementing the code. Although this is a general advice that can apply to virtually any CS class, this is especially important in OS when you have to, say, implement a protocol that will be designed to respond in a specific manner depending on the context.

Offered: Every semester

Prerequisite: CS 3410 or CS 3420. Do not take without one of these.

Historical Median Grade: Varies yearly

Workload: If you are not taking it with CS 4411, the workload is on the lighter side. Once you have a good understanding of the writeup for the projects, they don’t take too much time. However, obtaining a good understanding may take some time, so don’t put it off until the last minute. Don’t hesitate to clarify any details that you have with the writeup with TAs and professors, as that can save you a significant amount of time!

CS 4820: Introduction to Analysis of Algorithms

This course stays true to its name and exposes students to various algorithms and how to argue for their correctness. The types of algorithms introduced include…

  • Matching algorithms
  • Greedy algorithms
  • Dynamic programming algorithms
  • Divide and conquer algorithms
  • Network flow algorithms

It also dives into topics such as Turing Machines, NP-complete problems, and approximation algorithms in the later parts of the course.

The course has weekly problem sets that usually consists of three problems (two on a short week). Almost all of the problems involve (1) coming up with an algorithm to solve the problem of interest (2) write a proof to explain why the algorithm you proposed solves the problem (3) reason about runtime when applicable. Starting Spring 2016, some problem sets actually included a problem that involved coding in Java.

Some helpful advice for the class includes…

  • the textbook, written by Cornell professors (Eva Tardos and Jon Kleinberg) is super comprehensive and is structured just like the lectures. If you ever had to buy a textbook, this would be the most helpful one in terms of how much it will actually help you with the class
  • even if you plan to put off doing the problem set until a later time, try to read the problems as soon as they are released. Just thinking about the problems in your downtime can save a lot of time when you actually get down to doing it
  • if you haven’t used LaTeX much up until this point… be prepared! Sometimes typing up your answers can take longer time than actually doing the problem, so make sure to always leave enough time to type

Offered: Spring only

Prerequisite: CS 2800 and CS 3110

Historical Median Grade: This seems to vary wildly depending the professor; with Professor Tardos, the median was an A-. With Professor Kleinberg (Bobby), the median was a B/B+

Workload: The best description of the workload for CS 4820 is constant. With weekly problem sets, there is not much downtime of not actually having something due. Once you start using your late days as well, you may end up in a situation where you have to do 2 problem sets in one week…

Supplements to the Core Classes

These classes can be taken alongside their respective core classes, to enhance your understanding of the material and to reinforce topics.

CS 2111: Programming Practicum

Weekly supplemental class for CS 2110; credited S/U. This course does NOT fulfill the CS project requirement despite being called a practicum. Usually is taught by the course instructor(s) and delves deeper into topics covered in recent CS 2110 lectures. Before exams, it can also double as a review or Q&A session.


CS 4411: Practicum in Operating Systems

For this class, you and your partner will be graded solely on the 6 projects that you work on throughout the semester. All of the projects are written in C, and each take a considerable amount of time (Heavy workload). Each project delves deeper into a topic that was briefly introduced in the lecture, which gives you a deeper understanding of the material. If you take this class, you have to do only the first Mini Project (MP) for OS and can ignore the other ones.

The projects are estimated to be around 30-40 hours of work, but they are spaced out 2-3 weeks apart. Note that the first 4 projects build on each other. If you have a mistake on project 1, you must fix it before you turn in project 2 or else you will lose points. Or even worse, you will run into a huge error later down the line. More often, significant points are lost on projects by missing a detail that was in the writeup. For this class especially, make sure to check Piazza frequently for updates and clarification on the specifications for the project so that you don’t lose points for dumb mistakes.

Most of the difficulty comes from the nuances of working in C and familiarizing yourself with the codebase. If you need C help, go early in the week since office hours have to accommodate both 4410 and 4411 students.

General tip to score well on projects: even though it may be tedious, try to write a very simple test for each functionality you implemented. While working in C, it is easy to cast to void pointers and lose all type information, so even correctly seeming code can be wrong because of a simple mistake. If you do this, and make sure to cover every part of the project specifications, you will do very well in the class.

Though hailed as one of the more notorious of practicums, this course provides a very fulfilling experience. It will stress the importance of building and testing concurrently (not building, then testing), as well as trying to cover every possible corner case while trying your best to follow specifications.

Also for those who are curious, you CAN take CS 4411 as a standalone class, although if that is the case, then you should have taken CS 4410 prior to taking CS 4411.


Alternatives to the Core Classes

CS 1112: Introduction to Computing Using MATLAB

This is an alternate version of CS 1110 typically taken only by engineering students considering majors besides computer science.

CS 2112: Object-Oriented Design and Data Structures - Honors

This is the honors version of CS 2110. While the two courses cover approximately the same general topics, CS 2112 goes into greater depth with the material and has bigger and more challenging assignments. In particular, in CS 2112 you will learn more about algorithms and algorithm analysis on the theory side and about software design principles on the practical side.

The main difference from CS 2110, however, is in the projects. The coursework consists of several individual assignments followed by a final project spanning multiple assignments that you will work on with a partner for the remainder of the course. The assignments often involve implementing many of the data structures and algorithms covered in class. The final project also involves working with a partner in designing and managing a large codebase (thousands of lines of code) from scratch. These assignments are far heavier than the ones in CS 2110, so definitely consider the rest of your schedule and commitments before deciding to take this course. If you have the time to devote to this course though, you will learn a lot and also find yourself more equipped for the difficulty of upper-level CS courses.

While projects from other introductory classes (CS 1110, CS 2110) focus more on getting familiar with the language and the fundamentals of programming, CS 2112 focuses more on object oriented design. Having a good design and working plan goes a long way. Talking to the TA’s or the professor about your design will drastically reduce your work time. Make sure to devote enough time talking with your partner about design.

Offered: Irregularly, every 2 or 3 semesters

Prerequisite: Very good performance in CS 1110 or CS 1130 or equivalent course in Java, C, or C++, or permission of the instructor.

Historical Median Grade: A-

Workload: Heavy, 10 to 20 hours per week

CS 3420: Embedded Systems

This course can serve as an alternative to CS 3410 in terms of fulfilling the CS major’s core requirement. Someone who has NOT taken ECE/ENGRD 2300 is strongly discouraged to take the course; otherwise, you will not have covered the same material that is covered in CS 3410, as you will miss out on learning the details of the building blocks of a CPU. In addition, ECE/ENGRD 2300 exposes students to assembly, which you are assumed to be familiar with at the beginning of CS 3420.

The topics covered include

  • assembly language programming
  • interrupts and I/O
  • concurrency models
  • task/threads synchronization
  • real-time constraints and scheduling
  • communication
  • data conversion

A good amount of the material actually overlap with material that is taught in CS 4410 (around 30 to 50%, depending on how much material you are able to retain from CS 3420).

Throughout the semester, you will be using the ARM FRDM-K64F board by NXP (MSP430 Development Tool by Texas Instruments was used in the past) for all of your labs. Labs consist of implementing concepts taught in class using C and loading the program to the chip and are done with partners. Historically, partners for Labs 1 - 4 are randomly assigned while you can choose your own partners for Labs 5 and 6. There are 6 total labs for the course…

  1. Assembly language programming
  2. Interacting with I/O devices
  3. Concurrency (I/O and interrupts)
  4. More concurrency (locks and conditional variables)
  5. Scheduling (real-time and periodic)
  6. Final Project

The final project can be basically whatever you decide to build with the FRDM-K64F board and typically involves applying some concepts from previous labs and lectures. Just like with the labs, the final project can be done with a partner. Additionally, each group will be assigned a mentor to help out with any questions regarding the project.

The course also has a few written homeworks that are graded pass/fail based on if you get 60% of it right, but they require little to no time to complete. Once a week, there will be a short i>Clicker quiz as well covering the topics lectured from the previous week.

Some helpful advice for the class include…

  • Start your labs early! It is sometimes very hard to tell whether there is a bug in your code, so you might save yourself a lot of stress by making sure you have ample time to debug. This advice especially applies for the last two labs, which may seem a little rushed due to the proximity of finals season.
  • Try to review the material on a weekly basis to prepare yourself for the once-a-week i>Clicker quiz! This will also help you prepare for the prelims.
  • The professor particularly emphasizes that the prelims do not cover material that have not been discussed in class. Thus, it can be very helpful to go through the VideoNotes and lecture notes in preparation for the exams.

Offered: Every spring

Prerequisite: ECE/ENGRD 2300

Historical Median Grade: B

Workload: No final exam to worry about and the projects aren’t TOO time consuming (though you may spend quite some time in office hours). The workload for the final project will vary wildly on what your group decides to pursue.


Electives

“Electives” cover any course that isn’t listed as a specific requirement by your major or your college. The idea is to include some flexibility in your curriculum so you are more free to choose classes that truly interest you.

3000 Level 

CS 3152: Introduction to Computer Game Development 

In this course, students are assigned into groups of 6 containing programmers and designers at the very start of the semester, and work within that team to build a fully fledged desktop PC/Mac game that will enter the annual GDIAC Showcase at the end of the semester.

 

Lectures for the course cover both design and programming elements of computer game development, and serves as a useful resource for designing and building the game. For the first month while brainstorming game ideas, programmers and designers all must complete a series of 4 labs designed to teach you basic programming or designing techniques. The game is built using Java and the LibGDX framework. Art assets are generally created via Adobe Photoshop.

 

After the first month, there will be 7 milestones, with each one typically taking two weeks. The major milestones are: Non-digital Prototype, Gameplay Prototype, Technical Prototype, Alpha Release, Beta Release, Final Release, GDIAC Showcase. For each milestone, you will estimate what you will do for the milestone, demonstrate the milestone’s work in class or in labs, reflect on whether you met the goals for this milestone, and receive detailed feedback as well as suggestions moving forward from the professor and the TAs.

 

This course must also be taken with the 1 credit ENGRC 3152 course. Therefore, there are also document writing throughout the course. For every two week sprint, there will be a two week report. Other documents include the Concept Document, Gameplay Specification, Architecture Specification, Design Specification, and Game Manual. These documents will typically undergo three rounds of revision, where the last version turned in will be the final grade for the documents.

 

In the GDIAC Showcase, your game will be presented to the public. This counts at the final exam of the course, and the audience reaction will also be part of your final grade. The audience will be allowed to vote for their favorite, and there will be an award ceremony at the end of the showcase for various awards.

 

Because this is a very serious course where approximately 10 hours of work per person per week is expected, (and is a very competitive course to get in) there is an application handed in to professor Walker White that will determine whether you can get into the course, as well as your team assignment.

 

Some helpful advice for the class include…

  • Team dynamics is really important. Communicate often and resolve conflicts as soon as possible. Know your teammates strengths and weaknesses so as to balance work amongst yourselves.
  • Take the labs seriously and use them as a guideline to learn. A lot of the programming part is based heavily on some of the labs, and you are free to use any lab code. Knowing the labs well will make your lives easier when developing the game. For designers, the labs are great tutorials to help you get familiar with photoshop (if you are not already so) on digital art and animation.
  • Learn to use git well. Merge conflicts on the morning of a demo day is a very bad idea.

 

Offered: Every Spring

Prerequisite: For programmers it is CS 2110 or permission of instructor. For designers it is INFO 2450 and/or submission of art/design portfolio to instructor.

Historical Median Grade: A-

Workload: Approximately 10 hours per week outside of class.


4000 Level

CS 4110: Programming Languages and Logics

An introduction to the theory, design, and implementation of programming languages. Topics have historically included different semantics for mathematically reasoning about PLs, type systems, lambda calculus, exceptions, side effects, objects, and modules and probabilistic programming.

This class is problem-set based, and only some of the homeworks include coding (OCaml). It’s a good introduction to how programming languages work; topics touched in Compilers are evident throughout the course, though there is little overlap in terms of the actual content taught.

Some helpful advice for the class include…

  • Homeworks can be done in partners. If dividing the work, make sure to go over everything to know you understand the solutions. Some problems might be tricky.
  • It’s good to be comfortable with proofs and induction!

Offered: Usually every Fall

Prerequisite:  CS 3110 or permission of instructor

Workload: Not too heavy; 5 hours a week perhaps.


CS 4120 + CS 4121: Introduction to Compilers + Practicum

CS 4120 introduces compilers; lexing, parsing, type-checking, intermediate representations, optimization and code generation. The practicum is required, and is most of the work.

Some helpful advice for the class include…

  • Don’t underestimate the assignments. Always over-estimate the amount of time they will take to finish, and make sure to allow for a few days of debugging. Especially on the latter assignments, debugging can get tricky.
  • Make sure to apply all the good practices of software design and engineering you have learned. The compiler you write will be a significantly-sized project; big enough so that no single person will be able to know all the parts. Document, write regression tests, don’t allow technical debt; it will come back to bite you! Investing that extra hour or two on the first few projects will save you days on the last few.
  • Don’t leave team-members behind. Sometimes people have a rough week, and might fall behind; the amount of work that needs to be done is enough that it will always pay off to invest a few hours to keep your team members up to speed and productive, over focusing on work and letting them figure it out themselves.

Offered: Every other year, spring semester.

Prerequisite: CS 3110 and CS 3410.

Workload: Heavy. There’s a handful of written homeworks that can be finished in a sitting or two. Most of the work revolves around the practicum project, implementing a compiler, which can get really heavy.


CS 4152: Advanced Computer Game Development

In this course, students are divided into interdisciplinary teams of six students, comprised of both programmers and designers. Team members must work together throughout the semester to build a fully-fledged cross-platform mobile game that will enter the annual GDIAC Showcase. Devices are useful but not required; some students may be interested in purchasing a cheap Android phone or iPod touch for development purposes.

 

Lectures for the course cover both design and programming as applied to computer game development. There are no labs. Games are built using C++ and Cocos2d-x, while art assets are generally created via Adobe Photoshop.

 

The semester is split into several milestones, with each one typically taking two weeks. These include various prototypes (Non-digital, Gameplay, Technical) and releases (Alpha, Closed Beta, Open Beta, Showcase). Each milestone requires careful planning and sizing; at sprint’s end, teams can expect to receive detailed feedback from the course staff and an opportunity for self-evaluation.

 

This course must also be taken with the 1-credit ENGRC 4152. Therefore, document writing is an integral part of the class; for every two-week sprint, there will also be a two-week report. Other assigned documents include the Concept Document, Gameplay Specification, Architecture Specification, Design Specification, and App Store Proposal. These documents will typically undergo several rounds of revision, in which the last version turned in will earn the final grade for the document.

 

In the GDIAC Showcase, your game will be presented to the public. This counts as the final exam for the course, with audience reception factored into a game’s final grade. GDIAC attendees vote for their favorite games, and awards in various categories are distributed at the end of the Showcase.

 

Because this is an intensive course where approximately 10 hours of work per-person per-week are expected, prospective students must apply and be approved by Professor Walker White before enrolling. Applications are also used as the basis for team assignments, which are made by Professor White.

Some helpful advice for the class:

  • Team dynamics are crucial. Communicate often, and resolve conflicts as soon as possible.
  • Planning is everything. Know your teammates’ strengths, weaknesses, and schedules, and balance work accordingly.
  • Documentation and collaboration are key when working on a software project of this magnitude. Write sustainable code, and be prepared for inevitable refactoring and cleanup efforts.
  • Success is interdisciplinary! Successful team members often fill multiple roles as needed.

Offered: Every Spring

Prerequisite: For programmers it is  CS 3152 and one of the following (or permission of the instructor): CS 3300, CS 4620, CS 4700, CS 4758, or CS 5414. For designers it is INFO 3152 and INFO 3450 (or permission of the instructor).

Historical Median Grade: A-

Workload: Approximately 10 hours per week outside of class.


CS 4154: Analytics-Driven Game Design

In this class, students work together in groups of 5-6 to build a browser-based game, gathering information over the course of the semester through logging players’ actions and using it to improve the game over several iterations. Groups typically consist of 1 or 2 designers, and 4 programmers.

Lectures combine basic elements of game design with topics on data gathering for games. Game design topics taught include learnability and user interfaces, procedural content generation, balancing, and level design. Students will also learn how to collect data and make conclusions based on it to improve their game.

The games are typically written in Flash/HTML5, and have in the past always been 2D games. There are five milestones in total, spaced out approximately every 1.5 weeks. The last two milestones are public, and consist of releasing to Newgrounds and Kongregate respectively. Most games will receive at least 1,000 views.

After each milestone, groups present to the class on the data they gathered, as well as any conclusions they drew from this data. For example, a group may notice a steep dropoff in the number of players that pass a certain level, and talk about why this might be the case and how they can fix it. In at least one milestone, students must also perform an A/B test on a release of their games.

Students who are interested should expect to spend at least 10 hours a week on this class. In addition, students will need to meet with their group often - the most successful games in this class are built by groups that communicate and work together effectively.

This class is sometimes compared with CS-3152/4152; its format draws influence from these classes. Games in the analytics-driven class are slightly smaller in scope than those of the other game design courses, due to the emphasis on iterating on gameplay through analytics. In addition, lectures in this class overlap slightly with CS-3152, though most lectures are specific to this class. The class format is also fairly similar, with some class periods reserved for playtesting.

Previous game design experience is recommended, but not required, for both programmers and designers. In addition to the prerequisites listed below, some knowledge of MySQL for programmers is also helpful but not required. Designers should have some art and animation experience.

Some helpful advice for the class:

  • Make absolute sure that your game is correctly logging player actions before (and after!) each milestone release.
  • Work together with your team. Schedule work meetings and make sure everyone comes. It will help you keep track of your game’s progress, and generally help your team dynamic. This includes designers as well.
  • Helpful advice in the other game design classes apply here as well.

Offered: Fall 2014, Fall 2015

Prerequisite: Programmers: CS 2110 (or permission of the instructor). Designers: Submission of art/design portfolio to instructor.

Historical Median Grade: A-

Workload: At least 10 hours a week.


CS 4320: Introduction to Database Systems

This course introduces relational databases, typical NoSQL databases, and big data. The topics that the professor focuses on changes a little from semester-to-semester, but you can usually expect to cover:

  • relation models
  • SQL queries
  • query processing and optimization
  • transactions and recovery methods
  • NoSQL systems
  • database design
  • B+ trees
  • MapReduce algorithm

Lectures are pretty fast-paced because of the breadth of material that needs to be covered. If you’re taking the practicum concurrently, this material neatly lines up with whatever you’re expected to do for your practicum projects.

There are around 5 homeworks that are spaced out during the semester and are worked on in groups of 2 or 3. The primary languages used in homeworks are SQL, PostgreSQL, Java, and Neo4j; you are expected to be able to install any software that you do not already have. The staff grade the coding part of homework using automated tests, so it is very important to follow their specifications, especially for any input/output.

There is one midterm and one final. The final is cumulative, but focuses on material covered after the midterm. It is easy to do well on these tests if you’ve been attending all the lectures and you’re able to recreate/understand the homework solutions.

Some helpful advice for the class include…

  • At least do a cursory read-through of each homework the day it’s released! Then you can stew over ideas from the start and maybe come up with your solution faster once you actually get coding.
  • Especially if you divvy up the work for homeworks, make sure to revisit the parts your partner did and try them yourself so that you can ace those topics on the midterm/final.

Offered: Every semester

Prerequisite: Prerequisite: CS 2110 and CS 2800

Workload: Each homework requires you use your given time effectively, and they progressively get harder. There is a midterm and a final exam, both of which are not too difficult if you’ve been following along during lectures.


CS 4321: Practicum in Database Systems

This course is designed to supplement the main class, CS 4320, but it’s not necessary to take if you simply want to learn about database systems. You will be building a simple database system from scratch that can handle baby SELECT...FROM...WHERE queries. The language you will be using is Java, and the IDE is Eclipse.

In terms of material, this course can easily be taken concurrently OR after you’ve completed CS 4320. If you’re taking it concurrently, each project assumes only knowledge that you’ve covered during CS 4320 already. There are around 5 projects that are spaced out during the semester and are worked on in groups of 2 or 3. These projects are pretty substantial, which means get started early and work on it every day if you can!

Grading your projects is almost entirely automated, so you have to be extremely careful about following the instructions precisely, especially your input/output format. There is a “breaking automation” policy that allows you to recover points if you were genuinely misunderstanding something, and there is the normal regrading policy--both should be exercised very rarely and only if the cost for a regrade is worth the correction.

Some helpful advice for the class include…

  • Same as for the main course, try to at least do a cursory read-through of each project the day it’s released! Then you can stew over ideas from the start and maybe come up with your solution faster once you actually get coding.
  • Use some version control system, like Github to sync with your partner(s). Also, if you ever need to undo what you changed that make your system break, having saved previous versions makes rollback much easier!

Offered: Every semester

Prerequisite/Corequisite: CS 4320

Workload:  The projects are pretty time-consuming, but not too hard. If you are taking this with the main course, it may sometimes seem  like half your week is dedicated to database systems, so be very careful planning your time well.


CS 4620: Introduction to Computer Graphics

This course gives an introduction to the field of generating images using computers and provides a foundation for pursuing the subject more advanced and specific areas like animated films and video games. The course starts with the basic building blocks of representing a three-dimensional scene, including object meshes, perspective, lighting, and transformations in space, and then goes on to rendering techniques like ray tracing and rasterization through the graphics pipeline. Finally, subjects such as curves, textures, animation, and other advanced topics are covered. The course involves a decent amount of mathematics, including mostly linear algebra with a little bit of calculus, and prior knowledge is not a prerequisite but of course would be helpful.

There are generally around 7 projects (under Professor Bala), covering object meshes, basic ray tracing, scene rendering, shaders in GLSL, splines, animation, and advanced ray tracing. Projects consist of a programming part (done with a partner) and a written part (done alone). The written parts are usually a few questions designed to reinforce the theory taught in class. Programming assignments are done in Java and come with skeleton code as well as the course-created Java graphics framework. These are straightforward for the most part, as most of it is just translating the procedures or mathematics they describe into code. However, it is easy to make minor mistakes that are often very difficult to debug due to the nature of the subject, as you generally have few references other than the generated image to troubleshoot the problem, so it is important to be careful when programming and to really understand the theory before tackling the implementation. The course Java framework, although constantly being improved by the TAs, can also be buggy at times or counterintuitive if you're not careful, so read the specs carefully. Programming assignments are graded in scheduled demo sessions and are evaluated mostly visually based on the end result rather than through automated test cases.

There is also a midterm and a final, which along with the programming and written assignments encompass graded material in the course.

Offered: traditionally Fall, now sometimes Spring
Prerequisite: CS 2110/ENGRD 2110
Workload: Moderate; relatively straightforward assignments but debugging can be time-consuming


CS 4621: Computer Graphics Practicum

This course provides extra programming assignments to supplement CS 4620. There are three programming assignments and a final project, and the meetings of the course either go over material relevant to the assignments or are simply consultation meetings to discuss the final project with your designated TA(s).

The assignments focus on writing shaders, which are special programs that allow you to manipulate the way objects are drawn. This extra experience can be very useful if you want to pursue graphics further in practical applications, since shaders are an essential part of the GPU rendering pipeline used to render most scenes.

The final project is open-ended and done over the course of about a month, from project proposal to final demo. The project should go beyond the scope of the regular assignments and demonstrate techniques learned in the main course. Other than that, the entire subject and how far you want to go is up to you, so you have a lot of room to be creative. In terms of the written portion, the project proposal should be about two pages and the final project report is three to five pages.

Grading for the regular assignments is just like the grading in the main course (demo with a TA). The final project is also graded at a demo session and is evaluated based on difficulty of the techniques attempted/achieved and effort.


Offered: Same as CS 4620 (traditionally Fall, now sometimes Spring)
Prerequisite/Corequisite: CS 4620
Workload: Assignments are similar in workload to CS 4620 assignments; final project should be at least as difficult as a regular assignment but you decide how much you want to put into it.


CS 4670: Introduction to Computer Vision

Computer vision is a wide-ranging discipline that aims to gain a high level understanding of the world by analyzing digital images. It is also one of the main applications of machine learning, and common learning tasks, such as object recognition, are covered in this course.

This course covers a breadth of subjects about digital images starting from the level of an unfamiliar beginner and then builds up to more complex techniques. Students first learn about how an image is made up (image representation, filtering, fourier analysis) and then dive into the fundamental theories and techniques used in the field (feature detection, image transformations, single view modeling, stereo view modeling, structure from motion), and finally it finishes off with a strong focus in deep neural networks (Convnets, object recognition, face recognition, scene categorization), which have recently become more dominant in the field.

This is a project-based course, with students expected to complete roughly 5-6 projects and 2-3 homeworks over the course of the semester. The projects focus on the actual implementation of the theories learned in class. In previous semesters (Professor Bala), students have implemented their own panorama generating program, programs to recover 3D geometry of objects given 2D images, and constructed their own convolutional neural networks for image recognition.

Offered: TBD

Prerequisite: CS 2110/ENGRD 2110 and CS 2800 or equivalent. Linear algebra is not required but the course will go smoothly with more comfort in understanding and manipulating linear algebra concepts.

Workload: Projects are within the normal amount of work. There are not as many homework assignments as in other classes, but they are nontrivial.


CS 4700: Foundations of Artificial Intelligence

This course covers the history of artificial intelligence, with introductions to the major areas and research fields being tapped into today. In the past, the topics covered included:

  • AI methodology
  • Problem-solving strategies (search algorithms)
  • Heuristics
  • Knowledge representation
  • Logic and deduction
  • Reasoning and planning
  • Machine learning (decision trees, neural networks)

This class is structured around past research, kind of in a theory-and-example format, and requires attending lecture a couple of days during the week. There is a textbook (typically the one published by Russell and Norvig) that supplements the lectures and also contains a few of the homework problems.

The 4 homework assignments are assigned a bit sporadically, but always cover the material since last assignment. You also tend to get a handful of late-day extensions for turning in homeworks. These assignments are nontrivial for the most part, and cover much of the material that will be tested during the exams. There are two exams: the midterm and the final, which account for the bulk of your grade, and feature questions similar to those you’ve seen in the homeworks. In the past, class participation (questions/answers and comments during class) was also included as a mandatory part of your grade, but was changed to an optional extra-credit in Fall 2016 due to the size of the class.

There are a few TAs for this course, so use this resource wisely! Discussion of topics is encouraged, again because this class covers relevant modern AI theory and research, so the TAs can often shed some light on questions you have that are even outside the scope of the course. Finding a study group or discussing concepts on Piazza is a good way to way of reviewing your weak subjects.

Offered: Fall, sometimes Spring

Prerequisite: CS 2110/ENGRD 2110 and CS 2800 or equivalent

Workload: There are not as many homework assignments as in other classes, but they are nontrivial. Studying for the exams is not too time-consuming if you’ve kept up with the lectures and homeworks.


CS 4701: Practicum in Artificial Intelligence

This course is designed to supplement the main class, CS 4700, by allowing students to apply AI concepts in a practical setting. Students should note that CS 4701 does not teach additional AI-related concepts since it is solely a project-based course where students work on a semester-long AI project either individually or with a partner. The project is completely up to the students as long as it demonstrates a mastery of some important AI-related topics. Previous examples of course projects include games like Othello and Tetris as well as chat bots.

Aside from a scheduled section to explain the project requirements, there are no lectures or discussions for this course. Performance in the class is mainly determined by a final project presentation to the professor at the end of the semester. Although it is recommended that enrolled students have taken CS 4700, many students have taken only CS 4701, as they can independently learn the AI concepts required for the development of their project.

CS 4701 is required for the AI vector.

Loose structure:

  • Project proposal (6-8 pages)
  • Project content/code
  • Final Report (10-20 pages)
  • 20-min presentations given during finals (10-20 slides)

Some helpful advice for the class include…

  • This class is nice in that students get to define their own deadlines in terms of project milestones but don’t leave all the work to finals week!
  • The final presentation to Professor Selman is more like a 2-way conversation since he tends to ask a lot of questions, so be ready to talk about any project design/development decisions and explain implemented AI concepts.

Offered: Fall (and Spring 2017)

Prerequisite/Corequisite: CS 4700

Workload: The workload for CS 4701 depends entirely on how complex the project is and how much effort students choose to put into the project. There are only two deliverable deadlines throughout the semester: a project proposal due mid-semester and a final 20-min presentation with a final project report and demo to Professor Selman at the end of the semester.


CS 4740: Intro to Natural Language Processing

This course is an introductory course to Natural Language Processing (as the name clearly suggest). It teaches how computers use human languages as inputs, outputs, or both and covers parsing, machine translation, grammar induction, and information retrieval. Basically the course is about how computers can take human language and understand it. (Very very basic concepts of parsing and grammar induction were taught in CS 2800 and CS 2110 so the ideas might seem familiar.)

 

Some helpful advice for the class include… (Note some of this advice pertaining to the course is from the course Professor Cardie taught)

  • Know Python (although any language is acceptable, but for this course, Python would be a more convenient language due to existing natural language processing Python libraries.
  • There is a lot of information to know for the final, so study at least 2 to 3 days earlier. However it is fairly straightforward and is based off of the lecture slides. It covers everything learned throughout the semester.
  • Find a good group for the projects
  • Start the projects at least 3 to 4 days in advance if you don’t want the class to get too stressful
  • Do not wait until the last day to do projects. Some algorithms take a long time to run.

Offered: Normally offered in the Fall.

Prerequisite: CS 2110

Workload: There are usually 5 critiques over the semester and each one usually takes up two hours. There are also usually 4 major projects that take up to 20-30 hours and are either done in groups of 2-3 or 3-4. Make sure to find a good group if you don’t want to be the one carrying. These projects are split up into two parts. The second part is usually the heavier part of the project, but you get feedback for part 1 to help you. Part 1 is mainly creating baselines and planning.


CS 4780: Machine Learning for Intelligent Systems

An introductory course to supervised learning. This course is recommended to any student wanting a starting point to explore the field of machine learning, since the materials covered assume no prior knowledge. This course covers the theory behind some of the most important supervised machine learning models, and is focused on theory and proofs of why these models work. This gives the students the ability to reason about in what situations certain models can be advantageous. In addition, students get to implement/debug each of these models themselves in order to figure out the nuances, which helps build a stronger intuition of how they work. This class does not focus heavily on the applications of machine learning. For applications, see NLP or CV.

Some helpful advice for the class include…

  • The notes given during class and posted online are outlines of the proofs / theory that the class went over that day. During class, be attentive and don’t accept the proofs as they are. Try to focus on why certain things are true and ask after class for clarification, if blocked.

Offered: Spring

Prerequisite:  Programming skills (e.g. CS 2110 or CS 3110), and basic knowledge of linear algebra (e.g. MATH 2940), and probability theory (e.g. CS 2800)

Familiarity in statistics and linear algebra is recommended but fluency is not required. The programming language used is Julia or Python.

Workload: About 1 Programming assignment a week, but they are light and take a couple hours at most. In Fall 2016 with Prof. Weinberger, there was an autograder that displayed your assignment scores immediately upon submission, so you could stop working depending on how satisfied you were with your score. Programming projects are usually worked on with 1 other partner.


CS 4786: Machine Learning for Data Science

An introductory course in machine learning, with a focus on data modeling and related methods and learning algorithms for data sciences. Topics include dimensionality reduction, clustering, and probabilistic-modeling topics.

Performance in the class is determined mainly by 3-6 assignments and 2 competitions. The assignments, which are to be done individually, are designed to test your understanding of the fundamentals of the course material. They occasionally require light coding, but students do not have to submit the code they use. The competitions are group projects of up to four people.  Given a set of files and preliminary data, teams make educated predictions that are submitted onto Kaggle, a site for predictive modelling. A little less than half of the competition grade comes from the Kaggle score/performance percentage (how accurate the prediction is) relative to the other students in the class. Most of the competition grade comes from a written report, where teams explain how they set up the model to use the data and their rationale in a clear fashion.

Some helpful advice for the class includes…

  • Even though there are no examinations (no prelims or a final), stay up to date with the material. The homeworks will go by much quicker with a basic understanding. The lectures also provide exactly the procedures you need to do well in the competitions.
  • While the course is not coding intensive, you will need to do some light coding. It is a good idea to brush up on Python and/or Matlab.

Offered:  TBD (Was offered in Spring 2016 and Fall 2016, but not Spring 2017)

Prerequisite: probability theory (BTRY 3080, ECON 3130, MATH 4710, or strong performance in ENGRD 2700 or equivalent); linear algebra (strong performance in MATH 2940 or equivalent); CS 2110 or equivalent programming proficiency

Workload: 6 bi-weekly assignments and 2 competitions. A majority of the assignments can be completed in a couple of hours with sufficient understanding of the material and/or help from course staff. The competitions take significantly longer in terms of man hours, but they are group projects (up to 4 students). Starting early and making submissions regularly before the deadline will guarantee a decent competition score.


CS 4810: Introduction to Theory of Computing

An introductory course to some topics in theoretical computer science. This course is useful for anyone interested in more theoretical aspects of computer science. The topics generally include finite automata, nondeterminism, Turing machines, computability, and NP-completeness. Here's a detailed topic list from fall 2017 .

The course emphasizes a thorough understanding of the main ideas rather than the fine details of the underlying proofs (although understanding of the proofs are emphasized as well). Often on homeworks and exams, you will be asked to give the idea or a high level explanation of a proof rather than a formal proof. Lectures generally follow in this manner as well.

There are 3 prelims and no final. The prelims are all in class and are often 5 questions each (like the homework).

Some helpful advice:

Pay attention in class and take notes. Often the homework will have questions that ask you to recreate a proof or algorithm given in lecture. Sometimes, Professor Hopcroft will teach a theorem or idea that isn’t published in the textbook or elsewhere so if you miss lecture, or forget you’ll have to go to office hours. Reading the textbook is also helpful and sometimes the exposition there is clearer than in the lectures. Ask questions in lecture.

When studying for the prelims, it is useful to go through the past exams on the 2012 course website . Sometimes Professor Hopcroft recycles questions.

Offered: Every fall

Prerequisite: technically 2800, but depending on your interests and background it may not be hard to take without 2800.

Workload: One homework every week - usually 5 questions. In fall 2017, there were a total of 12 homeworks. Usually homeworks can be done pretty quickly if you’ve already gone to lectures and understand the material. Very often questions will come straight from lectures. Other times, they come from the textbook.


CS 4830: Introduction to Cryptography

An introductory course to cryptography. This course covers both the theory and application sides of cryptography. On the theory side, beginning with a formal definition of security, it goes on to cover computational indistinguishability, numerous methods of message encryption, digital signatures, and finally various consensus protocols. On the application side, topics include oblivious RAM and garbled circuits, which are fascinating ideas proposed only during the last few decades.

There is one written homework assignment that emphasizes rigorous proofs based on a solid understanding of definitions and concepts covered in class. Besides, there are also two coding projects, for which you will use Java to implement two interesting applications of cryptography and then run large-scale performance tests to reason about their security. Besides,there are two take-home prelims and one final.

The professor usually starts the class with a 5-minute quiz on the material of the previous lecture and takes attendance in this way.

Offered: Every spring before 2018

Prerequisite: CS 2800, as the class assumes knowledge of number theory, probability theory and proof techniques.

Workload: Medium. In spring 2017, there was one long written homework and two coding assignments. The proofs in the written homework are reasonably hard, but the coding assignments are fairly simple once you’ve understood the key ideas behind the application.


RELEVANT GROUPS ON CAMPUS

Outside of courses, Cornell offers a variety of ways for students to get involved in the local computer science community through student computing groups. Joining one or more of these organizations is a great way for students to network with other computer science students as well as learn about different opportunities in the computer science field. These organizations also host many company info sessions, academic and career development workshops, guest speaker presentations, and other events that computer science students may find helpful (not to mention, there’s usually free food and swag!).

ACSU: Association of Computer Science Undergraduates

The Association of Computer Science Undergraduates, more commonly known as ACSU, is Cornell’s chapter of the Association for Computing Machinery (ACM). ACSU promotes educational, professional, and social interaction among students interested in computer science and facilitates student communication with faculty, alumni, and corporate representatives to enhance the undergraduate experience in computer science. Some things that ACSU oversees include social events for CS students to meet outside of class, student-faculty events, academic workshops to develop technical skills, company information sessions for recruitment, a resume book for internships and full-time employment, student-led reading groups, and a mentorship program.

Learn more about ACSU: http://acsu.cornell.edu/

WICC: Women in Computing at Cornell

Women in Computing at Cornell, or WICC, is a student organization that seeks to bring together women in computing fields at Cornell, expand their opportunities and successes, provide a support network of women, and empower them to encourage younger women to consider computing fields. WICC membership and events are not just restricted to women, and anyone who is interested is welcome to join. Like ACSU, WICC also oversees many social events, company info sessions, academic workshops, a resume book, and a mentorship program. WICC is an ACM-W Student Chapter.

Learn more about WICC: http://wicc.acm.org/

URMC: Under-Represented Minorities in Computing

Under-Represented Minorities in Computing (URMC) is an undergraduate organization with focus on providing guidance and community for UR minorities interested in majoring in any computing field (CS, InfoSci, ECE, Stats, etc). In spite of being an incredibly diverse school, computing fields at Cornell have a huge representation problem. Engineering CS for example, was only 6% hispanic, and 1% african-american in 2015. URMC aims to provide community, mentorship and career development opportunities specially targeted to URMs, but open to all students in the computing community, to bring minority students together, and provide a welcoming environment to solve this representation gap.

Learn more about URMC: https://www.facebook.com/groups/cornellurmc /

ISSA: Information Science Student Association

The Information Science Student Association is open to all students (majors, minors, or undeclared) interested in Information Science or Information Science, Systems, & Technology. The ISSA is here to improve the student experience and spread the word about both majors. We plan networking events, social events, corporate information sessions, and meet-and-greets with Cornell faculty.

Learn more about ISSA: http://issa.infosci.cornell.edu/

Open Source Cornell

Open Source Cornell aims to promote the usage and development of open source software, as well as intellectual and software freedom by connecting free software users and developers, open access researchers, and open hardware “makers” with resources, events, and like-minded individuals. The group typically holds weekly meetings in Gates Hall.

Project Teams

The College of Engineering has over 20 project teams that allow students of all types of majors to gain hands-on, practical experience in their respective fields. While every project team has a different academic focus, most have some type of software subteam, and computer science students are encouraged to apply to any team that interests them. Computer science fields represented include but are not limited to mobile app development, web development, and software engineering. The general consensus is that students, especially freshmen, shouldn’t be afraid to apply if they have little to no prior experience working on a specific type of project, as many teams tend to accept based on potential and general knowledge of computer science.

Note: Recruitment for project teams generally occur in the very beginning of the semester (early September for Fall and late January/early February for Spring). Do your research early and don’t miss the application deadlines (some project teams recruit only once a year)!

A few of the more CS-focused project teams are listed below. There are many other teams that have roles relevant to CS majors!

Learn more about project teams: http://blogs.cornell.edu/teams/2015-teams/

ACM Programming Team

ACM is a project team devoted to competitive programming. ACM members participate in several programming competitions per year, including the Google Code Jam, the Facebook Hacker Cup, the Topcoder Open, and the ACM-ICPC. In these competitions, teams must create correct and efficient solutions to problems in a limited amount of time. Participating in these coding challenges can help students to think about their product prior to coding and be able to create a correct solution in all corner cases. Skills developed through ACM competitions can also be very useful for technical interviews.

Learn more about ACM:  https://groups.google.com/forum/#!forum/acm-icpc-cornell

Cornell AppDev: Cornell App Development

Cornell AppDev is a project team at Cornell University dedicated to mobile and web application development. The team consists of talented iOS/Android developers, backend developers, and designers who collaborate to bring projects to life. AppDev members work in a startup-like environment and gain practical experience in software development, design, and product management. AppDev also offers three 2-credit, 10-week courses to the Cornell community: Intro to iOS App Development, Principles of Backend Engineering, and Intro to Digital Product Design.

Learn more about Cornell AppDev: http://www.cornellappdev.com/

CDS: Cornell Data Science

Cornell Data Science, or CDS, is a project team that welcomes students of varying experience to learn about the data science field. CDS aims to train members in the cutting edge skills of data science through tech talks by industry experts and educational events led by faculty and other members. In addition to hosting an educational series about basic data science at general body meetings, CDS also recruits members every semester to work on a data science team project led by an experienced (student) project manager.

Learn more about CDS: http://cornelldata.science/

Cornell Design & Tech Initiative

Cornell Design & Tech Initiative is a project team that creates web and mobile apps to address needs on and around Cornell's campus. The team of over 50 developers, designers, and product managers is currently working on 6 different products across campus. Contrary to usual project team demographics, more than half of their members are underclassmen, their gender ratio sits at a healthy 50%, and they together span 6 of the 7 undergraduate colleges. Feel free to reach out to hello@cornelldti.org with any questions!

Learn more about Cornell DTI at www.cornelldti.org/


UNDERGRADUATE RESEARCH

Undergraduate research is a unique opportunity to reinforce topics you are learning about in class and to get experience working on real world projects. If you think you might want to pursue a PhD after graduating, then undergrad research experience is essential.

How to Find a Position

Finding research opportunities is a fairly painless process once you’ve identified a field you’re interested in. Cornell provides a list  of faculty members in each field of computer science and a brief description of their work. If you find faculty members whose work you find interesting, navigate to their webpages and check out their papers to get an overview of the research they do. Send a short (1 - 2 paragraph) email with your resume to these faculty members that describes your background and why you’re interested in their work. If all goes well, you’ll be able to meet in person to discuss opportunities they have available for you.

Preparation

It’s always a good idea to try to read the papers written by the faculty member you’re working under, especially ones that are related to the work you’ll be doing. You should ask which papers to read and the order in which you should read them. These papers will almost certainly be challenging to read since they’re written for an audience of experts in the field, but faculty members are usually willing to walk you through the parts that you have trouble understanding.

What Research is Like

Research is unique from other opportunities available at the undergraduate level in that it is largely self-driven. While faculty members will give you a general overview of the project they want you to work on, they don’t have time to constantly think of things for you to do. This gives you the freedom to set your own pace, but it also means that you’re responsible for the progression of the project.

Getting Credit

Research can be done either for course credit or (if the research group has sufficient resources) for pay. If you opt to take course credit it will appear on your transcript as CS 4999, which can be used to fill a technical elective. The CS department website describes the process in more detail

here.

TESTIMONIALS

Although the purpose of this README document is to provide an objective, unbiased introduction and overview of the major, we also thought it would be beneficial for students, especially underclassmen, to get personal insights from current CS majors of different grades. Note that these perspectives were provided by volunteers who wanted to contribute to the README so the contributors consisted of self-selected individuals, and therefore these testimonials may not be fully representative of the CS population at Cornell. Also note that these testimonials were collected from underclassmen (freshmen & sophomores) due to our target audience. However, we hope that these shared experiences can help shed light on what being a CS major could potentially be like in the Cornell community.


Freshman A

I was drawn to computer science in high school when I learned Java by watching online videos and C by solving problems in a programming book. So I entered college knowing clearly that I would pursue a major in CS.

With my AP credit I skipped the introductory CS course, and faced the hard decision of choosing between CS 2110 and CS 2112. I first read the ACSU README to have a general idea of the differences between the two courses in terms of course material and workload. Next, I contacted students who had already taken the courses for advice, and finally made up my mind to try CS 2112 because I wanted to challenge myself during my first semester of college and also to gain more experience in building and maintaining a large codebase.

Since I had added CS 2112 to my course list and knew that it would take up a large portion of my time, I decided not to take too many credits during my first semester. The other CS class that I took was CS 2800, which turned out to be a nice course to take together with CS 2112. 2112 was project-based, whereas 2800 was problem-set-based and basically involved writing mathematical proofs and solving problem sets. So this combination was a good one, as I could have a nice balance between writing code and solving problem sets. Besides, another advantage of taking them at the same time was that with those two taken, I could select CS classes more freely for my second semester, because CS 2800 teaches fundamental concepts in CS and thus is a prerequisite for many electives.

In terms of the learning experience, CS 2112 truly deserved its reputation as a hard class. The eight homework projects were challenging, especially the last four of them, which together constituted a large project of more than 10,000 lines of code. However, the professor and the teaching assistants were all extremely experienced and helpful, and I found that the homework helped me understand the class materials thoroughly. Taking 2112 was definitely rewarding, and with the experience of handling the heavy workload, I am more confident to face the challenges of future advanced CS courses. So if you don’t know whether CS 2110 or CS 2112 fits you better, try both during the first few weeks and see for yourself which one you can handle better. And a general rule of thumb is that when you are not sure whether a particular class is worth taking, or just want to know if you can handle the workload of the class, always feel free to ask someone who has already taken it for advice.

Finally, some suggestions: first of all, go to office hours! The people there are prepared to help you, and sometimes you may even find a better solution to a problem at hand by just talking to the teaching assistant. (Check out  Rubber duck debugging.) Additionally, look for various opportunities on campus for CS majors, such as teaching or research positions. For instance, if you feel you are doing pretty well in a class and hope to share your passion for the class and help other students, you can apply for a position as a teaching assistant. Lastly, join events held by CS-related student organizations such as ACSU and WICC! They frequently organize events such as guest lectures, the student-faculty luncheon, and at the end of the year, the CS formal.

Freshman B

Coming in, I was pretty certain I was going to stick with CS as a major and taking more classes helped me solidify that decision. However, I was interested in many other fields and was struggling to choose a double major/minor. As of now I'm leaning towards double majoring in Math and CS, which helped me decide to transfer to Arts and Sciences from Engineering because the Math major is not offered in the Engineering school. There's a lot of discussion about whether Arts or Engineering has a better environment for studying CS, but I personally thought being in Arts would be better in approaching the theoretical side of CS I want to explore.

As of adjusting into the CS classes at Cornell, my first CS class was CS 2112, and it was very challenging for me because I'm not a high caliber student and I didn't have any experience in CS except for my chill APCS class I took during high school. Sometime during the second assignment I panicked so hard I dropped the class and told my friend I'm going to give up my CS major and become an AEP major. Then I decided to sit in CS 2110 and realized that I was actually enjoying CS 2112 a lot, so I added the class back in and somehow survived through it. It was definitely painful at times, but I ended up meeting so many talented and motivated people in the class, and I learned so much from the class itself and the people around me. I would definitely recommend to incoming freshmen CS majors to challenge themselves and dive into as many meme-worthy/difficult classes or activities as possible.

Another thing I learned during freshman year was that lectures, office hours, and readings are actually pretty important. This applies to all classes but I think this is good to emphasize. In general, I'm excessively lazy and fairly unmotivated, and that accompanied by my poor time management skills resulted in me skipping hilarious amounts of lectures, doing readings and assignments half-heartedly, and not going to office hours for the past year. Habits are hard to throw away so it's probably going to be a while for me to stop doing this, but I genuinely wish that I realized earlier how important being an earnest student is, especially in CS.

Also, I was surprised to find how welcoming the CS community at Cornell was. There's a lot of diversity in our student population in comparison to other institutions, and I am always proud and happy to tell others that I am a CS major here. Although I have experienced only a year of Cornell so far, I haven't yet felt discriminated because of my gender as a female CS student, and I am grateful for the support for women in computing. Overall, I'm glad that I chose Cornell for studying CS and I hope my remaining years are as, or more, academically intriguing and challenging as my freshman year has been.


Freshman C

My first experience with CS at Cornell was the CS Placement Exam that places you out of Python. I was a student that came to Cornell with little CS experience but was set on the major just because I thought I wouldn’t like anything else. Fast forward and one year later, and my feelings are pretty much the same except that a bond of affection has replaced the indifference to CS (Stockholm syndrome at its finest).  Since I passed the exam, I ended up taking 2110 and 2800 my first semester, which are pretty much the bread and butter (or maybe the flour and the milk that you use to make the bread and butter) of your CS curriculum.  In retrospect, it really doesn’t matter if you take these first or second semester. If you do not take them the first semester, take the time to adjust to Cornell and focus on other things since you will still have the time to take the classes without a rush the next semester. If you do end up taking the classes, be sure to spend an adequate amount of time on them as the concepts never go away, and the effort you put into a class and the challenges you face can benefit you in the long run. Since I was still adjusting to Cornell during that timeframe, I did not understand the importance and the way prelims worked and how they affect your grades and therefore underperformed. I was then encouraged by my peers and closed out the semester with satisfactory results. What I learned the most out of that semester is that you should never be afraid to ask. Asking others for help, even professors, may seem scary at first but you soon come to realize that everyone who is around you wants you to succeed and is sometimes even willing to put in extra time to help. Even if you are starting a project the day it is due both professors and TA’s are still willing to help you learn, as long as you yourself are willing to put in the effort. What I want to pass down is that you should know (or at least think you know) what you want to get out of your first year. In order to know what you want, you have to know what is available. Therefore, don’t hesitate to find out, talk to people, go to events, and start building an answer to that question. Things are always easier when you have a realistic goal.


Freshman D

I remember debating whether to take CS 1110 or CS 2110 my first semester at Cornell. Since I was pretty set on majoring in CS, I went ahead and signed up for CS 2110 because I thought affiliating as soon as possible was my best option. In retrospect, this wasn't the smartest decision I made. Not only did it not help me affiliate sooner, but I also missed out on a chance to learn Python. This obviously doesn't apply to you if you've already mastered Python. If you, however, find yourself in a similar situation, just go ahead and take CS 1110.

Choose your CS partners wisely. Try to become partners with someone with good work ethic and communication skills. If you don't, you will spend countless nights of frustration and misery.

Join ACSU's mentorship program! My mentor told me about various opportunities available to freshmen and helped me decide which classes to take. It's also just nice to have someone older tell you about their experiences and perspectives.

Start assignments early. Go to office hours early. Study for prelims early. Procrastination is the cause of all bad GPAs. I thought I could pull off what I did in high school in college, but people here are way too smart for that.

I personally was very self-conscious about my lack of experience and didn't apply to the programs oriented to underclassmen. Nobody cares that you applied and got rejected, so just apply to everything.

My last advice is to make a lot of friends. Opportunities to make new friends dwindle as years go by, and you will regret it if you don't have friends. After all, CS is no fun if you don't have friends to complain about classes with.


Sophomore A

I decided to become a CS major my second semester freshman year, after I had taken 1110 and 2110 and loved it. Thus as a sophomore, I affiliated with the CS major. I handed in my affiliation form just before the summer, and was notified of acceptance at the start of my first semester sophomore year. Although it is not required that you affiliate with your major until the second semester of sophomore year, I felt it was convenient to affiliate early, as you will be able to get a CS advisor early on, and are allowed to pre-enroll in 4000 level classes that are open to CIS students only during pre-enroll.

 

As for classes taken, once 2110 and 2800 are out of the way in Freshman year, a variety of 3000 and 4000 level classes are open. As an elective, I took CS 4320 and the practicum, CS 4321. At first it was very intimidating to sit in a 4000 level class as a Sophomore, but after a while I realized that courses have prerequisites for a reason, and once you meet those, it does not matter which year you are in the course, as you will already have the prior knowledge necessary to succeed in the course. However, the workload for 3000 and 4000 level classes are considerably larger than what I had experienced in freshman year, which took some time to get used to. In my second semester I took CS 3152, Intro to Game Design, which turned out to have the largest workload in all my classes, but also one of my favorite classes at Cornell. It was an awesome and rewarding experience. Personally, I feel that sophomore year is a year to knock off some core classes such as CS 3110 and 3410/3420, but also take some time to explore the great variety of 4000 level electives out there.

I also took some time during sophomore year to explore TAing opportunities. I was a course consultant for both semesters, and found it very rewarding, because I get to help other students in their coursework, refresh my memory in the concepts that I might have forgotten from class, as well as learn how to explain my thoughts clearly to another person. I would highly recommend TAing some of your favorite classes if you like the class/professor, want to help others, or just want to make some money through this on-campus job.

Overall I find sophomore year a great year to explore opportunities, whether it is enrolling in some interesting 4000 level classes, diving into the internship search, trying out research, or TAing some classes to help your peers. It is your second year, when you are familiar with what Cornell has to offer, but do not have to worry about graduation yet. So make it count.


Sophomore B

It is quite hard to isolate my sophomore CS life from all I have been through at Cornell. I came to Cornell with undecided major and was truly overwhelmed by how many options are out there when I was a freshman. Trying to explore as many subjects as possible in the first year, I had my first CS course, CS 1110, in the spring semester and officially considered CS as a potential major on my list.

Since I was quite determined to be an Economics major, Sophomore life for me was to explore more about CS, make sure if I’m truly interested (because CS is not easy!) and balance the courses between Econ and CS. After taking the courses needed to declare the major, 2110 and 2800, I affiliated the major at the end of the first semester. Although CS advisor would not be assigned until the summer, I still found it better to affiliate early because students in CS major could more easily get the 4000 level course in pre-enroll period. Because I made up my mind to become a CS major in Sophomore year and hadn’t taken a lot of courses before, I just stuck to the CS flowchart and took only one CS core class (CS 3410) in the spring semester. Trying to plan my courses for Economics and CS, I also feel it is wise to decide the majors as early as possible for students with double or triple majors. It helps a lot to reasonably schedule the courses for all majors and college requirements later and to discuss with advisors or other faculty about your questions for future.          

In general, I think sophomore year is for exploring and balancing. As an underclassman, I still had plenty of time to take courses I’m interested in, explore academic activities and college life, and prepare for junior and senior years. Also, don’t worry if you have any questions. There are always people willing to help.


Sophomore C

I already knew I was going to major in CS by the time I was a sophomore, but I had no idea which concentration to focus on, what electives to take, when I was going to take what class... But if I had one piece of advice, I would say definitely affiliate early! You won't necessarily get an advisor earlier, but you'll get the whole affiliating paperwork over and done with before your sophomore year really hits you hard, and you will have a leg up during pre-enroll if you want to get higher-level CS electives. And what you put down on your checklist won't lock you into a certain external specialization or vector--you can change it later very easily.

Affiliating early also helps you get your priorities straight, whether you realize you want to knock out the rest of your college requirements, or if you want to start taking more advanced classes right away. It helped me solidify my strategy going into sophomore year: try to get just one CS core class done per semester so I could really do well in it, finish off most of my engineering requirements, and try a couple of higher-level CS electives. Easier said than done, and I ended up making my sophomore year far too heavy credit-wise such that I was drowning in coursework for most of the time. But the silver lining to that is that I get to have lighter course loads for my next two years!

I guess freshman year, for me, was more about diving into college life and acclimating to a new academic work ethic; sophomore year was more about finding what is good (and really, really bad) for work-life balance. I got a lot more involved with my community, but I was also better at managing my own schedule. The resources and networks at Cornell and within Cornell's CS department are super helpful for getting advice on pretty much anything, so make sure to take advantage of it!


Sophomore D

For me, the prospect of sophomore year was exciting because now that I had finished the basic intro courses in the CS major, I could take more advanced 3000-level courses as well as the entire range of 4000-level electives. I signed up a pretty heavy combination of CS core and elective classes, which was tough and kept me more busy than I ever was freshman year, especially since I had started interviewing with a few companies and needed time to prepare for that. It wasn’t all bad though, because I still enjoyed spending most of my time taking CS courses that I was interested in rather than college requirements I just had to get done with. Two important things I learned this year:

1) Electives (both CS and non-CS) can be really unpredictable -- there were some that sounded cool but ended up dull, and there were some that I took on a whim and ended up loving, so don’t be afraid to go out of your comfort zone and try something different

2) Definitely get out and get involved in activities outside of classes, but also realize that you can’t do everything. Sort out what you want to prioritize and balance accordingly so you don’t burn out.


Sophomore E

I started out comparatively late in computer science (after Freshman year). During my sophomore year, I was hesitant in trying out things because I thought I wasn’t qualified to do them. I was also worried of me being “late” (after all, there are people in the CS department who start CS as early as elementary school). Now, though, I feel that no one really is “late” and all that matters is how much you do and how much you like what you are doing. If anyone is feeling “late” (I had a lot of friends who were in the same boat--one of my friends decided to major in CS in their junior year) rest assured that there is no such thing as “late.” Also, try to talk to as many people as possible and figure out what you need to do. Cool thing that happened to me--I talked to a random guy in my swimming class, and he turned out to be an intern at Microsoft. He told me what I needed to do and how to apply for internships (I didn’t even know how a career fair worked!). The CS community is very large and diverse, so you can always find someone to ask for help.

Sophomore F

Transitioning into sophomore year as a computer science major is perhaps one of the greatest “power spikes” you will have in your four years at Cornell. As a sophomore who had completed his intro courses freshman year, I was able to begin diving into the upper level classes and figuring out for myself where my interests lie. It is also the perfect time to actually see what is ahead of you, in terms of classes to take in order to graduate and internship opportunities that arise because of your new standing and experience. Overall I believe that sophomore year is the time for you to experiment with the opportunities that Cornell gives you. I ended up TA’ing my first class sophomore year which showed me how much more there is to learning the material presented in class and it opened my eyes as to how it is like being on the other side of the table and how much our professors care about us as students. I also ended up taking a dance class which I would place outside of my comfort zone.  Therefore I recommend you take this time and really shaping your life beyond academics and the mentality you built freshman year.  


Junior A

My junior year was a sharp contrast from my underclassmen years. Having completed a good chunk of the requirements for the College of Engineering and the Computer Science core, this was the first year when I started taking 4000-level CS courses that interested me. I found this to be true for a lot of my friends too. Some dedicated their whole semester to their external specializations and other requirements that they didn’t even take a single CS course for a semester. I also found myself much busier than previous years, mostly due to interviews. Unlike freshmen and sophomore years, I found that I got a lot more attention from companies due to my status as a junior. Thankfully, I had a light-enough coursework for me to interview with as many places as I could afford to. Outside of classes, it was also interesting being an upperclassmen rather than an underclassmen. I also found myself taking leadership roles in clubs and getting involved in other activities on-campus as the leader rather than the follower I was in my underclassmen years.

Based on this, these are my tips for a rising junior in Computer Science

  1. Get involved in something outside of classes and interview!
  2. When you interview with places, also look for what the companies have to offer you, and start figuring out which places appeal to you and which places do not; this will pay dividends and save you a lot of time when you start looking for full-time jobs
  3. Challenge yourself with interesting CS electives, but don’t forget to diversify your schedule with classes from other disciplines as well!


Junior B

For me, junior year was all about really exploring the things I was interested in, but also giving myself breathing room to enjoy my experiences at Cornell. With a lot of my engineering college requirements and liberal studies electives out of the way, I was more free to choose specific CS electives. I also started taking up additional responsibilities outside of my normal coursework by becoming a TA and involving myself in my club activities more. Because of this, I feel that being a junior is all about finally striking a good balance between work and play, which is especially important since junior year is when you should definitely be considering post-college options: what kind of work environment you want, what kind of company culture you desire, where you want to move, etc.

A lot of other juniors will be interviewing for summer internships or research positions, so I found it a good idea to get some practice in before the recruiting season to stay on top of my game. However, it becomes really hard to not get down on yourself if you get rejected multiple times--and it’s times like those where you really have to take a step back and tell yourself you’re doing fine. You’re already at Cornell University and in a top CS program, so you’re already in a great position compared to thousands of other people! It’s all well and good to have a goal or dream position you aspire to, but not if you’re wrecking yourself to get there.


Junior C

If freshman year was the NBA draft and sophomore year was the preseason, junior year is the regular season. You are given a much wider breadth of opportunities, and your choices matter all the more.

While some students know exactly what kind of field they want to enter as early as freshman year, I spent my junior year nailing down exactly what I wanted to do. Now that many of the core requirements were out of the way, I was able to explore classes as diverse as machine learning, operating systems, and programming logics. Just taking these at the same time helped me figure out how I really wanted to spend my time.

I found it very difficult to balance my heavy workload with the job/internship search. I advise you to study up on technical interviews as early as possible, and to brush up before the fall of Junior Year, when most companies are looking. It is definitely possible to find a job during the spring, but figuring out your summer plans early helps ease your second semester of the year.

As a junior, you might also find yourself entering leadership roles in the activities you pursue. You will find yourself experienced enough to make authoritative decisions but still young enough to join new groups and make impacts in those groups.

Junior year is also an appropriate time to figure out what you want do after your undergraduate education. It is a good idea to remind yourself of how close you are to fulfilling your graduation requirements, and whether you qualify for early graduation or a higher-education program. Don’t get stuck or caught up in being satisfied with a single goal. Understand you are nearing the end, but remember to be reasonably flexible with your plan.


Senior A

By your senior year, one of your main worries will be what kind of career you want to pursue after graduation. What I’ve come to find out is that questions like these can never be answered in a short amount of time. Throughout your sophomore and junior year, you should always let this question sit in the back of your mind. Often times, it’s easy to get swept up with questions like “which company do smart people work for?” or “which route pays the most?” but in the end, a person’s career is his/her own personal journey. It will bring you happiness and satisfaction to decide to do you want to do based on your preferences alone.

This was something I didn’t learn until I was interviewing for company after company and I realized that I couldn’t even answer a simple question about why I wanted to work at a certain place. It was hard to be genuine when I had applied to the companies that my friends were applying to based on the reputations that my friends had told me. When it came down to making a decision, I was missing the conviction that this career path was what I had been working towards all along. The lesson I learned real late in the game is that to develop a real purpose of wanting to do something, you have to put your own time into doing your own thinking.

CS degree in particular has one of the highest variability in terms of what you can do, and it’s hard to find out what you like and dislike if you don’t try enough things. CS at Cornell has so many paths to offer, and it’s never too late to join a club. I encourage you to try out something you haven’t yet because, in the end, being conscious of your own motivations and goals while being open to trying out new things will go a long way in ultimately helping you define where you will take your career.


Senior B

tl;dr – Appreciate the people around you.

Background

I went into Cornell telling myself “don’t focus on the grades, just try your best” because “the journey is more important than the destination” :P right. I learned the hard way – the journey IS important, but quality is MUCH better than quantity of time spent studying. I focused so much on studying and improving my efficiency at studying that I really undervalued many other aspects at Cornell.

What’s my actual point?

Take a good look around you and appreciate the people you have the privilege of meeting. Sure, you won’t get along with everyone. Sure, when you work on a project and your partner seems hopelessly incompetent (they probably aren’t, you have no idea what’s going on in their life/what they’re going through!), you probably get a little annoyed. And sure, you might have a few housemate problems to work out.

Focus on what their strengths are.

It seems like a no brainer and cliché to focus on the positives and the strengths of people around you, but it’s really easy to focus on negatives, what needs to be done, what can be improved, etc. because let’s face it – we’re human!

I had the most fun at Cornell when I stopped to appreciate people for who they were instead of [constantly] fixating on apartment chores, interviews, prelims, and so on. I took classes in the Human Ecology, ILR, Arts and Sciences, and Engineering colleges my last semester and met a plethora of super diverse, interesting, and awesome people. Although many (including myself) may think that ILR is on the opposite spectrum of CS, I gained a completely different and valuable perspective by taking Intro to Conflict Resolution and Negotiation. I also had the privilege of studying with an ILR student in that class who made me realize that his approach to learning and synthesizing the class material was far superior to my diligent word-for-word note taking and regurgitation (although sometimes this style worked really well for me in other classes!). (*** Tangent: My favorite Cornell class – Human Bonding – was in the Human Ecology school. Yes, I was a CS major. ***)

My advice? Meet people inside AND outside your major/college, appreciate what they bring to the table, [study efficiently,] and enjoy the Cornell experience.