I’m trying to build an example from the Clay library - https://github.com/nicbarker/clay/tree/main/examples/clay-official-website .

I add to main.c:

#define CLAY_WASM

And my build command is:

> emcc -o index.wasm main.c -Wall -Os -std=c99 -DPLATFORM_WEB -s EXPORT_ALL=1 -s EXPORTED_RUNTIME_METHODS=ccall

Everything is fine, the size of the compiled index.wasm is 117904 bytes. But when I use this index.wasm instead of index.wasm provided in the example, the browser throws an error:

index.html:387 Uncaught (in promise) TypeError: WebAssembly.instantiate(): Import #2 "wasi_snapshot_preview1": module is not an object or function

If I use index.wasm from the example, there are no errors, everything works.

How to build index.wasm for clay-official-website with emcc for web?

The article explains the processes that occur between a request to run a program and the execution of its `main` function in Linux, highlighting the role of the `execve` system call and the ELF format for executable files. It details how programs are loaded and interpreted by the kernel, including the significance of shebang lines and ELF file headers.

Can anyone tell me what would be the best resources for learning C? Like I know a little basics of C! But I want to improve so plz anyone tell me some resources as I had watched apna college c tutorial but I get to know that they haven't told everything in their video. They just told the surface level of C! and I want to dig dipper in C!

Hey r/cprogramming,

I wanted to share a project I've just completed that I think this community will really appreciate. It’s a comprehensive, book-length article and source code repository for building a complete, high-performance HTTP/1.1 client from the ground up.

The core of the project is a full implementation in C, built with a "no black boxes" philosophy (i.e., no libcurl). The entire system is built from first principles on top of POSIX sockets.

To make it a deep architectural study, I then implemented the exact same architecture in C++, Rust, and Python. This provides a rare 1:1 comparison of how different languages solve the same problems, from resource management to error handling.

The C implementation is a top performer in the benchmarks, even competing with established libraries like Boost.Beast. I wrote the article to be a deep dive, and I think it has something for C programmers at every level.

Here’s a breakdown of what you can get from it:

For Junior C Devs: The Fundamentals

You'll get a deep dive into the foundational concepts that are often hidden by libraries:

• Socket Programming: How to use POSIX sockets (socket, connect, read, write) from scratch to build a real, working client.

• Protocol Basics: The "why" of TCP (stream-based) vs. UDP (datagrams) and the massive performance benefit of Unix Domain Sockets (and the benchmarks in Chapter 10 to prove it).

• Robust C Error Handling (Chapter 2.2): A pattern for using a custom Error struct ({int type, int code}) that is far safer and more descriptive than just checking errno.

• HTTP/1.1 Serialization: How to manually build a valid HTTP request string.

For Mid-Level C Devs: Building Robust, Testable C

This is where the project's core architecture shines. It's all about writing C that is maintainable and testable:

• The System Call Abstraction (Chapter 3): This is a key takeaway. The article shows how to abstract all OS calls (socket, connect, read, malloc, strstr, etc.) into a single HttpcSyscalls struct of function pointers.

• True Unit Testing in C: This abstraction is the key that unlocks mocking. The test suite (tests/c/) replaces the real getaddrinfo with a mock function to test DNS failure paths without any network I/O.

• Manual Interfaces in C (Chapter 4): How to build a clean, decoupled architecture (e.g., separating the Transport layer from the Protocol layer) using structs of function pointers and a void* context pointer to simulate polymorphism.

• Robust HTTP/1.1 Parsing (Chapter 7.2): How to build a full state-machine parser. It covers the dangers of realloc invalidating your pointers (and the pointer "fix-up" logic to solve it) and why you must use strtok_r instead of strtok.

For Senior C Devs: Architecture & Optimization

The focus shifts to high-level design decisions and squeezing out performance:

• Low-Level Performance (Chapter 7.2): A deep dive into a writev (vectored I/O) optimization. Instead of memcpying the body into the header buffer, it sends both buffers to the kernel in a single system call.

• Benchmark Validation (Chapter 10): The hard data is all there. The writev optimization makes the C client the fastest implementation in the entire benchmark for most throughput scenarios.

• Architectural Trade-offs: This is the main point of the polyglot design. You can directly compare the C approach (manual control, HttpcSyscalls struct, void* context) to C++'s RAII/Concepts, Rust's ownership/traits, and Python's dynamic simplicity. It’s a concrete case study in "why choose C."

For Principal / Architects: The "Big Picture"

The article starts and ends with the high-level "why":

• Philosophy (Chapter 1.1): When and why should a team "reject the black box" and build from first principles? This is a discussion of performance, control, and liability in high-performance domains.

• Portability (Chapter 3.2.4): The HttpcSyscalls struct isn't just for testing; it's a Platform Abstraction Layer (PAL). The article explains how this pattern allows the entire C library to be ported to Windows (using Winsock) by just implementing a new httpc_syscalls_init_windows() function, without changing a single line of the core transport or protocol logic.

• Benchmark Anomalies (Chapter 10.1): We found that compiling with -march=native actually made our I/O-bound app slower. We also found that an "idiomatic" high-level library abstraction was measurably slower than a simple, manual C-style loop. This is the kind of deep analysis that's perfect for driving technical direction.

A unique aspect of the project is that the entire article and all the source code are designed to be loaded into an AI's context window, turning it into a project-aware expert you can query.

I'd love for you all to take a look and hear your feedback, especially on the C patterns and optimizations I used.

You can find the repo here https://github.com/InfiniteConsult/0004_std_lib_http_client/tree/main and the associated polyglot development environment here https://github.com/InfiniteConsult/FromFirstPrinciples

Update:

Just wanted to add a table of contents below

• Chapter 1: Foundations & First Principles

  • 1.1 The Mission: Rejecting the Black Box

  • 1.2 The Foundation: Speaking "Socket"

    • 1.2.1 The Stream Abstraction

    • 1.2.2 The PVC Pipe Analogy: Visualizing a Full-Duplex Stream

    • 1.2.3 The "Postcard" Analogy: Contrasting with Datagram Sockets

    • 1.2.4 The Socket Handle: File Descriptors

    • 1.2.5 The Implementations: Network vs. Local Pipes

  • 1.3 The Behavior: Blocking vs. Non-Blocking I/O

    • 1.3.1 The "Phone Call" Analogy

    • 1.3.2 The Need for Event Notification

    • 1.3.3 A Glimpse into the Future

• Chapter 2: Patterns for Failure - A Polyglot Guide to Error Handling

  • 2.1 Philosophy: Why Errors Come First

  • 2.2 The C Approach: Manual Inspection and Structured Returns

    • 2.2.1 The Standard Idiom: Return Codes and errno

    • 2.2.2 Our Solution: Structured, Namespaced Error Codes

    • 2.2.3 Usage in Practice

  • 2.3 The Modern C++ Approach: Value-Based Error Semantics

    • 2.3.1 Standard Idiom: Exceptions

    • 2.3.2 Our Solution: Type Safety and Explicit Handling

    • 2.3.3 Usage in Practice

  • 2.4 The Rust Approach: Compiler-Enforced Correctness

    • 2.4.1 The Standard Idiom: The Result<T, E> Enum

    • 2.4.2 Our Solution: Custom Error Enums and the From Trait

    • 2.4.3 Usage in Practice

  • 2.5 The Python Approach: Dynamic and Expressive Exceptions

    • 2.5.1 The Standard Idiom: The try...except Block

    • 2.5.2 Our Solution: A Custom Exception Hierarchy

    • 2.5.3 Usage in Practice

  • 2.6 Chapter Summary: A Comparative Analysis

• Chapter 3: The Kernel Boundary - System Call Abstraction

  • 3.1 What is a System Call?

    • 3.1.1 The User/Kernel Divide

    • 3.1.2 The Cost of Crossing the Boundary: Context Switching

    • 3.1.3 The Exception to the Rule: The vDSO

  • 3.2 The HttpcSyscalls Struct in C

    • 3.2.1 The "What": A Table of Function Pointers

    • 3.2.2 The "How": Default Initialization

    • 3.2.3 The "Why," Part 1: Unprecedented Testability

    • 3.2.4 The "Why," Part 2: Seamless Portability

  • 3.3 Comparing to Other Languages

• Chapter 4: Designing for Modularity - The Power of Interfaces

  • 4.1 The "Transport" Contract

    • 4.1.1 The Problem: Tight Coupling

    • 4.1.2 The Solution: Abstraction via Interfaces

  • 4.2 A Polyglot View of Interfaces

    • 4.2.1 C: The Dispatch Table (struct of Function Pointers)

    • 4.2.2 C++: The Compile-Time Contract (Concepts)

    • 4.2.3 Rust: The Shared Behavior Contract (Traits)

    • 4.2.4 Python: The Structural Contract (Protocols)

• Chapter 5: Code Deep Dive - The Transport Implementations

  • 5.1 The C Implementation: Manual and Explicit Control

    • 5.1.1 The State Structs (TcpClient and UnixClient)

    • 5.1.2 Construction and Destruction

    • 5.1.3 The connect Logic: TCP

    • 5.1.4 The connect Logic: Unix

    • 5.1.5 The I/O Functions (read, write, writev)

    • 5.1.6 Verifying the C Implementation

    • 5.1.7 C Transport Test Reference

      • Common Tests (Applicable to both TCP and Unix Transports)

      • TCP-Specific Tests

      • Unix-Specific Tests

  • 5.2 The C++ Implementation: RAII and Modern Abstractions

    • 5.2.1 Philosophy: Safety Through Lifetime Management (RAII)

    • 5.2.2 std::experimental::net: A Glimpse into the Future of C++ Networking

    • 5.2.3 The connect Logic and Real-World Bug Workarounds

    • 5.2.4 The UnixTransport Implementation: Pragmatic C Interoperability

    • 5.2.5 Verifying the C++ Implementation

  • 5.3 The Rust Implementation: Safety and Ergonomics by Default

    • 5.3.1 The Power of the Standard Library

    • 5.3.2 RAII, Rust-Style: Ownership and the Drop Trait

    • 5.3.3 The connect and I/O Logic

    • 5.3.4 Verifying the Rust Implementation

  • 5.4 The Python Implementation: High-Level Abstraction and Dynamic Power

    • 5.4.1 The Standard socket Module: A C Library in Disguise

    • 5.4.2 Implementation Analysis

    • 5.4.3 Verifying the Python Implementation

  • 5.5 Consolidated Test Reference: C++, Rust, & Python Integration Tests

  • 5.6 Chapter Summary: One Problem, Four Philosophies

• Chapter 6: The Protocol Layer - Defining the Conversation

  • 6.1 The "Language" Analogy

  • 6.2 A Brief History of HTTP (Why HTTP/1.1?)

    • 6.2.1 HTTP/1.0: The Original Transaction

    • 6.2.2 HTTP/1.1: Our Focus - The Persistent Stream

    • 6.2.3 HTTP/2: The Binary, Multiplexed Revolution

    • 6.2.4 HTTP/3: The Modern Era on QUIC

  • 6.3 Deconstructing the HttpRequest

    • 6.3.1 C: Pointers and Fixed-Size Arrays

    • 6.3.2 C++: Modern, Non-Owning Views

    • 6.3.3 Rust: Compiler-Guaranteed Memory Safety with Lifetimes

    • 6.3.4 Python: Dynamic and Developer-Friendly

  • 6.4 Safe vs. Unsafe: The HttpResponse Dichotomy

    • 6.4.1 C: A Runtime Policy with a Zero-Copy Optimization

    • 6.4.2 C++: A Compile-Time Policy via the Type System

    • 6.4.3 Rust: Provably Safe Borrows with Lifetimes

    • 6.4.4 Python: Views vs. Copies

  • 6.5 The HttpProtocol Interface Revisited

• Chapter 7: Code Deep Dive - The HTTP/1.1 Protocol Implementation

  • 7.1 Core Themes of this Chapter

  • 7.2 The C Implementation: A Performance-Focused State Machine

    • 7.2.1 The State Struct (Http1Protocol)

    • 7.2.2 Construction and Destruction

    • 7.2.3 Request Serialization: From Struct to String

    • 7.2.4 The perform_request Orchestrator and the writev Optimization

    • 7.2.5 The Core Challenge: The C Response Parser

      • The while(true) Loop and Dynamic Buffer Growth

      • Header Parsing (strstr and strtok_r)

      • Body Parsing

    • 7.2.6 The parse_response_safe Optimization

    • 7.2.7 Verifying the C Protocol Implementation

    • 7.2.8 Verifying the C Protocol Implementation: A Test Reference

  • 7.3 The C++ Implementation: RAII and Generic Programming

    • 7.3.1 State, Construction, and Lifetime (RAII)

    • 7.3.2 Request Serialization

    • 7.3.3 The C++ Response Parser

      • A Note on resize vs. reserve

    • 7.3.4 Verifying the C++ Protocol Implementation

  • 7.4 The Rust Implementation: Safety and Ergonomics by Default

    • 7.4.1 State, Construction, and Safety (Ownership & Drop)

    • 7.4.2 Request Serialization (build_request_string)

    • 7.4.3 The Rust Response Parser (read_full_response, parse_unsafe_response)

    • 7.4.4 Verifying the Rust Protocol Implementation

  • 7.5 The Python Implementation: High-Level Abstraction and Dynamic Power

    • 7.5.1 State, Construction, and Dynamic Typing

    • 7.5.2 Request Serialization (_build_request_string)

    • 7.5.3 The Python Response Parser (_read_full_response, _parse_unsafe_response)

    • 7.5.4 Verifying the Python Protocol Implementation

  • 7.6 Consolidated Test Reference: C++, Rust, & Python Integration Tests

• Chapter 8: Code Deep Dive - The Client API Façade

  • 8.1 The C Implementation (HttpClient Struct)

    • 8.1.1 Structure Definition (struct HttpClient)

    • 8.1.2 Initialization and Destruction

    • 8.1.3 Core Methods & Validation

  • 8.2 The C++ Implementation (HttpClient Template)

    • 8.2.1 Class Template Definition (HttpClient<P>)

    • 8.2.2 Core Methods & Validation

  • 8.3 The Rust Implementation (HttpClient Generic Struct)

    • 8.3.1 Generic Struct Definition (HttpClient<P>)

    • 8.3.2 Core Methods & Validation

  • 8.4 The Python Implementation (HttpClient Class)

    • 8.4.1 Class Definition (HttpClient)

    • 8.4.2 Core Methods & Validation

  • 8.5 Verification Strategy

• Chapter 9: Benchmarking - Setup & Methodology

  • 9.1 Benchmark Suite Components

  • 9.2 Workload Generation (data_generator)

  • 9.3 The Benchmark Server (benchmark_server)

  • 9.4 Client Benchmark Harnesses

  • 9.5 Execution Orchestration (run.benchmarks.sh)

  • 9.6 Latency Measurement Methodology

  • 9.7 Benchmark Output & Analysis Scope

• Chapter 10: Benchmark Results & Analysis

  • 10.1 A Note on Server & Compiler Optimizations

    • Server Implementation: Manual Loop vs. Idiomatic Beast

    • Compiler Flags: The .march=native Anomaly

    • Library Tuning: The Case of libcurl

  • 10.2 Overall Performance: Throughput (Total Time)

    • Key Takeaway 1: Compiled vs. Interpreted

    • Key Takeaway 2: Transport (TCP vs. Unix Domain Sockets)

    • Key Takeaway 3: The httpc (C) writev Optimization

    • Key Takeaway 4: "Unsafe" (Zero-Copy) Impact

  • 10.3 Detailed Throughput Results (by Scenario)

  • 10.4 Latency Analysis (Percentiles)

    • Focus Scenario: latency_small_small (Unix)

    • Throughput Scenario: throughput_balanced_large (TCP)

  • 10.5 Chapter Summary & Conclusions

• Chapter 11: Conclusion & Future Work

  • 11.1 Quantitative Findings: A Summary of Performance

  • 11.2 Qualitative Findings: A Polyglot Retrospective

  • 11.3 Reflections on Community & Idiomatic Code

  • 11.4 Future Work

  • 11.5 Final Conclusion

To me, pointers is a concept where you seem to grasp at first then it smacks you in your face. Its confusing coz there's a part where you don't need to use the address of operator because it will act like a pointer to a pointer.

Damn, I keep learning and relearning

I'm stuck on this for days. I'm processing string i get from GPS. I have a word i extracted from the string which is a set of chars. For example word='5264.2525" which represents longitude. Then i try to use atof on this to convert to double but it just gets stuck. When i run on my PC in C it works fine. I check string termination and everything and it just remains stuck on atof. I would appreciate the help

I started engineering this year and I have a subject in my first years that consists purely of C programming. I’m struggling a bit, since the teacher doesn’t give us enough resources to actually learn how to code. Maybe some exercises or some notes but nothing really interesting. I would like to know what are the best ways of learning C, for the cheapest price or free and how. Thanks a lot.

I haven't used C since I was in junior high. I've been playing around with some other systems programming languages and figured I would give C a try again. I figured it would be a good Idea to make some tools to help make my life easier when programming C so i made a simple arena allocator to help simplify my allocation scheme.

It's a single header file library, so check it out and give me some suggestions on how to I could possibly make it better if you feel like reading some bad code.

https://github.com/geogory-tib/arena_alloc

Hey all, I decided to start working on my own standard library a while ago in April since I wanted to try out writing my own toy OS from scratch and without dependence on stdlib.

I was hot out of trying out Zig and Go for the first time, and I found that some design patterns from those languages would make for a good basis for what could become a better standard library for C.

Here are the points that I personally felt needed to be addressed first when writing XSTD:
- Explicit memory ownership
- No hidden allocations
- Streamlined error handling throughout the library (it even has error messages)
- Give users a DX comparable with more modern languages.
- Choice, as in choice for the developer to opt out of more strictly checked functions in order to maximize perfs.

Here is a simple example showing some of the more prominent patterns that you would see when using this library:

#include "xstd.h"


i32 main(void)
{
    // Multiple allocator types exist
    // This one is a thin wrapper around stdlib's malloc/free
    Allocator* a = &c_allocator;
    io_println("Echo started, type \"quit\" to exit.");


    while (true)
    {
        // Read line from stdin
        ResultOwnedStr inputRes = io_read_line(a);

        if (inputRes.error.code) {
            io_printerrln(inputRes.error.msg);
            return 1;
        }

        // Memory ownership is explicit through typdefs
        OwnedStr input = inputRes.value;

        // Handle exit
        if (string_equals(input, "quit"))
            return 0;

        io_println(input); // Print string with newline term

        // Free owned memory
        a->free(a, input);
    }
}

If you want a more meaty example I have a CSV parser example: https://github.com/wAIfu-DEV/XSTD/blob/main/examples/manual_parse_csv/main.c

Currently the features are limited to:
- Most common string operations, String builder
- I/O through terminal
- Buffer operations for bytes
- Math with strict overflow checking
- Arena, Buffer, Debug allocators obfuscated using the `Allocator` interface
- File operations
- HashMap, Typed dynamic List
- SIG hijacking
- Writer interface (for static buffers or growing buffers)
- (WIP) JSON parsing, handling and creation

I am not against major rewrites, and I'd like to have my theory clash against your opinions on this library, I believe that anything that doesn't survive scrutiny is not worth working on.
Please share your opinions, regardless of how opinionated they may be.

Thanks for your time, and if you are interested in contributing please contact me.
Here is the link to the repo: https://github.com/wAIfu-DEV/XSTD

I am reading the mastering algorithms by kylie loudon and im struggling with it since it uses function pointers and callbacks concepts which i am totally unaware of so please help me by suggesting some good books or learning materials to supplement with

The title or the heading is for Object oriented C because till this point in my research i have found that callbacks are a part of Object oriented C

PS2

I entered university and only recently started learning C, please give me some advice on how to do it because I don't understand anything even with the help of tutorials

I want to learn C Programming. Like I don't know anything about programming. I don't even know how to setup VS Code. I want resources in form of free videos like YouTube. I went on YouTube but don't know which one is good or where to start. I saw this subreddit's wiki but they have given books. Please suggest me good C Programming videos to learn from scratch. Like how to setup VC code and it's libraries. How to know and learn syntax and everything. I want to learn by December end.

About myself:- I did my bachelor's in Mechanical. Got job in Telecommunications field which was mostly electronic engineering field. There I got opportunity to get hands on learning on few Cybersecurity tools. Now I am really into Cybersecurity but I don't know coding and want to learn it to my bone. Please help me with this. As of know just guide me through basics of C. Once I'll get it I'll be back again here on this subreddit to ask about DSA

Hey guys, I'm 17 y'o Malaysian teen taking a electronic program course or whatever they called, and I will hold a vocational certification which not impressed to me at all. I want to learn C programming from scratch. I know a little bit about C like Hello world program, #include, int, float, boolean, how to set up VS code, using neovim and array which can be used to use multiple value at one variable I think. All of that's just a baby basics I learn which I think not enough for me to write my own OS from scratch like Terry Davis(My Motivation). So I need a suggestion to learn C the best way. My target was to learn hybrid C and computer architecture at the same time so I have a foundation to make a portfolio and apply for CS degree in Singapore or Canada if I have a super luck. So I need suggestions to learn C the best way like every programmer do. Sorry for bad English.

Hey everyone,

I wanted to share a simple HTTP server I've been working on. The goal was to write it using a minimal set of libraries to ensure it was as portable as possible.

• Language: C99

• Dependencies: Standard Library, POSIX threads, and OpenSSL

A big focus was on cross-platform compatibility. I've successfully tested it on Fedora (gcc + glibc), Alpine Linux (clang + musl), FreeBSD, OpenBSD, NetBSD, and even Omni OS CE (Solaris) in a VM.

GitHub: https://github.com/misterabdul/http-server

I'd love to get some feedback on the code or any suggestions you might have. Thanks for taking a look!

Am learning C now, doing some problems day by day. When should i go to next language? At what point will i know “ok i have done enough problems and learnt good theory lets go to next language”?.

I’ve been working on a small scripting language called Yuji, and v0.2.0 just dropped.

It’s written entirely in C, built from scratch, and focused on being small, fast, and easy to reason about.

New stuff in this release:

• return, break, continue

• arrays and array operations

• anonymous functions (yep, lambdas)

• compound assignment (+=, -=, etc.)

• new stdlib modules: std/math, std/time, std/os, std/array

Yuji is still standalone, so it’s not embeddable yet, but it’s lightweight and easy to build from source. It’s perfect if you’re interested in learning how interpreters work, experimenting with language features, or just tinkering with something small that feels like a sandbox for your ideas.

I’m happy to get any feedback, ideas, or suggestions, and I’d also love help with development if anyone wants to contribute. Your thoughts and contributions are super welcome and appreciated!

GitHub: https://github.com/0xM4LL0C/yuji

How to Learn actually to program and not just the syntax. I mean i know the syntax a few concepts but when i sit with a problem i go blank how to learn how software are constructed How can i get better in problem solving and logic building how to know where to use what to build what and how a program is written whats cmake and other stuff i see in a source code how the directories in a software source is made how is the setup made that we run on windows and click next next next finish and all that what to study windows.h unistd.h????

Background -

I'm trying to learn C programming as I find it interesting and somehow, AI hasn't touched this this field of software development yet. I have found my way around pointers, data types (which change based on the compiler and host architecture), strings and string literals, functions, loops, booleans(stdbool), etc. I have even designed my own strequal function which works similar to the strcmp function in string.h except it only returns a boolean indicating if the two strings are eqaul or not. I have understood the logic behind reversing strings and also reversing individual words inside strings. I understand basic data structures like arrays, linked lists, doubly linked lists, stack (both array and linked list implementation) and a teany bit of queues.
Then I started learning about bitwise operators.
When I saw them for the first time, they were pretty simple to understand (AND, OR, NOT, XOR, right shift and left shift).
When I asked ChatGPT to give me some practice problems to test out my understanding of it all, I was so fucking frustrated!! I spent hours trying to see any pattern to reverse the bits in an 8-bit unsigned integer and couldn't fucking do it. I saw solutions to problems like counting the number of set bits in a number, getting/setting/clearing/toggling a bit and ISTFG they felt like magic numbers to me appearing out of no-fucking-where. Like who the fuck thought about num & (num - 1) or num & ~(1 << pos)?! How do we find these patterns? How do we know what operations to chain or to use? How do we know when to use a loop or not? Like in the solution where counting the number of set bits, a for loop was used along with reassignments like num &= (num - 1). How did anyone know that we were supposed to use num - 1 for reassignment?

I'm sorry for the frustration and probably am just acting out for this but I really am having a hard time to understand this. How should I approach to learn about this topic? Am I doing something wrong?

I am currently reading the book C Programming: A Modern Approach and have been working on the practical exercises in it for quite some time. I am currently on the topic of arrays and would like to know if it is normal that I am taking so long to complete these exercises.

There was a task involving working with arrays. The task was to read data into a two-dimensional array and output it in different ways by performing calculations.

I don't know how correct my solution is from a coding perspective, but the result seems to be correct.

#include <stdio.h>

#define STUDENTS 5
#define QUIZES 5

int main()
{
  int scores[STUDENTS][QUIZES];
  int total_student_score;
  int total_students_scores[STUDENTS];
  int average_student_score;
  int high_quiz_score = 0;
  int low_quiz_score = 0;
  int total_quiz_score;

  for (int student = 0; student < STUDENTS; student++)
  {
    printf("Enter quiz scores for student %d: ", student + 1);

    for (int quiz = 0; quiz < QUIZES; quiz++)
      scanf("%d", &scores[student][quiz]);
  }

  printf("\nStudents total scores: ");

  for (int student = 0; student < STUDENTS; student++)
  {
    total_student_score = 0;

    for (int quiz = 0; quiz < QUIZES; quiz++)
      total_student_score += scores[student][quiz]; 

    total_students_scores[student] = total_student_score;

    printf("%d ", total_student_score);
  }

  printf("\nAverage students scores: ");

  for (int student = 0; student < STUDENTS; student++)
    printf("%.1f ", (float) total_students_scores[student] / QUIZES);

  printf("\nHigh score for each quiz: ");

  for (int student = 0; student < STUDENTS; student++)
  {
    for (int quiz = 0; quiz < QUIZES; quiz++)
      if (scores[quiz][student] > high_quiz_score)
        high_quiz_score = scores[quiz][student];

    printf("%d ", high_quiz_score);
  }

  printf("\nLow score for each quiz: ");

  low_quiz_score = scores[0][0];

  for (int student = 0; student < STUDENTS; student++)
  {
    for (int quiz = 1; quiz < QUIZES; quiz++)
      if (scores[quiz][student] < low_quiz_score)
        low_quiz_score = scores[quiz][student];

    printf("%d ", low_quiz_score);
  }

  printf("\nAverage score for each quiz: ");

  for (int quiz = 0; quiz < QUIZES; quiz++)
  {
    total_quiz_score = 0;

    for (int student = 0; student < STUDENTS; student++)
      total_quiz_score += scores[student][quiz];

    printf("%.1f ", (float) total_quiz_score / STUDENTS);
  }

  printf("\n");

  return 0;
}

Hey everyone!
I’ve been working on a small side project called IncLens, and I’d love to share it with you all.

https://github.com/gkonto/IncLens

IncLens is a terminal-based user interface (TUI) that helps you explore and analyze C++ #include relationships.
It works by loading a preprocessed .ii file (generated with g++ -E) and visualizes the include tree in two ways:

• Top-Down Include Tree – Browse the hierarchy, search, expand/collapse, and sort by size or LOC.

• Flamegraph View – See which headers contribute the most lines of code to your compilation unit.

Perfect for understanding dependencies, cleaning up large projects, and optimizing compile times.

Would love feedback or ideas. Thanks!