C: Programming Without a Safety Net

C is a general-purpose programming language created in the 1970s by Dennis Ritchie. It’s still widely used because it’s fast, powerful, and gives you direct control over memory.

Basically, newer languages hand you a car with airbags. C hands you an engine, a wrench, and legal responsibility.

1. Your first program

#include <stdio.h>

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

Here’s what’s happening:

• #include <stdio.h> gives you declarations for standard input/output functions. Apparently, saying hello requires paperwork.
• int main(void) defines the program’s entry point. It takes no arguments and returns an integer.
• printf(...) prints formatted text.
• \n starts a new line, because computers won’t infer your artistic intentions.
• return 0; reports successful completion. You survived.

C is usually compiled before running:

gcc hello.c -o hello
./hello

The compiler translates your source code into an executable. It catches many mistakes—not necessarily the exciting ones.

2. Variables: labeled boxes with commitment issues

In C, every variable has a type:

int age = 25;
double price = 19.99;
char grade = 'A';

• int: whole numbers.
• double: floating-point numbers.
• char: a character-sized integer type, often used for characters.

C is statically typed, so types are checked at compile time. However, it also performs automatic numeric conversions, because apparently consistency needed a plot twist:

double result = 5 / 2;  // 2.0, not 2.5

Both operands are integers, so integer division happens before the result becomes a double.

double result = 5.0 / 2;  // 2.5

There. One decimal point has rescued mathematics.

3. Decisions and loops: automating your questionable choices

Conditions

if (age >= 18) {
    printf("You may now make adult mistakes.\n");
} else {
    printf("Please make supervised mistakes.\n");
}

Loops

for (int i = 0; i < 3; i++) {
    printf("This meeting could have been an email.\n");
}

A for loop has three parts:

1. Initialization: int i = 0
2. Condition: i < 3
3. Update: i++

There’s also while, for when you know the condition but not how long the suffering will last:

int patience = 3;

while (patience > 0) {
    patience--;
}

4. Functions: putting your chaos into named containers

Functions let you reuse behavior:

int add(int a, int b)
{
    return a + b;
}

Call it like this:

int total = add(2, 3);

C passes arguments by value: the function receives copies. If you want a function to modify an existing object, you typically pass its address.

Which brings us to the feature everyone talks about with the expression of someone recalling a shipwreck.

5. Pointers: “I know where you live”

A pointer stores an address.

int score = 10;
int *p = &score;

*p = 20;

Now score is 20.

• &score means “the address of score.”
• int *p declares a pointer to an int.
• *p accesses the object that p points to.

Think of score as a house and p as a note containing its address. Dereferencing p means going to that house.

If the address is invalid, C does not politely ask whether you meant another house. You’ve entered undefined behavior territory: the language no longer guarantees what happens.

Your program might crash. It might appear to work. It might wait until the demo.

6. Arrays: boundaries exist, enforcement sold separately

int numbers[3] = {10, 20, 30};

printf("%d\n", numbers[0]);  // 10

Array indexing starts at zero, so the valid indexes here are 0, 1, and 2.

numbers[3] = 40;  // Wrong: out-of-bounds write

C generally does not perform automatic bounds checking. This write causes undefined behavior.

An array is not a pointer, although array expressions convert to pointers to their first elements in many contexts. Yes, that distinction matters. Yes, C will put it on the exam.

7. Strings: character arrays wearing a trench coat

A conventional C string is a sequence of characters terminated by a null character, '\0'.

char name[] = "Ada";

The array contains:

'A'  'd'  'a'  '\0'

That means it needs four bytes, not three. The invisible ending gets its own seat.

printf("Hello, %s!\n", name);

String operations require careful attention to buffer sizes and termination. Forget either, and your program may start reading or writing memory it has absolutely no business visiting.

8. Memory management: congratulations, you’re the garbage collector

For dynamically allocated memory, C gives you tools such as malloc and free, declared in <stdlib.h>.

Inside a function, you might write:

int *numbers = malloc(3 * sizeof *numbers);

if (numbers == NULL) {
    return 1;  // Allocation failed
}

numbers[0] = 10;
numbers[1] = 20;
numbers[2] = 30;

free(numbers);
numbers = NULL;

• malloc requests memory. Its contents are initially uninitialized.
• Check whether allocation succeeded before using it.
• free releases the allocation.
• Setting this pointer to NULL afterward does not fix any other pointers that referred to the same memory.

Classic mistakes include:

Other languages often automate this bookkeeping. C believes in personal growth through consequences.

9. Why would anyone use this?

Because C is genuinely useful:

• Low-level control: useful for operating systems, drivers, and embedded devices.
• Performance: efficient code with little runtime machinery.
• Portability: available on a huge variety of platforms, provided you respect platform differences.
• Interoperability: many languages and libraries expose C-compatible interfaces.

It’s not automatically faster than every other language, and terrible C code remains terrible code—just with excellent access to RAM.

How to learn it without becoming a cautionary tale

Start with variables, conditions, loops, and functions. Then learn arrays, pointers, strings, and memory ownership.

Compile with warnings enabled:

gcc -std=c17 -Wall -Wextra -Wpedantic hello.c -o hello

Treat warnings as useful advice, not decorative compiler poetry. Use a debugger and, where supported, AddressSanitizer and UndefinedBehaviorSanitizer to catch common runtime mistakes.

In short: C is a small language that gives you enormous control—and assumes you read the instructions before operating the chainsaw.