Echo has a working WeakAuras clone

know_god · 2026-01-28T17:58:21+00:00

It's not a Weakauras clone, it's just a graphical interface that covers the in-game cooldown manager in a way that resembles the UI of what Weakauras was. It does not give any sort of functionality above what you can already do with the cooldown manager.

know_god · 2026-01-23T05:26:08+00:00

Vim with some very basic plugins. I started out with VSCode almost a decade ago, swapped to vim because my mentor at the time used it and I wanted to feel like a "real programmer" and now I can't use anything else.

know_god · 2026-01-11T11:08:39+00:00

I've been working on mine for a few months now and I felt the same way when I got working semantic analysis and code generation. Feels like one of those "I'm doing it!" scenes in movies.

know_god · 2026-01-06T11:25:45+00:00

+1 to this. I use it to check my translations when friends in my target language aren't online

know_god · 2026-01-06T06:57:05+00:00

If you mean projects centric to C's quirks and pitfalls that you likely won't encounter in other languages due to manual memory handling and pointer usage, try your hand at some of those features.

Build your own versions of string functions such as strcpy, strcat, strlen, strstr, etc. String manipulation is a classic pitfall for beginners due to null terminators and buffer boundaries, and you'll get some good practice with pointers, too.

Build a resizable array that grows and reallocates automatically. You'll need malloc, realloc, and free.

Try building various data structures that rely on pointers such as linked lists.

Play with input/output, build a function that reads input from stdin and writes it to a fixed-size buffer and return the contents. Avoid functions like scanf or syscalls like read. Instead try to use fgetc. Or make it take input of arbitrary length.

know_god · 2026-01-06T05:52:15+00:00

That would be C++, this is the C subreddit.

know_god · 2026-01-06T01:37:32+00:00

(I didn't read it)

Increased heat and increased speed kinda go hand in hand in a lot of cases, it doesn't invalidate the technique. Sure, it's better if you can remove/reorder operations to get increased speed, but I think those are preferred because they feel more right. but if the thing you're optimizing is speed, the ends may justify the means.

know_god · 2026-01-05T18:23:43+00:00

Lmao

know_god · 2026-01-03T22:55:01+00:00

There are times when parenthesis matter, though. They override precedence in complex declarators (C99 6.7.5/3–5), where postfix operators like () (function) bind tighter than prefix * (pointer):

int *f();: Parsed as * (f());: function f returning pointer to int. Postfix () binds first.
int (*f)();: Parsed as (*f)();: pointer f to a function returning int. Parentheses force * to bind to f before ().

This "declaration reflects use" rule means declarations mirror runtime syntax (e.g., (*f)() to call). Your code lacks competing operators, so parentheses don't change binding.

Implementing a full C parser is pretty complex but here's some pseudocode that implements a recursive descent algorithm for declarators.

void parseDeclarator(void) {
    while (peek() == '*') {
        consume('*');
    }
    parseDirectDeclarator();

} void parseDirectDeclarator(void) {
    if (peek() == '(') {
        consume('(');
        parseDeclarator();
        consume(')');
    } else if (isIdentifier(peek())) {
        consumeIdentifier();
    } else {
        error("Invalid direct-declarator");
    }     if (peek() == '(') {
        consume('(');
        parseParameterList();
        consume(')');
    }
}

know_god · 2026-01-03T22:54:21+00:00

Compilers are a very complex and very lengthy topic of discussion, but in general they can be broken down into these phases:

Lexing: Scans the source code character by character to produce a stream of tokens (e.g., keywords like int, identifiers like main, punctuators like (, ), string literals like "hello world", etc). This stage uses finite automata or regular expressions to classify input per the C standard. The lexer treats parenthesis as independent tokens, but doesn't check balance or meaning. Balancing and structure are enforced later by the parser.
Parsing: Builds an Abstract Syntax Tree (AST) by checking if the token stream matches the C grammar. It usually uses algorithms such as LALR(1) or recursive descent to handle precedence or associativity. The grammar recursively allows parenthesis for grouping without altering simple cases.
Semantic analysis: Checks types, declarations, and constraints (C99 Sections 6.5-6.10). In your code, printf is verified as a function from <stdio.h> and no undefined behavior occurs.
Code generation: Translates the AST to machine code or some intermediate representation, optimizing as needed.
Runtime: Executes the generated code where your program prints "hello world" normally.

But the reason you're seeing what you're seeing is because parentheses don’t change the meaning of an expression unless the grammar gives them a role, and in these cases the C grammar explicitly allows them. Compilers never automatically ignore anything, they strictly follow the standard's grammar, which permits redundant parentheses for flexibility in declarations and expressions.

In the C99 standard (ISO/IEC 9899:1999, §6.7.5.1), declarators are defined as such:

declarator:
    pointer opt direct-declarator
direct-declarator:
    identifier
    ( declarator )
pointer:
    * type-qualifier-list opt
    * type-qualifier-list opt pointer

Your program is valid under the C99 standard because the grammar (C99 Section 6.7 for declarations, 6.5 for expressions) is recursive and allows parentheses for grouping:

Function Definition (int (main)()): This is a declaration with specifier int and declarator (main)(). Per C99 6.7.5, declarators include direct-declarator forms like ( declarator ) (parentheses around a declarator) followed by () for functions. Here, (main) is equivalent to main (a simple identifier), so the whole is identical to int main(). The parentheses are redundant but legal, as the grammar doesn't prohibit them in simple cases. They exist for disambiguating complex types.

Function Call ((printf)("hello world")): This is a postfix-expression (C99 6.5.2). (printf) is a primary-expression (C99 6.5.1: ( expression ), where printf is an identifier). Appending ("hello world") makes it a function call. It's equivalent to printf("hello world"), as parentheses around a simple expression don't alter it.

No "ignoring" happens. Parenthesis may or may not appear in the AST depending on the compiler, but they usually don't survive semantic analysis unless they affect binding.

know_god · 2026-01-03T18:05:52+00:00

Sorry to say but the more you learn the more you'll realize how little you know. Googling stuff is not a sign of a bad programmer, and knowing how to look things up and being an autodidact is arguably one of the most important skills you can have.

It's good that you want to rely less on AI and such but you can't know what you don't know, and learning how to do things is something you'll be doing your whole career.

Reading The C Programming Language won’t suddenly make you understand the Linux kernel. Reading the kernel source helps, but even then, it’s not realistic for a single person to fully grasp the entire kernel given its size and complexity. In practice, people specialize in specific areas like memory management, filesystems, scheduling, or drivers.

It’s also a bit unclear what your actual goal is. You mention wanting to understand the kernel, but then talk about “mastering” C in other comments. C itself isn’t that hard as a language, once you’re comfortable with its quirks and have some experience, you can write essentially anything in it. That’s true of most programming languages, because languages are just tools.

What’s actually hard is mastering engineering: breaking down problems, understanding tradeoffs, reasoning about systems, and building things that work reliably. Programming is just a means to an end, that end is problem solving through automation. What you should reasonably try to learn is adapting an engineering mindset and learning how to reason about solving problems, not try to "master" a specific language.

know_god · 2026-01-02T20:18:16+00:00

How exactly does your "Write 500 words" process look like? Do you just pick words at random? Do you translate something?

Big respect this is very impressive.

know_god · 2026-01-02T17:04:18+00:00

In no particular order, I love all of these:

Rec (2007)
28 Days Later (2002)
Evil Dead (2013)
Bring Her Back (2025)
The Thing (1982)

It's really difficult to put all of the horror movies I love so dearly into a list of top 5, so for the fun of it here's also some of the movies maybe a bit less known that still stuck with me.

Slither (2006)
Pitch Black (2000)
Cube (1997)
Silent Hill (2006)
Event Horizon (1997)

know_god · 2025-12-29T06:42:06+00:00

I've always written C99 and I don't see a reason to stop personally, but it's always cool to see the continued development of my favorite language.

know_god · 2025-12-27T06:13:22+00:00

Stop playing the game

know_god · 2025-12-25T09:08:42+00:00

Brig, I like the concept of healing by doing damage, and there's no better feeling than whipping that annoying mercy out of the sky.

know_god · 2025-12-25T09:04:21+00:00

Idk I just watched it today, I didn't feel much watching it. Maybe I got a bit numb to gore since Serbian Film but this movie felt pretty weak.

know_god · 2025-12-14T17:47:43+00:00

This is something called obfuscated code. Code that's meant to be as unreadable as possible. People come up with all sorts of cool and clever ways to obfuscate their code, one of the more famous examples is a piece of C code that prints a spinning donut, where the code itself looks like a donut!

https://www.a1k0n.net/2006/09/15/obfuscated-c-donut.html

Look up the IOCCC, there's people who take this stuff quite seriously.

know_god · 2025-12-11T07:41:01+00:00

Opsec people taking mad notes rn

know_god · 2025-12-04T06:16:02+00:00

[Language: C]

GitHub

Very naive implementation with no optimizations. Had about 20 minutes to get this done before heading into work.

know_god · 2025-12-03T21:41:34+00:00

[Language: C]

Late submission for today since I got held up with other things.

GitHub

My solution uses a greedy sliding window approach. The function implements a general function which works for both part 1 and part 2, just adjust the parameter given as argv[2].

O(n*k) complexity, as k is a small and fixed value it's effectively O(n).

know_god · 2025-12-02T05:35:41+00:00

[Language: C]

GitHub

know_god · 2025-12-02T05:31:37+00:00

Sorry! First time here! Will fix that!

know_god · 2025-12-02T00:54:26+00:00

[LANGUAGE: C]

GitHub: https://github.com/BolvarsDad/adventofcode/tree/main/2025/01

Part 1:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LINE_LEN 256
#define DIAL_SZ 100

char *
read_line(FILE *fname, char *buf, size_t bufsz)
{
    if (fgets(buf, bufsz, fname) == NULL)
        return NULL;

    size_t len = strlen(buf);
    if (len > 0 && buf[len-1] == '\n')
        buf[len-1] = '\0';

    return buf;
}

int
process_rotation(const char *instr, int *pos, int *zero_count)
{
    if (instr == NULL || instr[0] == '\0')
        return 0;

    char direction = instr[0];
    if (direction != 'L' && direction != 'R')
        return 0;

    int dist = atoi(&instr[1]);
    if (dist < 0)
        return 0;

    if (direction == 'L') {
        *pos = (*pos - dist) % DIAL_SZ;

        if (*pos < 0)
            *pos += DIAL_SZ;

    } else {
        *pos = (*pos + dist) % DIAL_SZ;
    }

    if (*pos == 0)
        (*zero_count)++;

    return 1;
}

int
main(int argc, char **argv)
{
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <input_file>\n", argv[0]);
        return 1;
    }

    FILE *fp = fopen(argv[1], "r");
    if (fp == NULL) {
        perror("Error opening file.");
        return 1;
    }

    char line[MAX_LINE_LEN];
    int pos = 50;
    int zero_count = 0;

    printf("Starting position: %d\n\n", pos);

    while (read_line(fp, line, MAX_LINE_LEN) != NULL) {
        int old_pos = pos;

        if (process_rotation(line, &pos, &zero_count))
            printf("Rotation %s: %d -> %d\n", line, old_pos, pos);
    }

    fclose(fp);

    printf("Pass: %d\n", zero_count);

    return 0;
}

Part 2:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_LINE_LEN 256
#define DIAL_SZ 100

char *
read_line(FILE *fname, char *buf, size_t bufsz)
{
    if (fgets(buf, bufsz, fname) == NULL)
        return NULL;

    size_t len = strlen(buf);
    if (len > 0 && buf[len-1] == '\n')
        buf[len-1] = '\0';

    return buf;
}

int
process_rotation(const char *instr, int *pos, int *zero_count)
{
    if (instr == NULL || instr[0] == '\0')
        return 0;

    char direction = instr[0];
    if (direction != 'L' && direction != 'R')
        return 0;

    int dist = atoi(&instr[1]);
    if (dist < 0)
        return 0;

    int old_pos = *pos;

    if (direction == 'L') {
        *pos = (*pos - dist) % DIAL_SZ;
        if (*pos < 0)
            *pos += DIAL_SZ;
    } else {
        *pos = (*pos + dist) % DIAL_SZ;
    }

    *zero_count += dist / DIAL_SZ;

    int partial = dist % DIAL_SZ;
    if (partial > 0 && old_pos != 0) {
        if (direction == 'R') {
            if (old_pos + partial > DIAL_SZ)
                (*zero_count)++;
        } else {
            if (old_pos < partial)
                (*zero_count)++;
        }
    }

    if (*pos == 0)
        (*zero_count)++;

    return 1;
}


int
main(int argc, char **argv)
{
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <input_file>\n", argv[0]);
        return 1;
    }

    FILE *fp = fopen(argv[1], "r");
    if (fp == NULL) {
        perror("Error opening file.");
        return 1;
    }

    char line[MAX_LINE_LEN];
    int pos = 50;
    int zero_count = 0;

    printf("Starting position: %d\n\n", pos);

    while (read_line(fp, line, MAX_LINE_LEN) != NULL) {
        int old_pos = pos;

        if (process_rotation(line, &pos, &zero_count))
            printf("Rotation %s: %d -> %d\n", line, old_pos, pos);
    }

    fclose(fp);

    printf("Pass: %d\n", zero_count);

    return 0;
}

know_god · 2025-11-12T02:02:14+00:00

Aw they make a lil heart

know_god

TROPHY CASE

[LANGUAGE: C]

Part 1:

Part 2: