About this course  [  Description  |  How to Do Well  |  Resources  |  Grading  |  Academic Integrity  |  Policies  |  Help  |  Learning Objectives  ]

This course teaches imperative programming in a C-like language and methods for ensuring the correctness of imperative programs. It is intended for students who are familiar with elementary programming concepts such as variables, expressions, loops, arrays, and functions. Given these building blocks, students will learn the process and techniques needed to go from high-level descriptions of algorithms to correct imperative implementations, with specific applications to basic data structures and algorithms. Much of the course will be conducted in a subset of C amenable to verification, with a transition to full C near the end. This will be accomplished along three dimensions:

• The main skill you will get out of this course is the ability to write code that is correct by design and accounts for the needs of its application context. You will learn about deliberate programming as a way to write high quality code, about assessing the performance of a program, and about comparing solutions to satisfy deployment constraints.
• As you do so, you will gain exposure to fundamental concepts in Computer Science — as opposed to programming — such as abstraction, correctness, complexity, and modularity. This will also give you a vocabulary to communicate effectively and precisely with other computer scientists.
• Our vehicle for achieving these objectives will initially be C0, a safe variant of C, and later C itself. Using them, you will gain exposure to a number of data structures and algorithms that are used pervasively in computer science. C is the language of choice for system-level applications, and both are representative of the popular imperative programming paradigm.

After completing 15-122, you will be able to take 15-213 (Introduction to Computer Systems), 15-210 (Parallel and Sequential Data Structures and Algorithms) and 15-214 (Principles of Software System Construction). Other prerequisites or restrictions may apply.

Prerequisites

You must have gotten a 5 on the AP Computer Science A exam or passed 15-112 (Fundamentals of Programming) or equivalent. You may also get permission from an advisor if you performed very high on the CS Assessment on Canvas.
It is strongly advised that you either have taken or take at the same time either 21-127 (Concepts of Mathematics) or 15-151 (Mathematical Foundations of Computer Science): historically, students who did not do so ended up learning less, spending considerably more time on the course and earning one letter grade lower than their peers who did, on average.

Past Offerings

	2025	'24	'23	'22	'21	'20	'19	'18	'17	'16	'15	'14	'13	'12	'11	'10
Fall	F25	F24	F23	F22	F21	F20	F19	F18	F17	F16	F15	F14	F13	F12	F11	F10
Summer	N25	N24	N23	M22	N21	N20	N19	N18	N17	N16	M15	M14	M13	M12	S11
Spring	S25	S24	S23	S22	S21	S20	S19	S18	S17	S16	S15	S14	S13	S12	S11

Our goals are for you to succeed in this course and to teach you skills and concepts that will contribute to your success in life. To this end, we are providing you with lots of resources and the knowledge that comes from years of experience. Talking to some of the thousands of students who took this course before you, here's some advice that they found particularly useful:

• Do not stress over grades: your goal is to learn new and exciting things. Good grades follow naturally from deep learning (but not necessarily vice versa). ...and employers care about what you know not what grade you got.
• Participate: you will get a lot more from this class if you ask questions and engage with the course staff than if you are a fly on the wall — and it will be more fun.
• Manage your time wisely: allocate sufficient time for homework and learning. Little adjustments can save you a whole lot of time later and have a huge impact on your performance. In particular, use class time to learn, review the material presented in lecture the same day, and schedule time for homework proactively.
• Start homework early: racing against a deadline is so stressful! Starting early will remove that stress, lead to deeper learning and give you time to improve your solution if you feel like it.
• Get all the help you need: we provide plenty of resources to help you succeed in this course — office hours every day, online help 24-7, and friendly staff when you need them. Take advantage of them: they are there for you! The only thing we ask is that you plan a bit ahead: helping students takes time and there are not enough of us if everybody waits up to the deadline.
• Make time for fun: take a break from studying at least once a day — meet with friends, go for a walk, play sports, whatever gets you to reset your mind.

Feedback

It is our goal to make this course successful, stimulating and enjoyable. If at any time you feel that the course is not meeting your expectations or you want to provide feedback on how the course is progressing for you, please contact us. If we are not aware about a problem, we won't know to fix it. If you would like to provide anonymous comments, please use the feedback form on the course home page or slide a note under our doors.

Course Material

There is no textbook for this course. Lecture notes and other resources are provided through the Schedule and Handouts tabs of this page, and on . We do not require students to read the course material before lecture, but those who are interested in reading ahead can certainly do so.

The C0 Language

In the first nine weeks, the course uses C0, a safe subset of C augmented with contracts. This language has been specifically designed to support the learning objectives in this course. It provides garbage collection (freeing students from dealing with low-level details of explicit memory management), fixed range modular integer arithmetic (avoiding the complexities of floating point arithmetic and multiple data sizes), an unambiguous language definition (guarding against undefined behavior), and contracts (making code expectations explicit and localizing reasoning).

C0 Tutorial C0 Library Reference C0 Language Reference Debugging C0 Programs Testing programs

C0 at CMU C0 on your own laptop VisualC0

The C Language

In the last five weeks, the course transitions to C in preparation for subsequent systems courses. Emphasis is on transferring positive habits developed with the use of C0, and on practical advice for avoiding the pitfalls and understanding the idiosyncrasies of C. We use the valgrind tool to test proper memory management.

• From C0 to C: Basics tutorial
• C Language Libraries
  • C string library <string.h>
• POSIX library standard — Unix standard library definitions including a library search functionality

Programming Environments

You are welcome to use any programming environment that suits you to write your programming assignments. However, all programming homework will be graded by running them on a Unix system using — you may want to make sure they work on Andrew Unix. Popular environment choices include VSCode, emacs and vim, but you should use what works for you: an environment that allows you to write code quickly and efficiently. Here are some useful links:

We require that you disable AI extensions from your programming environment and in general that you do not use AI tools. These tools may give a quick answer but they undermine learning and retention. (See also Academic Integrity Policy.)

This is a 12 unit course.

Tasks and Points

There are four categories of tasks: HW, CH, AC and FI, defined in the table below. You can earn a maximum of 1000 total points. Your course performance is computed as

min(HW, CH) + AC + FI and is expressed as a percentage by dividing it by 10. Taking the minimum of HW and CH encourages you to gain proficiency on the facet of the course you are least comfortable with.

Category	Points available	Points cap	Description
Homework (HW)	720	720	There are two kinds of homework assignments: 13 weekly practice problems (due on Gradescope Thursdays at 6pm — strict!) 12 weekly programming assignments (due on Autolab Sundays at 9pm — strict!)
Checkins (CH)	780	720	Weekly, in class, closed books, Tuesdays at 7:00pm or 7:45pm depending on section
Precepts/Activities (AC)	39	30	This category combines Friday precepts and daily in-class activities: Each precept is worth 2 points given out based on effort and rough correctness. There will be one activity worth 0.5 points during or after each lecture. Use the activities page to test your configuration and do the current activity (when there is one).
Final Exam (FI)	250	250	3 hours, closed books, on

Checkins and Precepts/Activities operate on the bucket system: there are more points available than what you need to achieve 100% in these categories.

We aim to have homework and checkins graded within two days of submission.

Accessing and Monitoring your Grades

Posted grades are accessible by clicking on the Grades tab of this page. After authenticating, you will see your current grades and a projection of where you are headed given your past performance in the class. Use this application to take action if the trajectory does not lead to the grade you are hoping for.

Evaluation Criteria

Your assignments and exams are evaluated on the basis of:

• Correctness: Your arguments should make sense, your proofs should be valid, and your program should work in the reference environment.
• Elegance: Written material should be of the same quality as what a professional would write. No typos, no bad grammar, clarity is paramount. You are also expected to write code with good programming style. See the Guide to Success on Coding with Style about what constitutes good style.
  For a small subset of assignments, the course staff will review all final submissions by hand. If there are significant style issues, they may give a non-passing grade on style, accompanied by a “FIX STYLE” annotations in their notes. Students who are told to fix their style must address these issues and discuss their revisions with a TA within 5 days of the homework grades being posted. Any TA or instructor can do style re-grading at any office hour; you do not have to go to the TA that assigned the grade.

Late Policy

This is a fast-paced course. The late policy has the purpose to help students from falling behind.

• There are no late days for practice problems.
• Each student has 3 late days for programming assignments and you may use at most one late day for each individual assignment. This means that for exactly 3 programming deadlines you can turn in your assignment within 24 hours after the deadline. Autolab handles these late days automatically — you don't have to email the course staff, just turn in the assignment between 1 second late and 24 hours after the deadline and Autolab will automatically deduct a late day. You can find how many late days you have used by clicking on "Gradebook" in . Once you have run out of late days, will accept and grade late submissions but will assign them 0 points.

  We strongly advise students not to use late days in the first half of the course. Later assignments are more challenging and many courses have lots of deliverables towards the end of the semester. The second half of the semester is where late days are most needed.

Aside from this, there will be no extensions on assignments in general. If you think you really really need an extension on a particular assignment, contact the instructors as soon as possible and before the deadline. Please be aware that extensions are entirely discretionary and will be granted only in exceptional circumstances outside of your control (e.g., due to severe illness or major personal/family emergencies, but not for competitions, club-related events or interviews). The instructors will require confirmation from University Health Services or your academic advisor, as appropriate. If injury, illness, or an emergency will prevent you from taking a scheduled assessment, notify the instructors.

Nearly all situations that make you run late on an assignment can be avoided with proper planning — often just starting early. Here are some examples:

• I have so many deadlines this week: you know your deadlines ahead of time — plan accordingly.
• It's a minute before the deadline and the network is down: you always have multiple submissions — it's foolish to wait for the deadline for your first submission.
• My computer crashed and I lost everything: Use Dropbox or similar to do real-time backup — recover your files onto AFS and finish your homework from a cluster machine.
• My fraternity/sorority/club has that big event that is taking all my time: Schedule your extra-curricular activities around your classes, not vice versa.

Grade Appeals

We make mistakes too!
After each homework assignment and practice activity is graded, you will be able to access your score by clicking on the Grades tab of this page. We will make the utmost effort to be fair and consistent in our grading. If you notice any grading mistakes, proceed as follows:

• Go to office hours and describe the putative grading mistake to a TA.
• If the TA does not resolve the matter convincingly, you may request a regrade as follows: Write an email to explaining where and why you think there was a mistake in grading. Make sure to specify which homework or exam this appeal is for. Write at most 3 lines for each response you are disputing.

Email requests to the course staff will not be accepted. Please do not make regrade requests on .

All regrade requests must be received within 5 days of the work being handed back on or , which we will announce in a post.

Final Grades

This class is not curved. However, to ensure consistency across semesters, we set our grading standards in such a way as to compensate for the relative difficulty of exams.

What follows is a rough guide to how course grades will be established, not a precise formula — we will fine-tune cutoffs and other details as we see fit after the end of the course. This is meant to help you set expectations and take action if your trajectory in the class does not take you to the grade you are hoping for (see also the Grades tab on this page). So, here's a rough, very rough heuristics about the correlation between final grades and total scores:

• A: above 90%
• B: 80-90%
• C: 70-80%
• D: 60-70%

This assumes that the makeup of a student's grade is not wildly anomalous: exceptionally low overall scores on programming assignments, practice problems or checkins will be treated on a case-by-case basis. In particular, students who are unable to demonstrate a basic proficiency with the C language in the last few programming assignments will receive a D in the class (this is because 15-122 is a prerequisite to 15-213, a very C-intensive course).

Precise grade cutoffs will not be discussed at any point during or after the semester. For students very close to grade boundaries, instructors may, at their discretion, consider participation in lecture and precepts, exam performance and overall grade trends when assigning the final grade.

You are expected to comply with the University Policy on Academic Integrity (see also The Word and Understanding Academic Integrity). The university policies and procedures on academic integrity will be applied rigorously. All students are required to fill out a form as part of their first assignment indicating that they understand and accept this policy.

The value of your degree depends on the academic integrity of yourself and your peers in each of your classes. It is expected that, unless otherwise instructed, the work you submit as your own is your own work and not someone or something else's work or a collaboration between yourself and others.

Many students who copy code or other work do so in the heat of the moment and regret their actions later on, when more clear-headed. You may contact the instructors by 2pm the day after a deadline and ask to delete your submissions for an assignment, no questions asked. Deleted submissions are not considered when running academic integrity checks and receive a grade of 0. You may do so at most once during the semester. Contact us before we contact you.