Week 2

We introduced programming with Scratch, and last week we learned a little bit of C, a textual language.

Our first, simple program just printed out hello, world:

#include <stdio.h>

int main(void)
{
    printf("hello, world\n");
}

We also learned to use CS50 IDE.

And concepts like:

And functions in C like printf, but really in essence they had analogies in Scratch, like the purple say block.

We learned to include the CS50 library, with helpful functions like:

And data types like:

We also ran into some limits of computing, like integer overflow or float imprecision, which could have severe real-world impact.

Commonly, errors come from our compiler, make or clang, as we’ll demonstrate:

int main(void)
{
    printf("hello, world\n");
}

Now if we make our new file, everything should work.

#include <stdio.h>

int main(void)
{
    printf("hello, world\n");
}

The first problem set introduced you to help50, a command written by staff which will help explain some errors that you still don’t understand.

Now let’s try another buggy program:

#include <stdio.h>

int main(void)
{
    string s = get_string();
    printf("hello, %s\n", s);
}

Now let’s try to print a # 10 times:

#include <stdio.h>

int main(void)
{
    for (int i = 0; i <= 10; i++)
    {
        printf("#\n");
    }
}

We can compile this without any issues, but when we run it, we see 11 # symbols, not 10 like we wanted.

So let’s include a new function from the CS50 Library, eprintf, that prints out errors (or anything we want to mark as special) to the screen:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    for (int i = 0; i <= 10; i++)
    {
        printf("#\n");
        eprintf("i is now %i\n", i);
    }
}

Now we see a bunch of input:

~/workspace/ $ ./buggy0
#
buggy0:buggy0.c:9: i is now 0
#
buggy0:buggy0.c:9: i is now 1
#
buggy0:buggy0.c:9: i is now 2
#
buggy0:buggy0.c:9: i is now 3
#
buggy0:buggy0.c:9: i is now 4
#
buggy0:buggy0.c:9: i is now 5
#
buggy0:buggy0.c:9: i is now 6
#
buggy0:buggy0.c:9: i is now 7
#
buggy0:buggy0.c:9: i is now 8
#
buggy0:buggy0.c:9: i is now 9
#
buggy0:buggy0.c:9: i is now 10

Let’s try one more:

#include <cs50.h>
#include <stdio.h>

int get_negative_int();

int main(void)
{
    int i = get_negative_int();
    printf("%i is a negative integer\n", i);
}

int get_negative_int(void)
{
    int n;
    do
    {
        printf("n is ");
        n = get_int();
    }
    while (n > 0);
    return n;
}

Let’s run:

~/workspace/ $ debug50 ./buggy3
n is

But if we type in a number for our program, it seems to do the normal thing and tell us it’s exiting:

~/workspace/ $ debug50 ./buggy3
n is -1
-1 is a negative integer

Child exited with status 0
GDBserver exiting

~/workspace/ $

So we can click in the extra space next to a line, and a red dot will appear, which will tell the debugger to pause the program:

Now as soon as we run the same command, we’ll stop at that line and the debugger will tell us about our variables:

So now let’s click the button next to the blue triangle at the top (which reads Step Over if you hover over it), which runs this line.

And now in our terminal we’ll see the prompt, and if we type in -1 to the prompt again, we’ll see that our variable has changed in the debugger. We’ll also see the line we’re on under Call Stack in the debugger, and if we press the Step Over button again, we’ll see our -1 printed out. Finally, if we press Step Over one last time (on the ending brace for main in our program), everything is complete and exits like before.

Let’s run it again with the same command, but this time instead of clicking Step Over, we’ll click the button next to it (that looks like an arrow pointing downwards), and Step Into the function.

And all of a sudden we’ll jump to the first statement (the others are declaring variables and constructs, but not doing anything) in our get_negative_int function:

There’s another, less technical way to debug called rubber duck debugging. When a programmer is working alone, it’s a useful technique for them to imagine having a toy rubber duck, and explaining their code to the rubber duck. Sometimes, hearing ourselves give an explanation out loud can be useful in realizing where our errors might be!

And if that doesn’t work out, CS50 has a whole support staff ready to help!

CS50 Problem Sets are evaluated on 4 axes, scope, correctness, design, and style.

Each of these axes will have a grade ranging from 1 to 5, and there’s no need to worry about scores of 3s, with some 2s and 4s, in the beginning, since you’ll have lots of room to grow and improve over the semester.

The axes are also weighted with the following formula:

CS50 also takes academic honesty very seriously, and over years there’s been a small, but significant fraction of students who have been involved in issues. Since we have the technological ability to compare all submissions to problem sets to each other, and past years, and any sources online, we tend to catch more cases than other courses.

Our policy can be shortened to just "Be reasonable." And more descriptively, "The essence of all work you submit to this course must be your own."

We’re happy to allow classmates, TFs, friends to help you, but "…​ when asking for help, you may show your code to others, but you may not view theirs …​"

This is explained more in the syllabus, and if you still have questions, please reach out to David or our head TFs for guidance!

We also have a regret clause, "If you commit some act that is not reasonable but bring it to the attention of the course’s heads within 72 hours, the course may impose local sanctions that may include an unsatisfactory or failing grade for work submitted, but the course will not refer the matter for further disciplinary action except in cases of repeated acts."

Now we dive into our first real-world application, crytography, or the ability to send and receive secret (encrypted) messages.

We watch a short clip from the movie A Christmas Story, where a child, Ralphie, excitedly decodes a secret message from the radio with a ring that maps letters to other letters, only to find that it is just an advertisement for Ovaltine, a beverage popular many years ago.

A method like that can be categorized as secret-key cryptography, where the sender and the receiver know some secret value, code, or phrase that can be used to encrypt and decrypt information.

Cryptography can also be reduced to an algorithm that takes inputs and produces outputs.

Inputs are the key and plaintext, or the message in unencrypted form that anyone can read, and the output is the ciphertext, or the encrypted message that only someone with the key can decrypt, or unscramble.

So let’s start by figuring out what a string really is. It’s a sequence of characters, in an array (a list of things right next to each other) in memory.

If we wanted to store Zamyla’s name, Zamyla, we’d put each character in a box:

-------------------------
| Z | a | m | y | l | a |
-------------------------

And this is important beacause we want to change one character at a time, say A to B and B to C.

We can see this in action with the following program:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    string s = get_string();
    for (int i = 0; i < strlen(s); i++)
    {
        printf("%c\n", s[i]);
    }
}

But what happens if, say, a user types in a really really long string or does something that causes an error? Well, get_string(), and certain other functions in C, can return a special value called NULL. And so to be safe, it’s good practice to check that s is not NULL before we try to do something with it:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    string s = get_string();
    if (s != NULL)
    {
        for (int i = 0; i < strlen(s); i++)
        {
            printf("%c\n", s[i]);
        }
    }
}

So now our program, if we just wanted it to print each character on a line, would be correct. But how might we improve the design? Well, recall that a for loop first initializes a value, checks a condition, and after each iteration, increments the value. So on each pass of the loop, we’re checking if i < strlen(s). But strlen() is a function that we call, passing it s as an argument, and using the value it returns to compare with i. Each time, we’re calculating the length of the string even though we don’t have to. A better solution might look like this:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    string s = get_string();
    if (s != NULL)
    {
        for (int i = 0, n = strlen(s); i < n; i++)
        {
            printf("%c\n", s[i]);
        }
    }
}

For style, our variable names are short, since we only have a few of them. We could comment our code:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // ask user for input
    string s = get_string();

    // make sure get_string returned a string
    if (s != NULL)
    {
        // iterate over the characters in s one at a time
        for (int i = 0, n = strlen(s); i < n; i++)
        {
            // print i'th character in s
            printf("%c\n", s[i]);
        }
    }
}

In C, there’s another feature called typecasting that lets you convert one type of data to another. Characters are stored in memory as binary numbers, so we can convert them back and forth.

Remember that ASCII is a standard for mapping characters to letters. Here are some sample ones:

A   B   C   D   E   F   G   H   I  ...
65  66  67  68  69  70  71  72  73  ...

a   b   c   d   e   f   g   h   i   ...
97  98  99  100 101 102 103 104 105 ...

We can experiment with this program:

#include <stdio.h>

int main(void)
{
    for (int i = 65; i < 65 + 26; i++)
    {
        printf("%c is %i\n", (char) i, i);
    }
}

Now if we compile and run our program, we get:

A is 65
B is 66
C is 67
...
Z is 90

But we can actually just say printf("%c is %i\n", i, i);, and i will be printed out as a character too, since printf knows %c means that i should be formatted as a character.

But wait, if we can treat numbers like characters, we can also treat characters like numbers:

#include <stdio.h>

int main(void)
{
    for (char c = 'A'; c <= 'Z'; c++)
    {
        printf("%c is %i\n", c, c);
    }
}

There’s another pattern with ASCII characters: a lowercase letter has a value exactly 32 higher than the same letter in uppercase.

Maybe we can apply this:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    string s = get_string();
    if (s != NULL)
    {
        for (int i = 0, n = strlen(s); i < n; i++)
        {
            if (s[i] >= 'a' && s[i] <= 'z')
            {
                printf("%c", s[i] - ('a' - 'A'));
            }
            else
            {
                printf("%c", s[i]);
            }
        }
        printf("\n");
    }
}

But we could even use a function that comes with C, toupper, in the library ctype.h (and we’d discover it through looking around reference books or online):

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    string s = get_string();
    if (s != NULL)
    {
        for (int i = 0, n = strlen(s); i < n; i++)
        {
            if (islower(s[i]))
            {
                printf("%c", toupper(s[i]));
            }
            else
            {
                printf("%c", s[i]);
            }
        }
        printf("\n");
    }
}

And in fact, toupper only changes lowercase letters to uppercase, so we can really just:

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    string s = get_string();
    if (s != NULL)
    {
        for (int i = 0, n = strlen(s); i < n; i++)
        {
            printf("%c", toupper(s[i]));
        }
        printf("\n");
    }
}

Let’s go even further in exploring strings by trying to implement a different function, strlen, ourselves:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    string s = get_string();
    int n = 0;
    while (s[n] != '\0')
    {
        n++;
    }
    printf("%i\n", n);
}

We can represent more of our computer’s memory as a grid:

-----------------------------------
| Z | a | m | y  | l | a | \0 | A |
-----------------------------------
| n | d | i | \0 |   |   |    |   |
-----------------------------------
|   |   |   |    |   |   |    |   |
-----------------------------------
|   |   |   |    |   |   |    |   |
-----------------------------------

Integers, and other data types, too, are stored in the same way in memory, even if they take up more bytes.

Once we understand that data is just bytes in memory, we can manipulate all of it and can do everything by writing a program.

And https://reference.cs50.net has lots of useful information too, about functions that come with C.

Let’s use what we’ve learned to dig deeper into command-line arguments.

So far, we’ve used int main(void) to start our programs. The void keyword in particular is indicating that our program takes no arguments.

But what if we want to write programs that take input from the command line, or words after the program name when we run it in the terminal? For example, we might run make hello or make cough0, and the second word there is an argument to our program hello.

It turns out, we can start our program with this: int main(int argc, string argv[]) and it will receive those command-line arguments.

Now our program will receive two arguments. The first is an integer named argc, as in argument count, that tells us how many arguments we got. The second is an array, or list, of strings, called argv, as in argument vector. This list of strings can be accessed with the same syntax as we do for characters in a string (since a string is just an array of characters), like argv[0].

Let’s see this in action:

#include <cs50.h>
#include <stdio.h>

int main(int argc, string argv[])
{
    if (argc == 2)
    {
        printf("hello, %s\n", argv[1]);
    }
    else
    {
        printf("hello, world\n");
    }
}

Let’s do this, to see how we can iterate over an array:

#include <cs50.h>
#include <stdio.h>

int main(int argc, string argv[])
{
    for (int i = 0; i < argc; i++)
    {
        printf("%s\n", argv[i]);
    }
}

We can be even cooler. Since we know argv is an array of strings and each string is an array of characters, we can directly access characters from argv:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(int argc, string argv[])
{
    // iterate over strings in argv
    for (int i = 0; i < argc; i++)
    {
        // iterate over characters in current string
        for (int j = 0, n = strlen(argv[i]); j < n; j++)
        {
            // print j'th character in i'th string
            printf("%c\n", argv[i][j]);
        }
        printf("\n");
    }
}

So what about main's output? It turns out, main also returns some value by default. When a program exits successfully, it returns a number 0 to indicate as much. A non-zero number, on the other hand, is used to represent an error.

Of course, we want to see this firsthand:

#include <cs50.h>
#include <stdio.h>

int main(int argc, string argv[])
{
    if (argc != 2)
    {
        printf("missing command-line argument\n");
        return 1;
    }
    printf("hello, %s\n", argv[1]);
    return 0;
}

We can see the exit code in terminal like this:

~/workspace/ $ ./exit
missing command-line argument
~/workspace/ $ echo $?
1

Don’t forget, an array is a chunk of continuous memory, with each of the elements inside contiguous, back-to-back-to-back. And those elements are generally the same data type, as we commonly have arrays of characters or integers. We’ll need this construct to solve more complex problems, like sorting and searching.

Phew, what an exciting day! More fun to come next week!