2026-02-06 09:13:43
At the end of the day, when the kid is asleep, I sit down in front of the TV and hours go by.
The algorithm tells me to consume, so I consume. The strength needed to fight it isn't there.
It never ends. Consume, consume, consume, consume.
Then it's time for bed. Repeat, evening after evening.
I don't know what I want from my nights, but I know its not this.
The only thing I know to counter consumption is creation.
The burn is there. The soul wants to make. That's why I'm doing this #100DaysToOffload writing challenge.
It's out of desperation. I can't keep going without creating something. Anything.
I want to have a body of work I can look back on and be proud of. Work that connected with someone, somewhere.
I know that I'll be throwing messages in a bottle into the infinite raging sea of the internet. I'll need to learn to be okay with that. But if it means I can tip the balance towards creation, I hope I can shake this feeling that an algorithm is in charge.
I've realized that in a world of consumption, creation is an act of rebellion.
And I really want to rebel.
2026-02-06 07:25:00
I've been building a modern C build tooling called cforge where it solves a lot of the issues in the C ecosystem. There has been requests for me to explain its main functionalities and how it helps eliminate one of the pain points of developing in C: its build tooling system, while they are functional and varied, are fragmented and difficult to use.
Moreover I then combined cforge with safe_c.h --> it gave birth to a wholly different user experience when writing C. It is very powerful, so much that I can't go back to use vanilla C. You know that thing once you found out about something and you can never go back? Some examples:
While I understand there might be issues with portability, I can never write vanilla C again and in this post I'll show you why.
One caveat though: I live in two worlds: finance and programming so I have a fairly busy schedule. I struggle to find the time to write this and it has been postponed since a month ago, hence I made the difficult decision to let AI produce an overview of cforge+safe_c.h
==Below is an AI generated overview of the features and capabilities of cforge and safe_c.h==
┌────────────────────────────────────────────────────────────────────┐
│ Systems Programming Landscape │
├──────────────┬────────────────┬──────────────────┬─────────────────┤
│ Language │ Safety Level │ Learning Curve │ Interop with C │
├──────────────┼────────────────┼──────────────────┼─────────────────┤
│ C │ Low │ Low │ Native │
│ C++ │ Medium │ High │ Native │
│ Zig │ Medium-High │ Medium │ Excellent │
│ Rust │ High │ High │ Complex │
│ safe_c.h │ Medium │ Low │ Native │
└──────────────┴────────────────┴──────────────────┴─────────────────┘
The Gap: There was no solution for C programmers who wanted:
────────────────────────────────────────────────────────────────────────────────
cforge introduces a staged compilation philosophy unique in the C ecosystem:
┌────────────────────────┬───────────────────────────────────────┬────────────────────────────┐
│ Traditional Build │ cforge Approach │Innovation │
├────────────────────────┼───────────────────────────────────────┼────────────────────────────┤
│ Single compilation │ Multi-stage validation │ Defense in depth │
├────────────────────────┼───────────────────────────────────────┼────────────────────────────┤
│ Manual sanitizer flags │ Automated sanitizer→hardened pipeline │ Simplified safety │
├────────────────────────┼───────────────────────────────────────┼────────────────────────────┤
│ No PGO by default │ Integrated PGO workflow │ Performance + safety │
├────────────────────────┼───────────────────────────────────────┼────────────────────────────┤
│ Per-project Makefiles │ Auto-generated build.zig │ Cross-platform consistency │
└────────────────────────┴───────────────────────────────────────┴────────────────────────────┘
Key Insight: cforge treats compilation as a verification pipeline, not just a translation step.
# Traditional: Just compile
gcc -o app main.c
# cforge: Validate then compile
Stage 1: fanalyzer (static analysis)
Stage 2: ASan/UBSan (runtime verification)
Stage 3: clang-tidy (code quality)
Stage 4: Hardened release (production)
The cforge test suite excels through zero-configuration auto-registration (constructor-based), crash resilience (signal handlers for segfaults), and a two-tier assertion model (fatal/non-fatal)—all within a single dependency-free header. Its tight integration with the cforge build pipeline automatically runs tests under AddressSanitizer, providing memory safety validation without extra setup, making it ideal for teams wanting modern testing ergonomics without leaving the C ecosystem.
Using GCC/Clang cleanup attribute (now C23 [[cleanup]]):
// Before: Manual cleanup, error-prone
FILE* f = fopen("data.txt", "r");
if (!f) return -1;
// ... 50 lines later, forgot fclose() or return path missed it
// After: Automatic cleanup
AUTO_FILE(f, "data.txt", "r"); // fclose() guaranteed
Contribution: Brings deterministic resource management to C without requiring C++ destructors or Rust ownership.
// Generates complete type-safe vector implementation
DEFINE_VECTOR_TYPE(Player, struct Player)
PlayerVector team;
player_vector_push_back(&team, (Player){.health = 100});
// Type-safe: compiler enforces Player type
Contribution: Proves that C macros can provide generics-like functionality with better error messages than C++ templates (no SFINAE madness).
DEFINE_RESULT_TYPE(Int, i32, const char*)
ResultInt divide(i32 a, i32 b) {
if (b == 0) return RESULT_ERROR(Int, "Division by zero");
return RESULT_OK(Int, a / b);
}
// Explicit error handling - no exceptions
ResultInt r = divide(10, 0);
TRY(r); // Early return on error
Contribution: Rust-style error handling in C without language changes or exception overhead.
UniquePtr ptr = UNIQUE_PTR_INIT(malloc(100), free);
void* data = unique_ptr_get(&ptr);
// ...
// Automatic cleanup at scope end
Contribution: Proves RAII patterns can work in C without vtables or runtime overhead.
The annotation system is novel for C:
typedef struct REFLECTED {
JSON_KEY("player_id") // Metadata for code generator
i32 id;
VALID_RANGE(0, 100) // Validation constraints
f32 health;
} Player;
Contribution: Demonstrates that C can have modern reflection through:
This bridges the gap between C's compile-time simplicity and modern introspection needs.
────────────────────────────────────────────────────────────────────────────────
Unlike Rust or Zig which require rewriting, cforge enables incremental adoption:
Existing C Codebase
│
▼
┌─────────────────┐
│ Phase 1: Drop │ Add safe_c.h header
│ in safe_c.h │ Use AUTO_FILE, AUTO_MEMORY
│ │ Risk reduction: Medium
└─────────────────┘
│
▼
┌─────────────────┐
│ Phase 2: Use │ Replace manual arrays with vectors
│ type-safe │ Add Result error handling
│ containers │ Risk reduction: High
└─────────────────┘
│
▼
┌─────────────────┐
│ Phase 3: Add │ Annotate structs for reflection
│ reflection │ Auto-generate serializers
│ │ Development velocity: Increased
└─────────────────┘
│
▼
┌─────────────────┐
│ Phase 4: Full │ Use cforge build pipeline
│ cforge │ PGO, hardening, cross-compilation
│ integration │ Production readiness: High
└─────────────────┘
Impact: Lowers barrier to entry for safety improvements—no rewrite required.
cforge's use of Zig as a cross-compiler backend:
cforge target aarch64-linux-musl
# Automatically handles:
# - Toolchain acquisition
# - Flag translation (removes -march=native for cross)
# - Static linking configuration
Contribution: Makes cross-compilation accessible to C developers who would otherwise struggle with complex toolchain setup.
safe_c.h serves as a reference implementation for:
Impact: Educational resource for C developers wanting to modernize their skills.
────────────────────────────────────────────────────────────────────────────────
┌──────────────────┬──────────────────────────────┬────────────────────────┐
│ Aspect │ C++ │ cforge + safe_c.h │
├──────────────────┼──────────────────────────────┼────────────────────────┤
│ Learning curve │ High (templates, RAII rules) │ Low (still C) │
├──────────────────┼──────────────────────────────┼────────────────────────┤
│ Compile times │ Slow (templates) │ Fast (macro expansion) │
├──────────────────┼──────────────────────────────┼────────────────────────┤
│ Binary size │ Can bloat │ Predictable │
├──────────────────┼──────────────────────────────┼────────────────────────┤
│ Debugging │ Complex (name mangling) │ Simple (C symbols) │
├──────────────────┼──────────────────────────────┼────────────────────────┤
│ Interoperability │ ABI issues │ C ABI (universal) │
└──────────────────┴──────────────────────────────┴────────────────────────┘
cforge's niche: "I want C++ features but in C."
┌────────────────┬─────────────────────────────┬─────────────────────────┐
│ Aspect │ Rust │ cforge + safe_c.h │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Memory safety │ Compile-time guaranteed │ Runtime detected │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Learning curve │ High (ownership, lifetimes) │ Low (C + macros) │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Migration │ Rewrite required │ Incremental adoption │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Ecosystem │ Growing but smaller │ Vast C ecosystem │
├────────────────┼─────────────────────────────┼─────────────────────────┤
│ Hiring │ Harder to find developers │ C developers everywhere │
└────────────────┴─────────────────────────────┴─────────────────────────┘
cforge's niche: "I need safety improvements but I don't want to rewrite. Rewrites are waste of time."
┌──────────────────┬────────────┬─────────────────────┐
│ Aspect │ Zig │ cforge + safe_c.h │
├──────────────────┼────────────┼─────────────────────┤
│ Comptime power │ Native │ External (Python) │
├──────────────────┼────────────┼─────────────────────┤
│ C interop │ Excellent │ Native (it's C) │
├──────────────────┼────────────┼─────────────────────┤
│ Build system │ Integrated │ External (cforge) │
├──────────────────┼────────────┼─────────────────────┤
│ Reflection │ Native │ Generated │
├──────────────────┼────────────┼─────────────────────┤
│ Tooling maturity │ Young │ Leverages clang/GCC │
└──────────────────┴────────────┴─────────────────────┘
cforge's niche: "I want Zig's safety but in C."
────────────────────────────────────────────────────────────────────────────────
Unlike Rust or Zig, cforge allows teams to improve safety without rewriting a single line of legacy code. Just include the header and start using AUTO_FILE for new code.
The combination of sanitizer→hardening pipeline is unique:
# One command gets you:
# - AddressSanitizer (development)
# - Stack canaries (production)
# - Control-flow integrity (production)
# - PGO optimization (production)
cforge pgo main.c
safe_c.h demonstrates that C can be used as a portable assembly with safety guardrails, challenging the narrative that C is inherently unsafe.
The annotation→generation approach proves you can have:
────────────────────────────────────────────────────────────────────────────────
┌───────────────────────────────┬────────────────────┬─────────────────────────┐
│ Limitation │ Impact │ Mitigation │
├───────────────────────────────┼────────────────────┼─────────────────────────┤
│ No borrow checking │ UAF still possible │ ASan catches at runtime │
├───────────────────────────────┼────────────────────┼─────────────────────────┤
│ Macro-based generics │ Weak type checking │ Careful use, tests │
├───────────────────────────────┼────────────────────┼─────────────────────────┤
│ External reflection │ Build complexity │ Automated by cforge │
├───────────────────────────────┼────────────────────┼─────────────────────────┤
│ Manual cleanup still possible │ Can forget defer │ Code review, linters │
└───────────────────────────────┴────────────────────┴─────────────────────────┘
cforge reflect # Generate code
cforge build # Compile
This is more complex than single-step compilation, though cforge automates it.
────────────────────────────────────────────────────────────────────────────────
safe_c.h demonstrates demand for:
cforge shows a migration path:
By integrating:
cforge raises the bar for what C build tools should provide.
────────────────────────────────────────────────────────────────────────────────
The REFLECTED, JSON_KEY, VALID_RANGE annotations suggest a future where:
cforge's use of Zig for cross-compilation suggests a trend:
────────────────────────────────────────────────────────────────────────────────
cforge + safe_c.h contributes the "missing link" in systems programming: a way to write safer C without leaving C.
Its key contributions are:
For the C ecosystem, this means:
The ultimate contribution: Showing that C's obsolescence is not inevitable—with the right headers and build tools, C can remain viable for new development while teams gradually migrate to Zig or Rust.
cforge with safe_c.h represents a novel "progressive enhancement" approach to modernizing C—delivering C++17/Rust-like safety and ergonomics without abandoning C's core philosophy or requiring language changes. It fills a critical gap in the C ecosystem: how to write safer C without learning a new language or accepting runtime overhead.
Some screenshots of cforge:
How does this cforge+safe_c.h combo affect my programming?
I'm currently using cforge+safe_c.h for a monsoonsim-lite project ~ a CLI-based business simulator. Another question I get asked frequently: will I open source the code for cforge and safe_c.h ? I'm not sure, most of the programs I've built are for internal use either me personally or office related work.
I actually don't want a "maintainer's life" as the creator of Zen-C is currently having. As mentioned earlier: I live in 2 worlds (finance and programming). I built something, it works for me and that's it. If there's a bug I'll fix it, if there's additional features that I need, I'll make the features.
The key: it revolves around to what I need and my use case, I'm not interested to what others need. So yeah it's the opposite mindset of a maintainer. Why do I have this mindset? Coz I've burned out before trying to fulfill other people's requests and I don't want to repeat that. Sorry for the rant...cheers!
==If you enjoyed this post, click the little up arrow chevron on the bottom left of the page to help it rank in Bear's Discovery feed and if you got any questions or anything, please use the comments section.==
2026-02-06 05:09:00
to all people that keep complaining about blogs not using capital letterS. i am proposing a new alternativE. this is not sentence case, title case or upper casE. this is end casE. does it satisfy yoU? this looks absolutely horrible and you are responsible for iT. this is the consequence of your actionS. hope you are happY.
i'm just tired of reading the same old take in discover about thiS. i get it, you don't like iT. good thing though this isn't your bloG. this is my place and i'll express myself however i wanT. and yes this also includes using end casE.
p.s. this also solves the issue of not being able to tell when a sentence beginS. or endS. though we are mostly focusing on the ends herE.
edit: i now have a javascript thingy that applies this to my whole bloG. you will suffer with mE.
2026-02-05 16:48:00
If there is one thing I have learned about my blogging after having the recent 'trending when trying to delete a blog' thing, it is to strike while the iron is hot, as it were. Start writing something the second that a thought strikes, rather than thinking 'I'll make a note of that thought and come back to it when time allows'. Because I don't.
Also, finish it then, because while 151 opening paragraphs kept may seem like 'a resource' to dip back in to, you actually have no idea of the headspace you were occupying and can't remember how you were thinking of developing the post from there now.
But this may just be me.
 
This is why, after reading my Bear blog Discover RSS feed this morning, I am now writing about the annoyance I feel when the cool kids writing other blogs do that 'not using capital letters at the start of sentences' thing on their blogs.
Why is that cool? It's as cool as that old trend of putting an i in front of product names to give it a bit of reflected coolness was in the early noughties. iPod begat iPhone, then everyone was at it until we had iSocks, iDonuts, and iDon'tKnowWhatElse.
It's not cool now. We laugh at it now, because now we have put an A in front of the i. Much cooler.
Then we're leaving out the vowels to make brand names. Wld t b cl t lv th vwls t? No. Unreadable nonsense.
Anyway, yes, no capital letters in your blog posts. Perhaps I'm just old fashioned, like everyone else that has existed since humans started using text and reading, but capital letters at the start of a new sentence was there for a reason. To tell you when it was the start of a new sentence.
I mean, it seems obvious. It's so easy for a brain to skip over an itsy-weeny full stop if there's not a capital letter ahead of it, signalling a new sentence is imminent. Without it, your mind is careering off through the words like being on a runaway train, looking out desperately for a safe punctuation station to jump off at.
The same signals are in my brain for reading, and have been since I first stunned my Dad by reading out some words I recognised from the bedtime story book when I was about three years old.
Now, if I was writing something that should feel like a stream-of-consciousness then perhaps the lack of capitals would make sense, but in that context the bloody full stops you do use don't make sense – we want commas and other non sentence-ending-signal punctuation to keep the stream flowing, not stopping.
Stop.
And although he can't be arsed to use any other punctuation that is considered normal, even Cormac McCarthy uses capitals for sentences (I think he does anyway, it's been a long time since I saw them – I lent my brother two of Cormac's novels fifteen years ago and haven't seen them since).
I suppose it boils down to this. A style. An affectation. To be different. but is also more difficult to read.
NB: There is no prize for writing me an email that points out that my titles do not use title case, i.e. Capital Letters At The Start Of Words, and therefore '...you have no idea what you're talking about'. You can write one anyway if you like. I'll put it in my 'hush now' folder.
NB(2): Also, the article above is written in a somewhat subtle and not quite earnestly meant manner that may be hard for certain nationalities to pick up on. Perhaps the same people who will have no idea what a full stop is.
NB(3): I thought this was quite amusing. I fill in the title (CAPITALS), Bear blog auto-populates the link field with 'capitals'... not in capitals. OK, just me, easily amused.
 
post link for sharing: {{ post_link }}
If you got this far, you may as well click the star below on your way out.
2026-02-05 11:29:00
Schopenhauer: "Life swings like a pendulum backward and forward between pain [of unfulfilled desire] and boredom [of satisfaction]."
Earlier E made me aware of a new drop for this product we like. A cute design caught my eye, and now I want another. Thing is, I don't need it. I barely use the one I currently have because I don't like putting up with its maintenance. If I acquired another it would surely suffer the same fate.
A few weeks ago I bought myself a pair of boots off Facebook Marketplace. I knew my size from trying them on in-store and scoured Marketplace diligently for months before finally pulling the trigger on a brand new pair selling for three-quarters retail price. I went to the Upper East to get them, handed over the cash, and they were mine.
I wore them around the house for a few days, did chores in them. They didn't feel quite right. I wanted more space in the toebox than they afforded me, and I hated how hard it was to take the shoe off. I wasn't as enamored with the look as I thought I'd been. Within days, I listed them on Marketplace, and not even a week after I'd gotten hands on them, I let them go.
This whole ordeal is illuminating to me. I live in a city where it is easy to get almost anything you want: pretty much every brand has a flagship store here, and the secondhand and used market is very much alive and well. And for as hard as I have tried, I have succumbed to many of its wiles. What have I learned? I get things I think I want; I realize I don't want them; and I get rid of them, sometimes at significant cost to myself (in time or money). Then my brain fixates on something else and the cycle begins anew.
It's not that I didn't know this before. I complain about it all the time. Being here just accelerates this cycle so I can see it for the farce it is. I suppose being able to get rid of stuff I realize I don't want and learning about myself in the process is not entirely a bad thing. But what stands out to me most is how much time and energy and attention I waste desiring things I don't even end up wanting or enjoy owning. I wish I could turn these desires off, or at least channel them into more productive pursuits like reading or writing or making music. I haven't figured this out yet. Some things help, like avoiding advertising and forums that center around a material hobby. But you can't run away from advertising forever. The ideas of nice things always worm their way into my head eventually.
Something else I noticed after buying the boots is that I was extremely cautious not to wear them outside or otherwise use them in ways that would show signs of wear, lest I decrease the resale value. Had I been somewhere I wouldn't have been able to sell them, I might have worn them longer, broken them in, learned to love the way they looked and felt. But here, with the possibility of getting rid of them looming a click away, I'm picky. Something to be said here about the illusion of choice, I guess.
2026-02-05 04:30:00
The average 25 year old isn’t making $100K a month or even in a year.
Most are making like $20K-$40K a year.
Some are making less.
Some are still figuring out what they even want to do.
But if you’re online all day, you’d think everyone your age is a millionaire.
Every other post is someone flexing their revenue/ lifestyle.
Their “I’m 17 making 500k a month” bullshit.
Can’t even lie I do the same…
And it creates this warped reality where you feel like you’re failing because you’re not there yet.
For every “22-year-old millionaire entrepreneur” with a Lambo, there are millions of 22-year-olds struggling to even make rent money.
You’re not behind.
You’re just comparing yourself to people who have extreme advantages one way or another.
Chasing six figures just because the internet told you to is sad.
I’m not saying don’t be ambitious.
I’m not saying don’t want more.
I’m saying build something that you’ll eventually love building.
Because the truth is, most of those people flexing online?
They’re miserable too.
Stop letting Instagram convince you that you’re failing.
Build at your own pace.
It’ll work out eventually, now or 5 years from now.