Your First C Program

A C program is small enough to hold in your head when you know what every line promises. In this lesson, you will write a complete source file, run it, observe its terminal output, respond to a compiler message, and make a small program of your own.

Build one reliable mental template

Start with a complete source-file template

Begin with the smallest program that has a real purpose: it produces a line of terminal output and reports that it finished normally. Copy the structure into a file called hello.c, then change the greeting before you run it. The browser runner uses a safe beginner subset; a local compiler is still the authority for real C code.

#include <stdio.h>

int main(void) {
  puts("Hello from C!");
  return 0;
}

Edit the program, predict its output, then run it.

Read the shape before reading the words

A first program is easier to debug when you separate its roles. The directive at the top prepares declarations for the compiler. The function header defines where the program starts. Braces mark the body of that function. Ordinary statements inside the braces end with semicolons. The final return statement communicates an exit status to the environment.

Use comments and order to make intent visible

C runs the statements in main in order, from top to bottom, unless you later add control flow. Comments are ignored by the compiler, so use them to explain a decision or a non-obvious constraint—not to repeat what a clear line already says. Run this source, then move one output call and predict how the terminal order changes.

#include <stdio.h>

/* A complete C program has one entry function. */
int main(void) {
  // puts adds a newline after this message.
  puts("Build, run, observe.");
  printf("Then make one small change.\n");
  return 0;
}

Edit the program, predict its output, then run it.

Choose an output call on purpose

puts is ideal for one plain line of text: it writes the string and adds a newline. printf gives you more control: it follows the format string exactly, so you place \n where a new terminal line belongs. Later, printf will also display values; for now, use it to make the newline rule visible.

#include <stdio.h>

int main(void) {
  puts("One line from puts.");
  printf("A second line from printf.\n");
  printf("A third line from printf.\n");
  return 0;
}

Edit the program, predict its output, then run it.

Build the source on your machine

Save the source as hello.c. Building from a terminal makes the source-to-executable boundary concrete: the compiler reads the file, reports warnings or errors, and produces a program you can start. Use warning flags from the beginning so suspicious code is visible before it becomes a habit.

Finish with a meaningful status

When your program reaches return 0;, it returns a conventional success status to the shell or operating system. That status is separate from the terminal text. A program can print a friendly message and still return a non-zero status to signal a failure; you will use those distinctions more deliberately once branches and errors arrive later in the course.

Repair the missing statement boundary

This source has one missing semicolon. The compiler—or the safe lesson runner—cannot know where the puts statement stops before it sees return. Read the message, inspect the previous line, add only the semicolon, and run it again.

#include <stdio.h>

int main(void) {
  puts("Every statement needs a boundary.")
  return 0;
}

Edit the program, predict its output, then run it.

Independent lab: publish a terminal event card

Build a three-line terminal announcement without copying an earlier message. Keep the include directive, main signature, braces, and return 0;. Change the event name, add a plain line with puts, and add a formatted line with printf that ends with \n. Run the result and explain why each terminal line appears where it does.

#include <stdio.h>

int main(void) {
  puts("Event: C study session");
  printf("Bring a notebook and arrive at 10:00.\n");
  return 0;
}

Edit the program, predict its output, then run it.

Lesson review

You can now read a complete C source file as a set of small contracts: the header prepares declarations, main defines the entry point, braces create the body, semicolons complete statements, output calls create terminal text in order, and return 0; reports normal completion. That is enough structure to begin adding values in the next lesson without treating the program as unexplained punctuation.

• I can write the smallest complete source file that includes output, main, and a success status.
• I can explain the different jobs of braces, parentheses, semicolons, and newline escapes.
• I can predict output order and choose between puts and printf for a plain line.
• I can compile with warnings enabled, use a diagnostic to find a missing semicolon, and make one targeted repair.