Basically title. I feel deterred from using local arrays because I cannot check in my C code if the allocation was successful.

Is it true that in C you cannot guarantee that a local array will not overflow the stack? Isn't it detrimental to any memory safety critical application. For a stack allocation, aren't there any guarantees in the C language that could help me make at least some decision about the safety of it?

If memory safety was critical, should local arrays be avoided for the possibility of stack overflow – and only dynamic allocation should be used?

Malloc gives you NULL when heap has not enough space but alloca and local arrays don't give any warning when stack has no space. Why does alloca have no similar system? I get that you can check the size and calculate the remaining space on the stack using system's api and that'd be a guarantee that the space won't be a problem.

I have a recursive data-structure (a simple linked list for purposes of this example) and wanted to statically define a linked-list. The following works fine:

#include <stdio.h>
typedef struct mytype_tag {
    struct mytype_tag* next;
    char* data;
} mytype;

mytype a = {
    .next = NULL,
    .data = "a",
};
mytype b = {
    .next = &a,
    .data = "b",
};

int
main() {
    mytype* s = &b;
    int i = 0;
    while (s) {
        printf("%d: %s\n", i++, s->data);
        s = s->next;
    };
}

However, I have to explicitly define/declare a and then have b take &a.

Is there a way to do this with anonymous/unnamed intermediary structures, thinking an imaginary syntax something like

mytype b = {
    .next = &((mytype)={
        .next = NULL,
        .data = "a",
        }),
    .data = "b",
};

so I can build up the linked-list without naming each intermediary instance?

I just finished the C programming course from BroCode on YouTube, and I'm still finding it hard to write a simple to-do list, is this a skill issue thing or it's just normal, I feel kinda incompetent

please could I get tips to help master the language properly!

I've built a C project with a clock-like system interface, but I'm very busy. Could the community help?

Link to my project: https://github.com/phuocthanhlamnguyen-gif/Time-system.git

You don't really need to follow the rules, but most of the rules are logical, and you can follow the license- not my rules, but it's optional, so I'll let you decide

I'm working on a program for tracking my account balances, budgeting/saving, spending analysis, etc. The program won't use/store sensitive info like SSN, account numbers, etc. - just transaction amounts, transaction categories/descriptions, and made-up account names. Additionally, there will be no web transfer - it's all offline, manual entry.

My question is: Do I need to worry about encryption?

Sorry if this sounds ridiculous - I just don't want to inadvertently screw myself with a hobby project.

Hi Folks!

I simply want to share this empirical study on the LLVM -O3 pipeline on the PolyBench suite.
I don't want to bore you with too many details that are already in the paper.
Any feedback is welcome :D

Blog post: https://federicobruzzone.github.io/posts/a-multi-dimensional-per-pass-empirical-study-of-the-llvm-optimization-pipeline.html
arXiv: https://arxiv.org/pdf/2606.31238

just gave my second semester exam and i have been writing #include<stdio.h> instead of the genral one technically my syntax is correct but i am scared that what if what if examiner does't have knowledge that my syntax is correct as well and reduces my marks or fails me :((((((((((((((((((((((((((((((((((((((((((((((((((((

i am reallly scared since i come from pretty trashy university and i just i hope i don't get less marks than expected or fail the subject

can any senior give me any advice in the comment or dms please?

I have become extremely fascinated with compiler development and want to eventually build a real compiler as a hobby project. My goal isn't just to follow a tutorial and copy code—I want to understand how compilers work at a deep level.

I've already started learning the prerequisites (computer organization, C++, data structures, etc.), but I'm looking for advice from people who have actually built compilers.

Some questions I have:

• If you had to start over today, what learning path would you follow?
• Which books would you consider essential?
• Are there any projects or milestones that helped everything "click"?
• Should I implement multiple small compilers before attempting a serious one?
• Is it better to use tools like Flex/Bison at first, or hand-write the lexer and parser to understand the fundamentals?
• How much compiler theory should I learn before I start building?

I'm looking for recommendations on books, papers, courses, blogs, repositories, or any other resources that helped you become proficient in compiler engineering.

I'd also appreciate hearing about mistakes you made while learning that you'd avoid if you were starting again.

Thank you, and yes this is all ai generated , I am sorry for this my English very bad i have to use ai

In C++, when you want to make a struct or class or function that acts upon/uses a type whose features are generally unimportant, you use templates. For example std::vector<T>, and that (as far as I'm aware), tells the compiler that whenever it sees something like std::vector<AStruct>, it should generate code that acts on a vector of AStructs. This is a useful feature that C doesn't have (which I'm fine with, there are workarounds, especially a really fucky workaround I saw on SO).

I'm assuming that one advantage of C++'s templates is that it can use SIMD, vectorized instructions, and all the other fun stuff that make a lot of actions faster, because it knows the size of std::vector<int> vs std::vector<string>.

In C, when I try to make type that's generic (especially a data structure like a priority queue), I have to have a (usually) void * and a size_t, one for where the data is, and for how big one object of that data is.

Here comes my question:

Can most C compilers, based off of the usage of the structs, realize that "Oh, this is basically always guaranteed to be used on the type int32_t, so I can just compile it with that in mind", or do I have to un-Genericify my struct for that?

(Note: I am aware of using Macros to achieve technically-generic-but-typed structs, however there are apparently issues with "eating your own dog food" when you try to make a queue of queues, for example. I'd rather avoid that, even if I probably won't eat my own dog food)

Run Go Online (1.21, 1.26)

I want to study system level development with C and automation with python/bash.

So, after thinking so much I want some resources. Mainly on C including //Best resource to learn to make a shell//

I am thing of learning cpp, when I will be ready to see death eye to eye.

Now, I can't figure out what to study. I am a busy scheduled high school student so I will have very less of time.

I have done python 2 years ago, and C 6 months ago. And, used linux with bash commands.

Is it safe to say that figures, at the core are technically constant variables in C?

I am still very far in the journey learning about lvalues and rvalues so I am genuinely curious.

Quick update: I just released tmuzika 1.1.3.

This is a small maintenance + usability update based on recent fixes and feedback.

What’s new:

improved stability in playback handling

fixed a few edge-case crashes in file navigation

better performance when loading large playlists

minor UI polish and consistency fixes

This release is mainly focused on making the app more reliable and smoother in daily use rather than adding major new features.

As always, feedback is welcome — it directly shapes these updates.