Introduction to C & Environment Setup

xcode-select --install

A dialog box will appear. Click "Install" and wait for the download to finish (it may take 10-15 minutes). This installs the Xcode Command Line Tools, which include GCC (actually, on macOS, gcc is typically an alias for Clang, Apple's compiler, but it works identically for our purposes).

To verify the installation, type:

gcc --version

You should see version information appear. If you do, you're ready!

Linux (Ubuntu/Debian): Open your terminal and run:

sudo apt update
sudo apt install build-essential

The build-essential package includes GCC, the make utility, and other development essentials. Verify with gcc --version.

Linux (Fedora/RHEL): In your terminal:

 class="language-bash">sudo dnf groupinstall "Development Tools"

Windows: You have two good options:

• MinGW-w64: Download from mingw-w64.org. During installation, select the x86_64 architecture. After installation, add the bin folder (typically C:\mingw-w64\...\bin) to your system PATH.
• WSL (Windows Subsystem for Linux): This gives you a full Linux terminal inside Windows. Install from the Microsoft Store, then follow the Linux instructions above. This is the recommended approach if you plan to do serious C development.

4. Your First C Program: Hello, World!

Tradition dictates that every programmer's first program prints "Hello, World!" to the screen. This simple program teaches us the essential structure of every C program. Create a file called hello.c using any text editor (VS Code, Sublime Text, or even Notepad) and type the following exactly

#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

Line-by-Line Breakdown: What Every Character Means

Let's walk through each line slowly. Understanding this completely will make the rest of your C journey much smoother.

Line 1: #include <stdio.h>

This is a preprocessor directive. The # symbol tells the compiler that this line should be processed before actual compilation begins. include literally means "copy and paste the contents of this file here." The file stdio.h (Standard Input/Output header) contains declarations for functions like printf() that let us interact with the console. The angle brackets < > tell the preprocessor to look in the standard system directories for this file. Without this line, the compiler wouldn't know what printf means!

Line 2: (blank)

Blank lines are ignored by C. Use them freely to make your code readable. Good programmers use whitespace like paragraphs in an essay.

Line 3: int main() {

This is the entry point of your program. When you run your compiled executable, the operating system looks for a function called main and starts executing there. Every C program must have exactly one main function. The int before it means "this function will return an integer (a whole number) to the operating system when it finishes." The open curly brace { marks the beginning of the function's body—everything between { and } belongs to main.

Line 4: printf("Hello, World!\n");

This is where the magic happens. printf stands for "print formatted." It sends text to your console (the terminal window). Everything inside the double quotes is printed literally—except for \n, which is an escape sequence meaning "newline" (move the cursor to the next line). The backslash \ is C's escape character. The semicolon ; at the end is crucial—in C, every statement must end with a semicolon. Think of it as the period at the end of a sentence.

Line 5: return 0;

This exits the main function and sends the value 0 back to the operating system. In computing convention, returning 0 means "everything went fine." If a program crashes or encounters an error, it typically returns a non-zero value. This is how shell scripts and other programs can check whether your program succeeded.

Line 6: }

The closing curly brace ends the main function. Every { must have a matching }.

Compiling and Running: Your First Taste of Power

Now let's bring your program to life. Open your terminal and navigate to the folder containing hello.c (use the cd command). Then:

# Step 1: Compile hello.c into an executable named "hello"
gcc hello.c -o hello

# Step 2: Run the executable
./hello

Let's understand exactly what each part means:

• gcc — invokes the GNU C Compiler
• hello.c — the source file to compile
• -o hello — the -o flag means "output," specifying that the compiled binary should be named hello. Without this flag, GCC defaults to naming the output a.out (a historical convention meaning "assembler output").
• ./hello — the >./ prefix tells the terminal "look
  in the current directory for the executable." Without it, the terminal searches only system directories.

If everything worked, you should see Hello, World! printed in your terminal. Congratulations! You're officially a C programmer.

5. A Second Example: Making It Interactive

Let's level up. Here's a program that asks for your name and then greets you personally. Create a file called greet.c:

#include <stdio.h>

int main() {
    char name[50];  // Reserve space for a name up to 49 characters (+ null)

    printf("What is your name? ");
    scanf("%s", name);  // Read user input into the 'name' variable

    printf("Hello, %s! Welcome to C programming.\n", name);
    return 0;
}

Line-by-line:

• char name[50]; — This declares a variable called name that can hold a string of up to 49 characters (the 50th byte is reserved for the null terminator \0 that marks the end of every C string). We'll explore variables in depth in Lesson 3.
• scanf("%s", name); — scanf reads input from the keyboard. %s tells it to read a string. The user's typed name gets
  stored in our name variable.
• Notice that for scanf with a string (%s), we do NOT use & before name—arrays are special in C; their name already acts as an address. This will make more sense later.

Compile and run: gcc greet.c -o greet && ./greet

6. Common Mistakes and How to Avoid Them

Every C programmer—even the experts—makes these mistakes. The key is recognizing them quickly:

Mistake #1: Forgetting the Semicolon

// WRONG - missing semicolon
printf("Hello")
return 0;

The compiler will complain with something like expected ';' before 'return'. Always check that every statement ends with ;. Note: preprocessor directives (#include, #define) do NOT need semicolons.

Mistake #2: Missing the Closing Curly Brace

// WRONG - missing closing brace
int main() {
    printf("Hello\n");
    return 0;
// <-- Missing }

The compiler will report something like expected '}' at end of input. Use a text editor with brace matching to avoid this. Many editors highlight matching braces automatically.

Mistake #3: Forgetting to Include the Header File

// WRONG - no #include <stdio.h>
int main() {
    printf("Hello\n");  // Compiler doesn't know what printf is!
    return 0;
}

The compiler may warn about an "implicit declaration" of printf. Always include the headers for the functions you use.

Mistake #4: Using the Wrong Escape Character

// WRONG - uses forward slash instead of backslash
printf("Hello/n");  // This prints "Hello/n" literally, no newline!

Escape sequences always use the backslash \, not the forward slash /.

Mistake #5: Typing ./hello.c Instead of ./hello

After compiling, running ./hello.c tries to execute your source code directly (which won't work). Always run the compiled binary, not the .c file.

7. Key Terminology You Need to Know

Key Takeaways

• C is everywhere. Operating systems, embedded devices, databases, and game engines all rely on C. Learning it opens doors to understanding how technology actually works.
• Every C program needs main(). It's the single entry point. The int return type communicates success (0) or failure (non-zero) to the operating system.
• #include <stdio.h> is essential for input/output. Without it, the compiler doesn't know about printf or scanf.
• Semicolons are mandatory. Every executable statement in C ends with ;—forgetting one is the #1 beginner error.
• The compile-then-run cycle is: gcc file.c -o file && ./file. Master this two-step process early.

Practice Exercises

Exercise 1: Your Own Greeting

Modify the "Hello, World!" program to print a 3-line message about yourself. Use three separate printf statements—one for each line. Make sure each line appears on its own row in the output.

Hint: Remember \n creates a newline. Each printf without \n will leave the cursor on the same line for the next printf to continue.

Exercise 2: Fix the Broken Program

The following program has 3 errors. Find and fix them:

include <stdio.h>

int main() {
    printf("Hello World!\n")
    return 0;

Hint: Check the #include syntax, the semicolons, and the braces.

Exercise 3: Full Name Greeting

Write a program that asks

Starter code:

#include <stdio.h>

int main() {
    char name[50];
    int age;

    printf("Enter your name: ");
    scanf("%s", name);

    printf("Enter your age: ");
    scanf("%d", &age);  // %d for integers, & needed for non-array variables

    // YOUR CODE: print the greeting
    return 0;
}

Exercise 4: Compiler Explorer

Deliberately introduce each of

1. Remove the #include line
2. Change printf to print
3. Remove a semicolon
4. Remove the closing }

This exercise teaches you to read compiler errors, which is one of the most valuable skills in programming. The compiler is your friend, not your enemy!