Don’t be alarmed by the length of this problem’s specification. Most of it is just instructions for getting your programming environment set up and learning how to navigate within it. Once these steps are completed, you’ll be good to go for the rest of the year in CS50 AP!
- Set up your CS50 programming environment.
- Get comfortable with Linux.
- Solve your first problem in C.
- Pages 1 – 7, 9, and 10 of http://www.howstuffworks.com/c.htm.
- Chapters 1 – 5, 9, and 11 – 17 of Absolute Beginner’s Guide to C.
- Chapters 1 – 6 of Programming in C.
This course’s philosophy on academic honesty is best stated as “be reasonable.” The course recognizes that interactions with classmates and others can facilitate mastery of the course’s material. However, there remains a line between enlisting the help of another and submitting the work of another. This policy characterizes both sides of that line.
The essence of all work that you submit to this course must be your own. Collaboration on problems is not permitted (unless explicitly stated otherwise) except to the extent that you may ask classmates and others for help so long as that help does not reduce to another doing your work for you. Generally speaking, when asking for help, you may show your code or writing to others, but you may not view theirs, so long as you and they respect this policy’s other constraints. Collaboration on quizzes and tests is not permitted at all. Collaboration on the final project is permitted to the extent prescribed by its specification.
Below are rules of thumb that (inexhaustively) characterize acts that the course considers reasonable and not reasonable. If in doubt as to whether some act is reasonable, do not commit it until you solicit and receive approval in writing from your instructor. If a violation of this policy is suspected and confirmed, your instructor reserves the right to impose local sanctions on top of any disciplinary outcome that may include an unsatisfactory or failing grade for work submitted or for the course itself.
- Communicating with classmates about problems in English (or some other spoken language).
- Discussing the course’s material with others in order to understand it better.
- Helping a classmate identify a bug in his or her code, such as by viewing, compiling, or running his or her code, even on your own computer.
- Incorporating snippets of code that you find online or elsewhere into your own code, provided that those snippets are not themselves solutions to assigned problems and that you cite the snippets’ origins.
- Reviewing past years’ quizzes, tests, and solutions thereto.
- Sending or showing code that you’ve written to someone, possibly a classmate, so that he or she might help you identify and fix a bug.
- Sharing snippets of your own solutions to problems online so that others might help you identify and fix a bug or other issue.
- Turning to the web or elsewhere for instruction beyond the course’s own, for references, and for solutions to technical difficulties, but not for outright solutions to problems or your own final project.
- Whiteboarding solutions to problems with others using diagrams or pseudocode but not actual code.
- Working with (and even paying) a tutor to help you with the course, provided the tutor does not do your work for you.
- Accessing a solution to some problem prior to (re-)submitting your own.
- Asking a classmate to see his or her solution to a problem before (re-)submitting your own.
- Decompiling, deobfuscating, or disassembling the staff’s solutions to problems.
- Failing to cite (as with comments) the origins of code, writing, or techniques that you discover outside of the course’s own lessons and integrate into your own work, even while respecting this policy’s other constraints.
- Giving or showing to a classmate a solution to a problem when it is he or she, and not you, who is struggling to solve it.
- Looking at another individual’s work during a quiz or test.
- Paying or offering to pay an individual for work that you may submit as (part of) your own.
- Providing or making available solutions to problems to individuals who might take this course in the future.
- Searching for, soliciting, or viewing a quiz’s questions or answers prior to taking the quiz.
- Searching for or soliciting outright solutions to problems online or elsewhere.
- Splitting a problem’s workload with another individual and combining your work (unless explicitly authorized by the problem itself).
- Submitting (after possibly modifying) the work of another individual beyond allowed snippets.
- Submitting the same or similar work to this course that you have submitted or will submit to another.
- Using resources during a quiz beyond those explicitly allowed in the quiz’s instructions.
- Viewing another’s solution to a problem and basing your own solution on it.
Your work on this problem set will be evaluated along four axes primarily.
- To what extent does your code implement the features required by our specification?
- To what extent is your code consistent with our specifications and free of bugs?
- To what extent is your code written well (i.e., clearly, efficiently, elegantly, and/or logically)?
- To what extent is your code readable (i.e., commented and indented with variables aptly named)?
To obtain a passing grade in this course, all students must ordinarily submit all assigned problems unless granted an exception in writing by the instructor.
One of the hurdles that people getting started with programming frequently encounter is configuring their computer environment for programming. One approach would be to buy a new computer, install a programming-friendly operating system on it (such as Ubuntu Linux) on it, and use that! But that’s a pretty big ask.
Another approach is to do what we’ve done in the past. Several years back, our staff put together something called the CS50 Appliance, a “virtual machine” (running Ubuntu) that you can run inside of a window on your own computer, whether you run Windows, Mac OS, or even Linux itself. To do so, all you need is a “hypervisor” (otherwise known as a “virtual machine monitor”), software that tricks the Appliance into thinking that it’s running on “bare metal.”
But why not skip that altogether? After all, wouldn’t you like to get programming right away, without having to download, install, or configure much of anything at all?
We thought you might! So recently Dan, Dan, and Dino, a few members of our staff, prepared a successor to the CS50 Appliance that’s “cloud-based” (remember what that means?) largely using open-source software developed by a company called Cloud9.
So let’s get you set up with your own instance of the so-called CS50 IDE, which we recommend you use for the majority of your programming work in the course.
Go to http://c9.io and sign up for cloud9 using your email and password of your choosing. Do not begin to use the default workspace provided by cloud9. You need to create a CS50 workspace for this class.
Copy and paste (do not click on) the line below into the same browser tab you are current active in:
This should create a new CS50 IDE workspace inside of your newly-created Cloud9 account (called ide50).
On every subsequent visit to c9.io, you should be brought right back to this workspace (if not, just click on the colored avatar in the top-right corner after logging in to be brought to your Cloud9 dashboard, from which you’ll be able to then open your workspace).
When you are finished working in your CS50 IDE workspace in class, it is VERY IMPORTANT that you LOG OUT. You can sign out by clicking on the colored avatar on the upper right hand side of your screen. If you don’t log out, the next student at that computer, may end up working in your workspace.
That wasn’t too bad, right?
Once you’ve got your CS50 IDE instance open in a browser window, have a look over the README file we’ve included with it. It includes some basics about using your new workspace. Don’t worry too much about references to “problem sets” or other terminology or things you haven’t seen before—CS50 IDE is neutrally configured for use with different versions of the CS50 course that won’t be applicable for your progress through CS50 AP.
Let’s now make sure that you have the most up-to-date version of CS50 IDE. To do so, click in the terminal window (conveniently called Terminal) at the bottom of the screen, where by default you should see a prompt which reads:
You are now about to work with a command-line (i.e., text-based) interface via which you can navigate your workspace’s files and directories and run programs by typing their names. Updating the CS50 IDE is pretty easy. Just type
at the prompt and then hit Enter on your keyboard. It may take a while to finish executing, but after a minute or two (depending on the speed of your computer and the quality of your Internet connection), you’ll see the terminal window eventually tells you
All done! <3
after which you are free to continue exploring CS50 IDE.
Okay, let’s create a folder (otherwise known as a directory) in which your code for this problem will soon live. On the left side of the screen you should see a file tree listing the current contents of your CS50 IDE workspace (right now it should simply be a folder entitled
ide50. Right-click in the blank space underneath
ide50 and select New Folder near the bottom of the context menu that pops up. This should create, as expected, a new folder for you entitled New Folder which you can rename now to
unit1. If you accidentally leave it named
New Folder, simply right click on the folder, choose Rename from the context menu, and rename it.
Front and center in the CS50 IDE workspace is a window wherein you’ll be able to write your code, using Ace, a web-based text editor. Right now, assuming you haven’t played around with the tabs, that window is blank.
Let’s create a new file to play around with. Right-click on your newly-created
unit1 folder and choose New File from the context menu. Then, double-click on this new file (which should hopefully be called
Untitled and which should be nested beneath
unit1 in the file tree), and a blank window should open up in Ace with the tab for
Untitled as the active one.
Go ahead and type
hello (or the ever-popular
asdf) on line 1 of the document, and then notice how the tab’s name in Ace is now prefixed with an asterisk (*), indicating that you’ve made changes since the file was first opened. Select File > Save, and that asterisk should disappear, indicating all of our changes are saved.
Untitled isn’t exactly a useful name for this file though, is it? Let’s fix that! In the file tree on the left, right-click on
Untitled and select Rename from the context menu. Enter
hello.txt when able, and then hit Enter on your keyboard. You should see the name of the file has changed both in the file tree on the left and in the name of the tab.
hello.txt still open in your workspace, notice that beneath your document is that terminal window. Notice that the window’s prompt is, assuming you haven’t otherwise manipulated it
username is the username you selected when creating your edX account) which means that you are logged into your workspace and that you are currently inside of
~/workspace (i.e., inside a folder called
workspace which is itself inside your home directory (aka
~)). If that’s the case, based on the file tree should be a
unit1 directory somewhere inside, since we created it just a few moments ago. Let’s confirm as much.
Click somewhere inside of that terminal window and type
and then Enter. That’s a lowercase L and a lowercase S, which is shorthand notation for “list.” Indeed, you should then see a list of the folders inside of your workspace directory, among which is
unit1! Let’s open that folder! Type
followed by Enter to change your directory to ~/workspace/unit1 (ergo,
cd). You should find that your prompt changes to
confirming that you are indeed now inside of
~/workspace/unit1 (i.e., a directory called
unit1 inside of a directory called
workspace inside of your home directory). Now type
followed by Enter. You should see
hello.txt! Now, you can’t click or double-click on that file’s name there; it’s just text. But that listing does confirm that
hello.txt is where we hoped it would be.
Let’s poke around a bit more. Go ahead and type
and then Enter. If you don’t provide
cd with a “command-line argument” (i.e., a directory’s name), it whisks you back to your home directory by default. Indeed, your prompt should now be:
Phew, home sweet home. Remember though that everything we create in the CS50 IDE will ultimately live inside of
workspace, so just:
to return to where everything started. Make sense? If not, no worries; it soon will! It’s in this terminal window that you’ll soon be compiling your first program! For now, though, close Ace by clicking the small “x” in the tab for
hello.txt (if you’ve made additional changes, you’ll be asked if you want to save your file before the tab closes).
First, a hello from Zamyla if you’d like a tour of what’s to come, particularly if less comfortable. Note that in this video, she is using the CS50 Appliance, which is somewhat different from the CS50 IDE, but not a problem.
Shall we have you write your first program? You could go ahead create a new file inside of your
unit1 directory and save the file as
hello.txt), just as before (remember how?), but we’ll also take this opportunity to show you another way. In the terminal window, type
and then, after confirming that you are in the right spot by looking at your prompt, type
after a few moments, you should see
hello.c has been created inside of your
unit1 directory. Neat! Double-click on that file in the file tree to edit it, as before, then go ahead and write your first program by typing these lines into the file (though you’re welcome to change the words between quotes to whatever you’d like):
Notice how Ace adds “syntax highlighting” (i.e., color) as you type. Those colors aren’t actually saved inside of the file itself; they’re just added by Ace to make certain syntax stand out. Had you not saved the file as
hello.c from the start, Ace wouldn’t know (per the filename’s extension) that you’re writing C code, in which case those colors would be absent.
Do be sure that you type in this program just right, else you’re about to experience your first bug! In particular, capitalization matters, so don’t accidentally capitalize words (unless they’re between those two quotes). And don’t overlook that one semicolon. C is quite nitpicky!
When done typing, select File > Save (or hit ctrl-s), but don’t close the tab. Recall that the leading asterisk in the tab’s name should then disappear. Click anywhere in the terminal window beneath your code. The prompt itself should now be
If it’s not, navigate yourself there. (Remember how?)
hello.c should exist in this folder, assuming everything’s gone according to plan. Let’s confirm that
hello.c is there. Type
at the prompt followed by Enter, and you should see both
hello.txt? If not, no worries; you probably just missed a small step. Best to restart these past several steps or ask for help!
Assuming you indeed see
hello.c, let’s try to compile! Cross your fingers and then type
at the prompt, followed by Enter. (Well, maybe don’t cross your fingers whilst typing.) To be clear, type only
hello here, not
hello.c. You’ll likely see a line that looks like the following immediately after hitting Enter
clang -ggdb3 -O0 -std=c99 -Wall -Werror hello.c -lcs50 -lm -o hello
If after that all that you see is another, identical prompt, that means it worked! Your source code has been translated to object code (0s and 1s) that you can now execute. Cool! Type
at your prompt, followed by Enter, and you should see whatever message you wrote between quotes in your code! Indeed, if you type
followed by Enter, you should see a new file,
If, though, upon running
make, you instead see some error(s), it’s time to debug! (If the terminal window’s too small to see everything, click and drag its top border upward to increase its height.) If you see an error like expected declaration or something no less mysterious, odds are you made a syntax error (i.e., typo) by omitting some character or adding something in the wrong place. Scour your code for any differences vis-à-vis the template above. It’s easy to miss the slightest of things when learning to program, so do compare your code against ours character by character; odds are the mistake(s) will jump out! Anytime you make changes to your own code, just remember to re-save via File > Save (or ctrl-s), then re-click inside of the terminal window, and then re-type
at your prompt, followed by Enter. (Just be sure that you are inside of
~/workspace/unit1 within your terminal window, as your prompt will confirm or deny.) If you see no more errors, try running your program by typing
at your prompt, followed by Enter! Hopefully you now see precisely the below?
If not, reach out for help!
Woo hoo! You’ve begun to program!
Now let’s see if the program you just wrote is correct! Included in the CS50 IDE is
check50, a command-line program with which you can check the correctness of (some of) your programs.
If not already there, navigate your way to
~/workspace/unit1 (Remember how?)
If you then execute
you should see, at least,
hello.c. Be sure it’s indeed spelled
hello.c and not
hello.C, or the like, as filenames on CS50 IDE and indeed most Linux operating systems are case-sensitive. If it’s not, know that you can rename a file in the terminal (as opposed to right-clicking in the file tree) by executing
mv source destination
source is the file’s current name, and
destination is the file’s new name. For instance, if you accidentally named your program
Hello.c, you could fix it as follows.
mv Hello.c hello.c
Okay, assuming your file’s name is definitely spelled
hello.c now, go ahead and execute the below. Note that
1516.unit1.hello is just a unique identifier for this problem’s checks. We’ll always specify exactly the unique identifier you should use to check your programs’ correctness.
check50 1516.unit1.hello hello.c
Assuming your program is correct, you should then see output like
:) hello.c exists :) hello.c compiles :) prints "hello, world\n"
where each green smiley means your program passed a check (i.e., test). You may also see a URL at the bottom of
check50‘s output, but that’s something your teacher might use when checking your code (though you’re welcome to visit it nonetheless).
If you instead see yellow or red smileys, it means your code isn’t correct! For instance, suppose you instead see the below.
:( hello.c exists \ expected hello.c to exist :| hello.c compiles \ can't check until a frown turns upside down :| prints "hello, world\n" \ can't check until a frown turns upside down
check50 doesn’t think
hello.c exists, as per the red smiley, odds are you uploaded the wrong file or misnamed your file. The other smileys, meanwhile, are yellow because those checks are dependent on
hello.c existing, and so they weren’t even run.
Suppose instead you see the below.
:) hello.c exists :) hello.c compiles :( prints "hello, world\n" \ expected output, but not "hello, world"
Odds are, in this case, you printed something other than
hello, world\n verbatim, per the spec’s expectations. In particular, the above suggests you printed
hello, world, without a trailing newline (
\n). See why?
check50 lets you check your work’s correctness before you submit your work. Once you actually submit your work (per the directions at this spec’s end), your teacher will use
check50 to evaluate your work’s correctness officially.
In addition to
check50, the CS50 IDE comes with
style50, a tool with which you can evaluate your code’s style vis-à-vis CS50’s style guide. To run it on, say,
hello.c, execute the below:
You should see zero or more lines of suggestions. Yellow smileys indicate warnings that you should consider addressing. Red smileys indicate errors that you should definitely address.
style50 is still a work in progress (a “beta” version, so to speak), so best to consult CS50’s style guide for official guidance.
And how about that? You’ve written your first C program and configured your CS50 environment! Not too shabby.
This was Problem 1-2.
workspacefolder is renamed to
ide50, the actual name of the workspace in question, but rest assured that
ide50in the file tree corresponds to
workspacein the terminal window.