Modern C & Future of the Language

/* C Standards Timeline */

/*
   K&R C (1978)     - Original C book
   C89/C90 (1989)   - First ANSI/ISO standard
   C95/C99 (1999)   - Major update (inline, //, VLA, etc.)
   C11 (2011)       - Threads, atomics, Unicode, bounds checking
   C17 (2018)       - Bug fixes, no new features
   C23 (2023)       - Latest standard (attributes, nullptr, etc.)
*/

/* Check C version */
#if __STDC_VERSION__ >= 201112L
    printf("C11 or later\n");
#elif __STDC_VERSION__ >= 199901L
    printf("C99\n");
#else
    printf("C89/C90\n");
#endif

/* Enable specific standard */
/* gcc -std=c11 program.c   (C11) */
/* gcc -std=c17 program.c   (C17) */
/* gcc -std=c2x program.c   (C23 - experimental) */

/* Key features by standard */

/* C89/C90 - Original standard */
/*
   - Function prototypes
   - void pointers
   - const, volatile
   - Standard library
*/

/* C99 - Modern features */
/*
   - // comments
   - Variable declarations anywhere
   - inline functions
   - long long type
   - Variable-length arrays (VLA)
   - Flexible array members
   - _Bool type
   - Complex numbers
   - <stdint.h> (int32_t, etc.)
   - restrict keyword
   - Compound literals
   - Designated initializers
*/

/* C11 - Safety and concurrency */
/*
   - _Static_assert
   - _Generic
   - Anonymous structs/unions
   - <threads.h> (portable threads)
   - <stdatomic.h> (atomic operations)
   - Bounds-checking interfaces (optional)
   - Unicode support (_uchar.h)
   - _Noreturn
   - _Alignas, _Alignof
*/

/* C17 - Bug fixes */
/*
   - Clarifications and defect fixes
   - No new features
*/

/* C23 - Latest features */
/*
   - nullptr constant
   - typeof operator
   - Attributes (gnu::deprecated, etc.)
   - Binary literals (0b1010)
   - Digit separators (1'000'000)
   - auto type inference
   - constexpr
   - _BitInt(N) - arbitrary-width integers
   - #elifdef, #elifndef
   - Improved integer types
   - Improved UTF-8 support
   - Improved binary search (std::bsearch_s)
*/

/* _Static_assert - Compile-time assertions */

_Static_assert(sizeof(int) == 4, "int must be 4 bytes");
_Static_assert(sizeof(void*) == 8, "64-bit pointers required");

/* Catch errors at compile time, not runtime */

/* _Generic - Type-generic macros */

#define print(x) _Generic((x), \
    int: printf("%d", x), \
    float: printf("%f", x), \
    double: printf("%lf", x), \
    char*: printf("%s", x), \
    default: printf("unknown type") \
)

/* Usage */
print(42);          /* Calls printf("%d", 42) */
print(3.14);        /* Calls printf("%lf", 3.14) */
print("hello");     /* Calls printf("%s", "hello") */

/* Generic swap */
#define swap(a, b) do { \
    typeof(a) _tmp = a; \
    a = b; \
    b = _tmp; \
} while(0)

/* Anonymous structs/unions */

struct Point {
    union {
        struct {
            int x, y;
        };  /* Anonymous struct */
        int coords[2];
    };  /* Anonymous union */
};

struct Point p;
p.x = 10;           /* Direct access to x */
p.coords[0] = 10;   /* Same as p.x */

/* Atomic operations */

#include <stdatomic.h>

atomic_int counter = 0;

/* Thread-safe increment */
atomic_fetch_add(&counter, 1);

/* Compare-and-swap */
int expected = 5;
int desired = 10;
atomic_compare_exchange_strong(&counter, &expected, desired);

/* Memory ordering */
atomic_store_explicit(&counter, 42, memory_order_release);
int value = atomic_load_explicit(&counter, memory_order_acquire);

/* Portable threads */

#include <threads.h>

int thread_func(void *arg) {
    printf("Thread running\n");
    return 0;
}

thrd_t thread;
thrd_create(&thread, thread_func, NULL);
thrd_join(thread, NULL);

/* Thread-local storage */
_Thread_local int thread_counter = 0;

/* Each thread has its own copy */

/* Bounds-checking functions (optional, Annex K) */

#define __STDC_WANT_LIB_EXT1__ 1
#include <string.h>

char dest[10];
errno_t err = strcpy_s(dest, sizeof(dest), "Hello");
if (err != 0) {
    /* Handle error */
}

/* Note: Annex K is optional and not widely implemented */
/* Better: Use standard functions carefully */

/* Alignment */

#include <stdalign.h>

alignas(16) int aligned_array[100];

/* Check alignment */
size_t alignment = alignof(int);

/* _Noreturn */

#include <stdnoreturn.h>

noreturn void fatal_error(const char *msg) {
    fprintf(stderr, "Fatal: %s\n", msg);
    exit(1);
}
/* Compiler knows function never returns */

/* nullptr - Type-safe null pointer */

/* Before C23 */
int *ptr = NULL;  /* NULL is usually ((void*)0) */

/* C23 */
int *ptr = nullptr;  /* Distinct null pointer constant */

if (ptr == nullptr) {
    /* ... */
}

/* typeof / typeof_unqual */

/* Get type of expression */
int x = 5;
typeof(x) y = 10;  /* y has type int */

/* Remove qualifiers */
const int cx = 5;
typeof_unqual(cx) y = 10;  /* y has type int (not const int) */

/* Generic macro with typeof */
#define max(a, b) ({ \
    typeof(a) _a = (a); \
    typeof(b) _b = (b); \
    _a > _b ? _a : _b; \
})

/* Attributes - Standardized annotations */

/* Deprecated */
[[deprecated("Use new_function instead")]]
void old_function(void) {
    /* ... */
}

/* Fallthrough (no warning) */
switch (x) {
    case 1:
        printf("One\n");
        [[fallthrough]];
    case 2:
        printf("Two\n");
        break;
}

/* Maybe unused */
[[maybe_unused]] static void debug_only(void) {
    /* Only used in debug builds */
}

/* Nodiscard - Warn if return value ignored */
[[nodiscard]] int important_function(void) {
    return 42;
}

important_function();  /* Warning: return value ignored */

/* Binary literals */

int binary = 0b10101010;     /* 170 in decimal */
int flags = 0b1111'0000;     /* With digit separator */

/* Digit separators - Improve readability */

int million = 1'000'000;
long big = 1'000'000'000'000L;
int hex = 0xFF'FF'FF'FF;

/* auto type inference */

auto x = 5;           /* x is int */
auto y = 3.14;        /* y is double */
auto z = "hello";     /* z is char* */

/* constexpr - Compile-time constants */

constexpr int BUFFER_SIZE = 1024;
constexpr int DOUBLE_SIZE = BUFFER_SIZE * 2;

/* More expressive than #define */

/* _BitInt(N) - Arbitrary-width integers */

_BitInt(128) big_number = 0;  /* 128-bit integer */
_BitInt(256) huge = 1;        /* 256-bit integer */

/* Useful for cryptography, big number arithmetic */

/* Improved preprocessor */

/* #elifdef - More readable */
#ifdef FEATURE_A
    /* ... */
#elifdef FEATURE_B  /* Instead of #elif defined(FEATURE_B) */
    /* ... */
#else
    /* ... */
#endif

/* #elifndef */
#ifndef FEATURE_A
    /* ... */
#elifndef FEATURE_B
    /* ... */
#endif

/* Improved UTF-8 support */

#include <uchar.h>

/* UTF-8 string literals */
const char8_t *utf8_str = u8"Hello 世界";

/* Better Unicode handling */

/* Label at end of block */

void function(void) {
    if (error) {
        goto cleanup;
    }
    
    /* ... */
    
cleanup:  /* Can now be at end without statement after */
}

/* Previously needed: */
cleanup:
    ;  /* Empty statement required */

/* Empty initializer */

int arr[] = {};  /* Now legal in C23 */

/* Improved integer constants */

/* wb prefix for unsigned _BitInt */
auto x = 123wb;

/* More flexible */

/* Choose the right standard */

/* Embedded systems - C99 or C11 */
/* Wide support, good features */

/* General applications - C11 or C17 */
/* Stable, well-supported */

/* New projects - C23 */
/* Latest features, but check compiler support */

/* Modern C project structure */

/*
project/
├── src/           # Source files
├── include/       # Header files
├── tests/         # Unit tests
├── docs/          # Documentation
├── build/         # Build outputs
├── CMakeLists.txt # Build system
└── README.md
*/

/* Use build systems */

/* CMake example */
/*
cmake_minimum_required(VERSION 3.10)
project(MyProject C)

set(CMAKE_C_STANDARD 17)
set(CMAKE_C_STANDARD_REQUIRED ON)

add_executable(myapp src/main.c src/utils.c)
target_include_directories(myapp PRIVATE include)
*/

/* Compiler flags for modern C */

/* Development build */
/* gcc -std=c17 -O0 -g -Wall -Wextra -Wpedantic -Werror */

/* -std=c17     Use C17 standard */
/* -O0          No optimization (faster compile) */
/* -g           Debug symbols */
/* -Wall        All warnings */
/* -Wextra      Extra warnings */
/* -Wpedantic   Strict standard compliance */
/* -Werror      Warnings as errors */

/* Additional helpful warnings */
/* -Wshadow           Warn about shadowed variables */
/* -Wconversion       Warn about implicit conversions */
/* -Wstrict-overflow  Warn about overflow assumptions */
/* -Wformat=2         Extra format string checks */
/* -Wundef            Warn about undefined macros */

/* Release build */
/* gcc -std=c17 -O3 -march=native -DNDEBUG */

/* -O3            Maximum optimization */
/* -march=native  CPU-specific optimizations */
/* -DNDEBUG       Disable assertions */

/* Static analysis */

/* Clang static analyzer */
/* scan-build gcc -c program.c */

/* Clang-tidy */
/* clang-tidy program.c -- -std=c17 */

/* Cppcheck */
/* cppcheck --enable=all program.c */

/* Sanitizers */

/* AddressSanitizer (memory errors) */
/* gcc -fsanitize=address program.c */

/* UndefinedBehaviorSanitizer */
/* gcc -fsanitize=undefined program.c */

/* ThreadSanitizer (race detection) */
/* gcc -fsanitize=thread program.c */

/* Code formatting */

/* clang-format */
/* clang-format -i *.c *.h */

/* Use .clang-format config file */

/* Documentation */

/* Doxygen-style comments */

/**
 * @brief Calculate factorial
 * @param n Input number (must be >= 0)
 * @return Factorial of n
 * @pre n >= 0
 * @post result >= 1
 */
int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

/* Unit testing */

/* Use testing framework: Check, Unity, etc. */

/* Example with simple asserts */
void test_factorial(void) {
    assert(factorial(0) == 1);
    assert(factorial(1) == 1);
    assert(factorial(5) == 120);
    printf("All tests passed\n");
}

/* Version control */

/* Git best practices */
/* - Commit often */
/* - Write good commit messages */
/* - Use branches for features */
/* - Review code before merging */

/* Continuous Integration */

/* GitHub Actions example */
/*
name: CI
on: [push, pull_request]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build
        run: gcc -Wall -Werror *.c
      - name: Test
        run: ./a.out
*/

/* Where C is used today */

/* Operating Systems */
/*
   - Linux kernel (pure C)
   - Windows kernel (C/C++)
   - macOS/iOS kernel (C/C++)
   - FreeBSD, OpenBSD (C)
   - All major OS kernels use C
*/

/* Embedded Systems */
/*
   - Microcontrollers (Arduino, STM32, etc.)
   - IoT devices
   - Automotive systems
   - Medical devices
   - Consumer electronics
   - Real-time systems
*/

/* Databases */
/*
   - PostgreSQL (C)
   - MySQL (C/C++)
   - SQLite (C)
   - Redis (C)
*/

/* Programming Language Implementations */
/*
   - Python (CPython)
   - Ruby (MRI)
   - Perl
   - Lua
   - Most language runtimes
*/

/* High-Performance Computing */
/*
   - Scientific computing
   - Numerical libraries (BLAS, LAPACK)
   - Simulation software
   - Graphics processing
*/

/* Networking */
/*
   - Network protocols
   - Routers and switches
   - Web servers (nginx, Apache parts)
   - VPN software
*/

/* Graphics and Games */
/*
   - Graphics drivers
   - Game engines (parts)
   - 3D rendering
   - OpenGL, Vulkan implementations
*/

/* C interoperability with other languages */

/* Python C Extensions */

/* Python calling C */
/*
#include <Python.h>

static PyObject* my_function(PyObject *self, PyObject *args) {
    int x;
    if (!PyArg_ParseTuple(args, "i", &x)) {
        return NULL;
    }
    return PyLong_FromLong(x * 2);
}

static PyMethodDef methods[] = {
    {"my_function", my_function, METH_VARARGS, "Double a number"},
    {NULL, NULL, 0, NULL}
};

static struct PyModuleDef module = {
    PyModuleDef_HEAD_INIT,
    "mymodule",
    "My C extension",
    -1,
    methods
};

PyMODINIT_FUNC PyInit_mymodule(void) {
    return PyModule_Create(&module);
}
*/

/* Rust FFI (Foreign Function Interface) */

/* C function */
int add(int a, int b) {
    return a + b;
}

/* Rust calling C */
/*
extern "C" {
    fn add(a: i32, b: i32) -&gt; i32;
}

fn main() {
    let result = unsafe { add(5, 3) };
    println!("Result: {}", result);
}
*/

/* Go calling C (cgo) */

/*
// Go code
import "C"

func main() {
    result := C.add(5, 3)
    fmt.Println(result)
}
*/

/* Why C is still relevant */

/*
   1. Performance - Close to the metal
   2. Portability - Runs everywhere
   3. Simplicity - Small, understandable language
   4. Control - Direct memory management
   5. Ubiquity - Everywhere in computing
   6. Stability - Code from decades ago still works
   7. Interoperability - All languages can call C
   8. Efficiency - Minimal overhead
   9. Standards - Well-defined, stable standards
   10. Foundation - Understanding C helps with all languages
*/

/* C vs. Modern Languages */

/* C vs. Rust */
/* Rust: Memory safety, modern features */
/* C: Simpler, more mature, wider adoption */
/* Both: Systems programming */

/* C vs. C++ */
/* C++: Objects, templates, much larger */
/* C: Simpler, smaller, easier to master */
/* Both: High performance */

/* C vs. Python */
/* Python: High-level, easy, productive */
/* C: Low-level, fast, efficient */
/* Both: Complementary (Python uses C) */

/* C vs. Go */
/* Go: Garbage collection, concurrency, simplicity */
/* C: Manual memory, more control, smaller runtime */
/* Both: Fast compilation, systems programming */

/* The future of C */

/*
   - C will remain relevant for decades
   - New standards every 5-6 years
   - Gradual modernization
   - Still the lingua franca of programming
   - Foundation for understanding computers
   - Essential skill for systems programmers
*/

/* Next steps in your C journey */

/* 1. Practice Regularly */
/*
   - Solve coding challenges (LeetCode, HackerRank)
   - Implement data structures from scratch
   - Write small utilities
   - Contribute to open source
*/

/* 2. Read Quality Code */
/*
   - Linux kernel (linux/kernel/*)
   - Git source code
   - Redis source code
   - SQLite source code
   - Study how experts write C
*/

/* 3. Deep Dive Topics */

/* Systems Programming */
/*
   - Process management
   - File systems
   - Networking (sockets)
   - Signals and IPC
   - Book: "The Linux Programming Interface"
*/

/* Operating Systems */
/*
   - Write a simple OS kernel
   - Understand memory management
   - Learn about scheduling
   - Book: "Operating Systems: Three Easy Pieces"
*/

/* Computer Architecture */
/*
   - Understand CPU pipelines
   - Learn about caches
   - Study assembly language
   - Book: "Computer Systems: A Programmer's Perspective"
*/

/* Compilers */
/*
   - Write a simple compiler
   - Learn about parsing, optimization
   - Book: "Crafting Interpreters"
*/

/* Embedded Systems */
/*
   - Program microcontrollers
   - Real-time constraints
   - Hardware interfacing
   - Resource-constrained programming
*/

/* Network Programming */
/*
   - Write client/server applications
   - Understand protocols
   - Learn about concurrency
   - Book: "Unix Network Programming"
*/

/* 4. Project Ideas */

/* Beginner */
/*
   - Command-line text editor
   - File compression utility
   - Calculator with parsing
   - Simple shell
*/

/* Intermediate */
/*
   - HTTP server
   - Database engine
   - Memory allocator
   - JSON parser
*/

/* Advanced */
/*
   - Operating system kernel
   - C compiler
   - Virtual machine
   - Network protocol implementation
*/

/* 5. Resources */

/* Books */
/*
   - "The C Programming Language" (K&R) - Classic
   - "C Programming: A Modern Approach" - Comprehensive
   - "Expert C Programming" - Advanced
   - "21st Century C" - Modern C practices
*/

/* Online */
/*
   - Learn C (learn-c.org)
   - C reference (en.cppreference.com)
   - Linux man pages (man7.org)
   - GitHub open source projects
*/

/* Communities */
/*
   - Stack Overflow
   - Reddit r/C_Programming
   - IRC #c on freenode
   - GitHub discussions
*/

/* 6. Build Your Portfolio */

/*
   - Create GitHub repositories
   - Document your code well
   - Write about your projects
   - Contribute to open source
   - Share knowledge through blogs/tutorials
*/

/* Final thoughts */

/*
   C is a lifetime skill. It teaches you:
   - How computers really work
   - Memory and performance awareness
   - Problem-solving at a fundamental level
   - Discipline and careful thinking
   
   Master C, and all other languages become easier.
   
   Happy coding! 🚀
*/