Course Syllabus

Information about this course, CS 70: Data Structures & Program Development, for Spring 2024 (Flipped).

Professors

• Christopher Stone, stone@cs.hmc.edu
• Carter Slocum, cslocum@g.hmc.edu OFFICE HOURS MCGREGOR 327 MW @ 10am

Previous Professors

• Melissa O'Neill, oneill@cs.hmc.edu
• Calden Wloka, cwloka@hmc.edu

Prerequisites

• Either CS 5 & CS 60, or CS 42
• A college-level calculus course

Overview

Building on the computer science foundation you received in CS 60/42, this course develops your programming and problem-analysis skills. It also provides a grounding in fundamental data structures and a solid working understanding of C++. You will learn

• How to write elegant, readable, and maintainable programs.
• How and when to use a range of common data structures, including lists, arrays, stacks, queues, trees, hash tables, and balanced trees.
• How to use a computer’s memory effectively, through C++’s pointers and manual memory management.
• How to work collaboratively on Computer Science problems.
• How to use standard software development tools, including git and Makefiles.

You will also get lots of practice writing software, including some fairly large programs, which should allow you to improve your coding skills and speed. The main affective goal of this course is to help you become an even more sophisticated Computer Scientist than you already are. Many of the concepts in this course will already be familiar to you (e.g., recursion, direct-memory access, linked lists, trees, Big O, recurrence relations, etc.). However, you will deepen and broaden your understanding of these topics, and you will compose these concepts to build more complex and—we hope—more elegant programs than you have written in the past.

This semester the course is designed to be flexible enough to allow both in-person and online learning. Instructional material will be delivered asynchronously for you to work through on your own schedule. In-person class sessions will be primarily devoted to time to work on homework assignments with members of the teaching team nearby to answer questions about the homework or to discuss lesson material. The teaching team will also offer help and support through Piazza

Community & Growth

This course has a diverse population. Some students arrive on day one ready to attempt large, complex C++ programs; other students (the vast majority of the class, in fact) aren’t yet ready. That’s fine, and expected: your “readiness” changes over time and reflects your prior experience, rather than your intelligence, your commitment, or your worth as a person.

We also have a diversity of circumstances. This is always true, but it is especially true under pandemic conditions. Some students will have lots of available time and capacity for focused study and others will need to carefully balance this course with other responsibilities, time/resource constraints, and self-care.

CS 70 works well because we respect and welcome each other no matter what level of “readiness” we are at and no matter what else is piled on our plates. It works because we all support one another in learning. A core goal of this course is to provide practice and guidance so that, by the end, everyone in the class who has put in the effort will be ready to tackle hard problems in a professional manner. If you are finding that the course structures, the instructors, or your peers are not meeting this goal or are not supporting you in the ways that you need, please reach out so we can make adjustments as necessary!

Pair Programming

CS 70 uses the pair-programming methodology for all weekly homework assignments. All homework will be done as a pair, with one joint solution turned in by that pair. Over the course of the semester, you will be part of three different pairs (you can’t choose the same partner twice).

In the pair-programming model, you must spend your time working together on a single piece of code. At any given moment there will be one person typing (the “driver”) and the other making suggestions (the “navigator”); these roles should switch at least every 30 minutes, and possibly much more often.

Under normal circumstances we would require that you be face-to-face with your partner when working on the assignments. If you and your partner find a setting where you feel comfortable and safe doing that, great! This semester, we will also permit remote pair programming, which involves software that allows both partners to interact with the same coding environment as well as interacting with each other through live video chat.

Each line of text and code submitted by a pair must be a true collaborative effort. You will be violating the honor code if, for example, you divide the work such that you work separately, with one person doing part of the work and the other person doing the rest. Obviously it is also an honor code violation if one person does all the work on their own; more subtly, it is also forbidden to submit any work that was technically created while working together, but that only one partner understands.

For a more complete description of best pair-programming practices, and advice on choosing partners, see our Pair-Programming Policy.

Collaboration Outside Your Pair

We love for you to discuss the lecture and reading topics with your classmates! This can range anywhere from informal chats to formal study groups.

You can even discuss high-level features of assignments and the ideas involved, including general approaches to the problems, bugs in the specification, how long you’ve spent working on a problem, and so forth. You may also get or give help with the basic tools and technologies related to completing the assignments: how to use different operating systems (Unix, Mac, or Windows issues), basic C++ language issues, git/GitHub, running the compiler, and the like.

One limit on appropriate outside-of-pair collaboration on homework assignments is the “in your head” rule. When students help each other, they should leave with conceptual understandings in their heads, not physical or electronic artifacts. (If you really understand a concept, you can explain it on demand it without the need for paper notes, whiteboard code, or other crutches.) Thus you are not allowed to meet as a group and leave with notes about the assignments on paper, nor can you help someone fix a bug and then leave without first reverting the code to its unfixed state.

Another general rule is “understanding, not rote learning.” The goal is to help everyone learn, not just to get over an immediate hurdle. If you are helping someone, remember that giving away answers can be detrimental to their understanding; asking leading questions to help guide them to the answer is usually a better approach. Working together as peers and jointly moving together from confusion to understanding is, of course, even better.

Web searches are treated similarly to collaboration outside of a pair: you can use the web to help you use tools and technology, or for getting alternate or additional background on lecture topics, but the web may not be used as a source of code or other specific assignment or exam answers (unless specifically allowed).

Communications and Getting Help

If you have questions about the course (about assignments, course policies, C++, etc.) that you cannot answer yourself, please use Piazza for asynchronous communication (not email); there are more eyes on Piazza so you are more likely to get a quick response.

There are several different ways to get help, ask questions, and otherwise reach out, each with their own purpose. We will use Piazza for asynchronous communication, and professor/grutor office hours either online or in-person for synchronous communication. Please see the Getting Help page for details.

Graders / Tutors (aka “Grutors”)

There are many grutors for this course whose mission in life (at least some of the time) is to help convey the wonder of CS 70! They will be responding to Piazza posts as well as holding regular help sessions online and (hopefully) in person as well. They will also be grading your homework assignments.

Computer and Website Accounts

This course requires you to use four main tools. (Sorry! We've tried to consolidate as much as we can!) These are

• Course Website: This website is the hub for all course content, including course policies, learning material, and homework descriptions.
• Piazza: Most communication about the course, including announcements, requests for help from the instructors, grutors, or fellow students (see the help page for more on Piazza).
• GitHub: Your homework projects will use git for version control, and GitHub for distributing starter code, sharing code with your partner, making your code available to grutors and instructors when asking for help, and for submitting your code when it's due.
• Gradescope: this is where you will ultimately submit your work and view feedback on your submissions.

Coursework & Grading

Course Grade

Your final grade in CS 70 will be calculated as follows:

• 48% Assignments (paired homeworks and individual responses)
• 44% Proficiency checks
•   8% Engagement with lessons and attendance

CS 70 final grades are calculated according to the following grading scale:

Final grades are truncated, not rounded. For example, an 82.8 will receive a B-. Each of these categories of work are described in more detail below.

Because each category (assignments, proficiency checks, class participation, and lesson completion) focuses on different learning goals, it's important for you to demonstrate achievement in all three categories. For example, if you fail most of your proficiency checks, you can't make up for that just by doing great on the assignments and participation. Specifically, if you score less than 50% in any category, we reserve the right to assign a lower letter grade than the above scale would indicate (including D or F).

Assignments

There will be nine main homework assignments during the term, along with a few smaller in-class assignments. Homework assignments will be available by Thursday each week and be due on the following Wednesday night.

Proficiency Checks

Our goal is that through the work in this course you will gain proficiency with a number of core topics and skills. We all (the course staff, your peers, and you) work together to achieve this goal. It is important that we evaluate whether we are collectively succeeding! Some of these skills are best evaluated in the context of your programming projects (debugging, code style, collaboration, etc.). Some are more conceptual. Rather than evaluating your knowledge and skills with traditional one-shot exams, we will regularly check in with you.

Alongside each homework assignment will be a group of four “proficiency checks”—exam-style questions designed to check whether you have gained proficiency in some key concept or topic that you have studied and practiced in the preceding weeks. These checks will be opportunities for you to consolidate what you've learned so your knowledge is firm and at your fingertips as we continue to build on it.

Each proficiency check question must be completed in exam-like conditions. Similarly, like other exams, you may not copy, distribute or otherwise reproduce the questions.

You may not have access to any reference materials, the internet, or other people while you answer these questions. You can take as long as you like, but once you have looked at the first question you must complete each proficiency-check question in one sitting (i.e., no switching to another activity after you've seen the question and coming back later). If you are unsure about how to interpret a question while taking the PC, there is a space to explain any choices you made.

Proficiency checks will be graded either “demonstrated” or “not demonstrated” to indicate whether you have demonstrated proficiency in that topic. Proficiency checks focus on topics and skills that are core to the goals of this course—an incorrect answer often reveals a significant misunderstanding of a critical concept. If you have not passed your check, then we all have more work to do! Not demonstrating proficiency means you should study that topic more intensely and take advantage of office/grutoring hours to fill any gaps in your understanding.

We believe that grading should reflect and reward learning and growth, so your first proficiency check is not your only chance to show your understanding of a topic. At a few points in the semester you will have the opportunity to do a second or third check to demonstrate proficiency in topics that you missed the first time (with different questions on the same topic). During these times you will have no homework assignments and only one weekly lesson so that you can focus on reviewing and studying. These opportunities are scheduled as follows:

• Retry proficiency check groups 0–3: assigned in Week 5
• Retry proficiency check groups 4–6: assigned in Week 10
• Retry proficiency check groups 7–8: assigned in Week 14
• Final try for all checks (groups 0–9): assigned during finals period

In the final try for each proficiency check, we will assign partial credit for demonstrations of partial proficiency (rather than a binary “demonstrated” or “not demonstrated” assessment). There will be a total of 44 proficiency checks. Each check is worth 1 point (earned when you demonstrate proficiency) out of 44 points total.

Because the proficiency checks measure proficiency in what we consider to be the essential goals of CS 70, a letter grade of A is only available to students who demonstrate proficiency in nearly all checks (98% or more).

Engagement with Lessons

Your score in this category will reflect the extent to which you engaged with the online lessons. Each lesson is associated with 1 point, which you earn by completing the lesson. Often the lessons will contain questions for you to think about and answer. Please note that to complete a lesson you must answer all questions but, although we will be able to review your answers, the correctness of your answers does not factor into your grade! You can think of these questions as analogous to questions we might pose during a lecture. Just like in an in-person class, you should take the opportunity to think these through as best you can, but it is totally okay to answer incorrectly or with incomplete understanding; all the better to learn from the differences between your answer and the answer that is ultimately found.

To receive full credit for engagement with a lesson, you must complete the lesson by the end of the week in which it is assigned. You should also have made a genuine attempt at answering the questions in the lesson. If you are unable to complete a lesson by the end of the week, you can still complete it later, but you will received diminished credit for it based on how late it is.

Class Participation

Your score in this category will reflect the extent to which you attend and meaningfully participate in class sessions. Note that you will first engage with new lesson material asynchronously via the online course materials rather than in in-person lectures. Although we won't be covering new content during class meetings, they will still be very important! They will serve as built-in time for you to work with your partner on homework, check in with instructors about the homework and lesson content, and participate in our learning community. We hope that attending class meetings will be valuable to you as an individual, but know that your presence will also be valuable to those around you who will benefit from your questions, your insights, and your collegial spirit.

In order to retain flexibility for quarantines or other disruptions, we will permit virtual attendance via Zoom, although we hope that you will attend class in person unless there is a compelling reason to do otherwise.

For each class meeting, you will fill out a "check-in" on this website, worth 2 points. There you will indicate, on your honor, whether you attended (virtually or in person) and whether you arrived on-time. These are also opportunities to quickly let us know how things are going! Like any other assignment, it is your responsibility to submit these check-ins on time. When calculating the final grade, we will drop the two lowest-scoring check-ins, in effect excusing two absences or forgotten check-ins. Except for extraordinary circumstances or accommodations recommended by the Academic Deans' Office, absence for any reason will result in no credit for that class meeting.

Late Work

Homework and proficiency checks are due on the day indicated (Tuesdays, this semester) at 11:59 PM Pacific Time.

This semester you will work with three different partners: Partner 1 for Homeworks 1–3, Partner 2 for Homeworks 4–6, and Partner 3 for Homeworks 7–8. For each partnership, you and your partner together have one late pass that provides one 24-hour extension on one homework assignment; that is, a “late day.” Unused extensions do not carry over to new partnerships, but each new partnership will have the same single late-pass opportunity.

Note that extending the deadline for a homework assignment does not extend the deadline for that week's proficiency check. These are two separate deadlines for two separate assignments that happen to be at the same time. However, each individual student will have three late passes that can be used to provide you with one 24-hour extension on one group of first-try proficiency checks. You may use these extensions at your discretion, so you could, in principle, use them three weeks in a row, although we wouldn't recommend it! These late passes cannot be used on retries (since you will already have an entire week devoted to retries).

You do not need to tell us that you’re using a “late pass”: the submission system will notice that fact based on your submission time and will “bill” your virtual late-pass account. Homework that is more than 24 hours late or submitted after the deadline when no CS 70 late passes remain results in undefined behavior.

If you know about an upcoming commitment (such as an exam in another course, or a family event you must attend) that could affect your ability to get an assignment done by its deadline, you may ask for an assignment early. We may not always be able to make that happen, but we will try our best. Please notify us at least 24 hours before you need it.

Similarly, if, after starting an assignment, you think it is impossible to accomplish the necessary work in the available time, consult us as soon as possible before the due date. We might be able to offer you some help that would allow you to finish more quickly, or it might be that everyone in the class is having the same problem. The same advice applies if we have scheduled something at a particularly bad time for you (e.g., at the same time as a major deadline for another class) or if there seems to be a bug in an assignment.

Extenuating Circumstances: Unforeseeable Situations Only

Penalty-free extensions for extenuating circumstances are dealt with on a case-by-case basis. In general, you are only excused for situations you could not have foreseen (e.g., your or your partner’s illness), and only if you explain the situation at your earliest opportunity (either directly or via someone else, such as the Dean of Students), before the due date. Planned travel and work for other classes are foreseeable; these events are precisely when you should use the free late passes or ask to obtain the assignment early.

Reminder: The Honor Code

All students—even those from other colleges—are expected to understand and comply with Harvey Mudd College’s expectations of academic integrity as outlined in our Honor Code and in the CS department’s interpretation of that policy.

Specifically,

• You must not exchange literal copies of material, whether that material consists of code, program output, or English-language text (e.g., documentation). You also may not copy material from published or online sources, with or without cosmetic changes (such as altering variable names), without explicit permission. If you do have permission to use externally written material, you must attribute it properly and clearly indicate which material is yours and which material is not yours. Publishing your own homework or exams from CS 70 on the web (e.g., in a public GitHub repository during or after this semester) violates this policy.
• You should not do anything that a reasonable student peer would describe as “subverting the clear intent of the assignment,” unless you have asked for and received permission to do so. Finding open-sourced code that you can use to solve an assigned problem, for example, would typically be subverting the intent of the assignment because your shortcut means that you do not get the practice that the assignment is aiming for.
• If you use any sources to assist you, you must document them. (A clarification about assignment requirements or a debugging tip, however, need not be credited.)
• It is just as bad to copy from your past self as from someone else. In a situation where we are expecting you to do new work, you may not reuse or refer back to substantially similar work you have previously done.
• Similarly, you may not use any kind of AI assistant (such as GitHub Co-Pilot) to write code for this class (or even suggest code you can write). These systems embody a wealth of experience and coding skill—using such a system is like adding a CS senior as a third member of your pair-programming team and just as inappropriate. Allowing another entity, human or AI, to write your code for you and then not disclosing that the code is not your own exclusive work is an Honor Code violation—it violates both the attribution rule and the intent-of-the-assignment rule.
• If you aren’t sure whether something you’ve done or plan to do is allowed, you should explicitly document what you did and—if at all possible—consult with the course staff, ideally before you take the questionable action. Similarly, document any extensive or particularly important help you obtain, even if that help seems perfectly legitimate. If you’ve been helped so much that we can’t consider the work truly your own, you might not be able to get full credit for it but proper attribution will avoid an Honor Code violation.
• Academic integrity also involves being careful enough to avoid unintentionally breaking the rules. Thus, you must read instructions in assignments and exams carefully so that you are aware of any limitations they place on you, such as time restrictions or restrictions on information sources you may consult. Similarly, if you see something that plausibly seems like it ought to be off-limits to you, such as a GitHub directory belonging to another student or files from a previous semester, you should immediately contact us to let us know that something doesn’t seem right, rather than looking further at something that perhaps should have been off-limits.
• These principles apply to all methods and media of discussion or exchange (voice, writing, email, etc.).

Violations of these policies will be reported to the appropriate administrator at your home institution, and handled by the rules and procedures used there.

Accommodations

HMC is committed to providing an inclusive learning environment and support for all students. Students with a disability (including mental health, or chronic or temporary medical conditions) who may need accommodations in order to fully participate in this class are encouraged to contact their home college's accessible-education officer:

Textbooks

All required readings will be available in electronic format. The following books are useful references, but not required:

• Steve McConnell, Code Complete, Second Edition. Microsoft Press, 2004. ISBN 0735619670.
• Stanley B. Lippman et al., C++ Primer, Fifth Edition. Addison-Wesley, 2012. ISBN 0321714113.
• Robert Sedgewick, Algorithms in C++, Parts 1-4: Fundamentals, Data Structures, Sorting, Searching, 3rd Edition. Addison-Wesley, 1998. ISBN 0201350882.

(When logged in, completion status appears here.)

Go to Parent Page Next Page