Mark A. Sheldon, Associate Teaching ProfessorDepartment of Computer Science
Tufts University
Joyce Cummings Center, Room 440C
177 College Avenue
Medford, MA 02155 USA
| Email: |  |
| Web page: | http://www.cs.tufts.edu/~msheldon/ |
| Phone: | 617-627-2491 |
| Fax: | 617-627-2227 |
Office hours for Fall 2024: Th 1:30–3:00, Fr 1:30--2:45, and by appointment (in person)
- Graduation instructions, including links to forms and instructions for submitting them
- Should I take CS 11 or CS 15?
- Information for those interested in CS 21 Concurrent Programming (2024 Spring)
- Thoughts on auditing
- Advice on asking for recommendations
- Information/advice about the CS Minor
- How to get involved in research
- Syllabi for past courses with me
- Some of Prof. Chow's advice on career prep
Should I take CS 11 or CS 15?
Many incoming students or others with some programming experience are curious about whether they should take CS 11 (Introduction to Computer Science) or CS 15 (Data Structures). There is no single right answer. I've written the following guide to thinking about the choice. Also note that being a first-semester college student (or transfer student) takes up about 2–3 credits worth of brain space. That is also something to keep in mind.
CS 11 and CS 15 currently both use C++. CS 11 covers
problem solving and basic programming skills from
scratch — no experience necessary. You'll learn about how to
break a problem down and solve it in a well-structured program, which
means encoding your solution in a way that a computer can execute.
This means that you'll learn something about how computers work, too.
The programming tools you'll learn to apply to problems include
values, variables, expressions, conditional execution (if
statements), functions, recursion, loops, arrays, structs, and
classes. All of these tools are pretty common in introductory courses
students might take elsewhere (though recursion is often skipped).
Unlike most courses students have elsewhere, students also learn about computer memory organization, pointers, and manual allocation and deallocation of memory (array lists, sometimes called vectors or dynamic arrays, and linked lists). All of this is done on our department computers, which run the GNU/Linux operating system.
CS 11 also includes two or three substantial programming projects, the last of which requires the student to manage memory in an application with 2 – 3 classes
CS 15 starts from there. My alternative name for CS 15 is
“Data abstractions every working programmer must know: their
applications, interfaces, implementations, and costs.” It covers
a variety of data abstractions that can be employed in many practical
applications, their implementations and performance tradeoffs.
Students solve larger problems and write larger programs, all of which
require multiple source files. Students also learn more about memory
management, use recursion a lot more, employ the
Unix make utility to build their programs, and
do unit testing. CS 15 also includes two (or three)
substantial programming projects that are more complex than those in
CS 11 and that involve making choices about data structures and
their implementations.
Students with a strong programming background would be bored in CS 11 for the first two thirds of the course. In the final month or so of the term, you work on larger projects (and use pointers), so most students with a high school background are challenged by the end of the course.
If you skip CS 11, then, if you don't know about pointers, memory allocation/deallocation, and Unix, then you'll have to learn those skills in CS 15. It's doable, and we support students during the transition, but it will be substantially more work for the first 3 – 5 weeks while you catch up on those topics.
If you have a busy schedule and are settling in to college, then it might make sense to take the easier course, reinforce the skills you have and acquire a few more — take CS 11 (but don't complain that you already know the material for the first part of the course).
If you are up for a challenge and are willing to do extra work, or if you already know about pointers, then take CS 15.
Finally, as a rough guide:
- If you have a background in programming using C++ and know about
classes, pointers,
new, anddelete, then you'll probably be ok in CS 15. If your background is in C, and you are comfortable with pointers, then you'll have to work to come up to speed on data abstraction with classes, but CS 15 should be in reach. - If your background is in Java, then it will be substantially more work, even though you probably understand how to use classes better than is necessary. While the languages are syntactically similar, their memory models are different. As I said above, many, but not all, students succeed with this background. Expect to work at least twice as hard as students coming from CS 11 for the first month or two.
- If your background is in Python, then you have a larger gap to make up: you'll need to learn a new syntax plus static typing, a different way of building and running programs, and a lot about how memory works at a lower level. It's probably best to take CS 11.
- If you have never done a project that requires ~1000 lines of code and 2–3 classes, then you might consider taking CS 11 to build up your programming experience.
- If you want to pick up or brush up on your C++ programming,
then, that's great. I don't have any good recommendations for
on-line resources, but I'm sure there are some. (Hint: The first
CS 15 homework usually involves implementing what Java calls
an ArrayList. If you can implement
an
ArrayListfor some type in C++, then you'll be all set for Homework 1!) - If you are not familiar with Linux or Unix systems, then, if you take CS 15, you should sit in on the first CS 11 lab (with the permission of the instructor) and learn the basics of getting around and compiling a program in Linux.
If you are considering skipping CS 11, I recommend that you look at CS 11 review material on structs, memory, pointers, classes, and data abstraction. There, you'll find notes, lecture videos, and practice exercises on some of the later CS 11 topics. If you are ok with that material, that is a good sign that you might be ready for CS 15.
You may choose to give CS 15 a try for a week and then switch to CS 11 if there is space. Going the other way is not recommended: coming in after others are well along in the transition will put you way too far behind.
Auditing
Students often ask about auditing a course, like CS 11, 15, 40, etc. Generally, I'm not a fan of auditing a programming course. If you don't actually do the work, you won't get any benefit at all: lectures are ok, but you won't build programming skills without programming (just like watching videos of people riding a bike won't enable you to ride a bike). On the other hand, if you are doing the work, then you may as well take the class.If you're not in the class, but using staff resources to answer questions and grade your work, then you are competing with people who are paying for the course.
So, my position is, assuming there is room: You are welcome to attend lectures and do the work on your own, but you should not submit work for evaluation. For lab courses, you may join a lab only if there is space in that lab, but you can't displace a registered student. For 11 and 15, there are usually a few labs with small enrollments: See on SIS which ones those are.
Come to class on the first day, and, if there is room and you understand the restrictions above, I'll sign an audit form.
Also, you will need an EECS login to participate in class. Please
see the EECS IT help desk folks to get an account. Their offices
are in the very back of the second floor of Halligan, and their
email is staff@eecs.tufts.edu
Teaching