lixiasky

Thanks for the catch! You’re spot on about the missed wakeups. It's still a very early prototype—mainly just wanted to see if this whole architecture holds water. I'll definitely be adding the #StoreLoad fence and tightening up the memory ordering in the next push. Appreciate the feedback!

I didn't realize the mods had un-killed this post yesterday, so my apologies for the late replies. I'm very grateful to them for doing that—I just only now saw that it was live.

Haha, point taken! I will try to dial down the "customer service mode" :) Re: GitHub: Yeah, thankfully I had the local git history, so the code was safe. Just lost the community interactions (stars/issues), which was a bummer. Re: Felix: That sounds exactly like what I need. Being able to define custom schedulers within the language is pretty much the holy grail I'm chasing here. I'll put it on my reading list for tonight.

Haha, you have a really sharp eye! 1. The Baby Wireshark: Unfortunately, my previous GitHub account got flagged/shadowbanned (still not sure why, and the appeal didn't work), so I lost access to that repo. I had to start fresh with this new account. 2. The Tone: You caught me! English is not my first language. I do use LLMs to help polish my grammar because I want to ensure my technical points are clear and I don't accidentally sound rude due to language barriers. Also, I learned most of my English from reading technical documentation and watching TED talks, so my "default" style tends to be a bit formal—just like an AI! :)

The legendary "Coroutines in C" article!

Thanks for the reference—I learned a lot from his work. His use of macros to hide the switch statement is basically the spiritual ancestor of co_await. It is wild to think that C++20 essentially standardized that exact pattern, just moving the "state machine generation" from the preprocessor hacks to the compiler itself.

You are absolutely right about the history (Conway coined the term in '63!). The assembly stack-switching you mentioned is the classic "Stackful" approach (like Fibers or Boost.Context). C++20 went the "Stackless" route (compiler-generated state machines) to avoid the per-stack memory overhead, though it certainly makes the implementation mechanics trickier. Lua is definitely a gold standard for asymmetric coroutines. As for Felix—I actually wasn't familiar with it until you mentioned it. Thanks for the pointer! I'll definitely dig into their docs to see how they handle scheduling compared to the C++20 approach.

Oh absolutely! Adam Dunkels' work is legendary. It's kind of poetic that Protothreads achieved stackless concurrency via C preprocessor macros and Duff's device tricks, and now years later, C++20 finally baked that exact same "state machine via switch-case" logic directly into the compiler. Same spirit, just less macro magic! :)

You are spot on about the distinction. C++ chose the stackless path for "zero-overhead" efficiency, but it definitely shifts the burden of safety and usability onto the library developers. Regarding safety and data sharing: You're right, C++ won't enforce isolation like Erlang. That's the trade-off we make for performance. However, to address your point about "sane wrappers" and concurrency models: I actually implemented Go-style Channels (CSP) on top of this scheduler to bridge that gap. It uses co_await to mimic Go's channel behavior, supporting Direct Handoff (skipping the buffer/queue if a receiver is waiting) and optimization via await_suspend returning false to avoid context switches on the fast path. While a full-blown STM might be too heavy, I found that combining these Channels with Epoch-Based Reclamation (EBR) gives a pretty robust safety net without the overhead of heavy locking. If you're interested, the Channel implementation is here: https://github.com/lixiasky-back/tiny_coro-build_your_own_MN...

That is a fascinating comparison! History really does rhyme. What you described—suspending with a flag and resuming with new values—is surprisingly similar to how the C++20 compiler transforms coroutines into a state machine under the hood. In tiny_coro, the promise_type essentially manages that "inversion of control" you mentioned, but hides the manual state management behind the co_await syntax. It's really cool to see that these fundamental patterns for "stopping and resuming" computation have existed for so long, just in different forms.

You hit the nail on the head. C++20 coroutines are indeed complex and the barrier to entry is high. However, that complexity actually forced me to start from first principles. It drove me to tackle the essential problems from the ground up, which gave me a much deeper understanding of how coroutines truly work. That is exactly why I built this project—I wanted to create a minimal "laboratory" to dissect stackless coroutines without the overhead of a massive framework like Seastar. Regarding your point on Erlang/Go: That's actually the goal of this scheduler! It implements the M:N threading model (Work-Stealing) to simulate that kind of "lightweight process" concurrency, but giving you manual control over the mechanics. Hope this helps you finally wrap your head around co_await!

Whoa, that sounds really cool — I like the idea.

Thanks for the question!

Yes, Vanta currently relies on gopacket for packet capture and parsing. As a student, my main goal was to build something clear, functional, and real — rather than reinvent everything from scratch.

I'm actively learning the details of network protocols, and I do plan to write some custom parsers later, both for flexibility and personal understanding. But at this stage, I think it’s more important to deliver a meaningful tool than to prove I can reimplement low-level stacks.

In the long run, I may gradually replace parts of gopacket, but right now it's an important and reliable foundation for the project.

(And honestly — finishing something real matters more to me than perfection )

Haha, true to tradition, right?I’ll make sure to add an “Enable Historical CVEs” flag in the next release

Totally fair! I really appreciate the honesty. English isn't my native language, and most of the expressions I know come from TED talks, open source READMEs, and honestly... the kind of news clips our teachers play in class

So yeah, that probably shaped the way I wrote this. You’re right though — reading it again, it does sound kinda overly polished.

I’ll try to keep future writing more personal and grounded. Still learning — and thanks for reading it at all. That already means a lot!

Thanks a lot for sharing this — it's super helpful!

Yeah, I’m currently using gopacket mainly to get something working fast, but I’ve been thinking about writing my own parsers from scratch to understand the protocols better.

Your Hdr example is really clean — definitely saving this as reference! I love how direct and readable it is.

I’ll definitely try going lower level when I revisit the packet layer logic. Thanks again for the nudge

Great question! I chose Go mainly because it's simple, efficient, and widely used — and honestly, it's the language I'm most comfortable with right now.

I'm still a student, and I don’t have super big ambitions yet — I just wanted to build something I could actually finish and understand

Rust is amazing, but I haven’t started learning it seriously yet. It feels a bit overwhelming at this stage. Maybe one day, when I'm ready to dive deeper!

Good luck with your Burp project too — I’d love to see it if you share it someday!

Thanks! I actually didn’t think that far ahead — I just wanted to build something within my ability, something that works and feels meaningful to me.

If it happens to fill a niche, that’s a lucky bonus

Thanks for sharing your experience! Go really does shine here—I felt that even as a student building Vanta while learning, things came together surprisingly well.

The features you mentioned sound awesome. I might give it a try later on—supporting stream breaks and debug controls sounds really fun

Thank you for this — I had read Linus' first post before and never imagined my tiny tool would be compared to something with that kind of legacy.

I'm just an undergrad student in China (not even CS major, unfortunately), and this little project was my way of saying thanks — to the schools that stood up bravely.

Really appreciate your kind words. Let’s see what comes next. :)