## The mindset shift: C vs C++

In C:

 - ❌ No classes, no RAII, no `std::string`
 - ✅ **You control memory explicitly**
 - ✅ Functions are small, focused, and composable
 - ✅ Portability comes from *conditional compilation*

 - “Each function returns ownership of dynamically allocated data, and the caller frees it.”*

## Feature macros (`_POSIX_C_SOURCE`)

```c
#define _POSIX_C_SOURCE 200809L
```

### Why this exists

C standard libraries hide some functions unless you *opt in*.

Without it:

* Some systems won’t expose those functions
* You’ll get mysterious warnings or missing symbols

---

## Headers: what C teaches you here

```c
#include <stdio.h>   // printf, FILE
#include <stdlib.h>  // malloc, free
#include <string.h>  // strlen, strdup
#include <unistd.h>  // POSIX functions
```

In C:

* Headers are **contracts**
* If it’s not included, the compiler assumes *nothing*

**Rule of thumb:**

> If you call a function, its header must be included — no exceptions.

---

## Conditional compilation (`#if defined(...)`)

Example:

```c
#if defined(__APPLE__) || defined(__FreeBSD__)
#include <sys/sysctl.h>
#endif
```

### What this teaches you

* C has **no runtime reflection**
* Portability happens at **compile time**
* The preprocessor literally removes code before compilation

Think of it as:

```text
“Only compile this code if the OS supports it.”
```

This is how *real* portable C software works (git, curl, openssh).

---

## The most important function in the file

```c
static char *dup_or_unknown(const char *s)
```

### Why this exists

This function enforces a **contract**:

* Every getter:

  * returns a valid `char *`
  * never returns `NULL`
  * always returns heap memory

### Why that matters

It lets `main()` be *simple*:

```c
char *user = get_user();
/* ... */
free(user);
```

No special cases.
No defensive `if (ptr)` checks.

---

## Dynamic allocation patterns (CRITICAL)

Example:

```c
char *buf = malloc(len);
snprintf(buf, len, "...", ...);
return buf;
```

### This is idiomatic C

Rules being followed:

1. Allocate **exactly what you need**
2. Initialize before use
3. Return ownership to the caller
4. Caller must `free()`

Contrast this with C++:

* No destructors
* No smart pointers
* No safety net

---

## Why no global buffers?

You *could* have done:

```c
static char buf[256];
```

But that would:

* Break thread safety
* Break reentrancy
* Make functions non-composable

Dynamic allocation makes your functions:

* Reusable
* Testable
* Library-quality

---

## Reading system information in C

Each platform teaches a lesson:

### Linux

```c
/proc/cpuinfo
/proc/uptime
```

* Text parsing
* Line-by-line scanning
* Defensive string handling

### macOS / BSD

```c
sysctl()
```

* Structured kernel APIs
* Buffer-size negotiation
* Integer & struct-based data

---

## Time handling (classic C pain point)

```c
time_t now = time(NULL);
difftime(now, boottime.tv_sec);
```

Why this matters:

* `time_t` may not be an integer
* You *never* subtract times directly
* `difftime()` handles portability

---

## The `main()` function: clean by design

```c
char *user = get_user();
/* ... */
free(user);
```

Notice:

* No logic
* No parsing
* No platform checks
* No error handling clutter

All complexity lives *outside* `main()`.