0x457A65

This body of work brings me great joy. Excited for the hundreds of developers who’ll find it valuable. If you’re serious about learning Solana development, take the Solana tutorial series from RareSkills.

RareSkills has a Rust learning platform for developers coming from other languages. There are over 700 problems tailored to take you from the basics (not exactly beginner-level, you should already know how to code in some language) to advanced topics. You can read books and watch videos, but you really learn by coding, and RareCode helps a lot with that.

In my last post, I said that here at RareSkills we try to be precise in our ZK book, but “precise” wasn’t the right word. When you aim to explain things to people outside the field, you often need to simplify. Total precision is the role of formal textbooks. What matters is not being superficial. You only truly learn Groth16, PLONK, or STARKs, if you can write the algorithm from scratch and understand what you’re doing. That’s our goal. We try to present these algorithms not as recipes, but as a natural sequence of thought. Given the right assumptions, the algorithm should come almost naturally. Precision comes with time and the reader’s maturity. If you are honest in what you present, and the reader learns what you set out to teach, they will naturally look for more advanced or more precise material later. No single resource can do everything. Ultimately, you don’t learn by just reading a blog post or watching a video. You learn by reasoning about the topic, doing calculations, and writing code. When I published my first scientific paper, I was afraid of making mistakes. Later, when I peer-reviewed papers, I saw how common mistakes actually are. Then I realized that mistakes are not the problem. They are part of the process. The real problem is intellectual dishonesty - simplifying beyond what is justified, overcomplicating what is simple, pretending to understand what you don’t, or just repeating ideas without truly engaging with them. What we seek here is intellectual honesty, always. That is why we spend so much time writing, rewriting, and reviewing our articles. Our review process is more picky than the Rust compiler. We put a lot of effort into what we do. Sometimes it’s genuinely tedious to explain something like the Kronecker delta — it feels obvious to you, but it may not be to others. Sometimes we succeed, other times we don’t. But we keep going.

Our ZK book is a work in progress. Today we published an article on the Inverse Number Theoretic Transform, continuing our series on the Number Theoretic Transform. We currently have modules on Elliptic Curve Cryptography, Groth16, Bulletproofs, Circom, and the Number Theoretic Transform. New modules are cooking. Our goal is to provide increasingly better education in ZK. We teach hard math in a didactic way, targeting developers rather than trained mathematicians. We make ZK digestible without being vague, while still being precise. Link in the first comment.

@veorq @jpmorais80 see.

I factored the number RSA1024-1 using my home-built QPU stack; alarming sign that RSA1024 will soon be broken. I'm choosing Full Disclosure, in the interest of transparency and Science advancement: gist.github.com/veorq/25bee6ef… Non-ZK proof that the correct RSA1024 was used: #RSA-1024" target="_blank" rel="nofollow noopener">en.wikipedia.org/w/index.php?ti… @yuvadm your move

When someone learns Groth16, it`s common to use Lagrange interpolation at some point. But Lagrange interpolation is mostly useful for demonstrations. Real-world applications rely on the Number Theoretic Transform instead. A ZK student needs to understand how NTT works - but that requires some background: groups, fields, Lagrange's theorem, roots of unity, primitive roots, then orthogonality of roots of unity, modular congruence, Vandermonde matrix, how to compute the NTT and its inverse using algorithms like radix-2 DIT and DIF, and when to use each. These topics are usually covered in depth only in signal processing textbooks - but there they are developed over complex fields, not finite fields, which is what we need. To bridge this gap, we at RareSkills are finishing writing a long series of 25 articles about these topics (15 already published) as part of our ZK book. It aims to teach you what NTT is from first principles, going through signal flow graphs all the way to a complete Python implementation for polynomial multiplication in O(n log n). To do this, we developed a way of understanding NTT that you won’t find elsewhere - not in textbooks, not in articles. We spent over a year reasoning about how to explain it as clearly as possible. Whether we succeeded or not is up to you, but we gave it our best =)

RareSkills education is so good that it's possible to learn Rust as your first language using our @RareCodeAI platform. We don't spam trending content for attention or rush to sell courses on the current meta. Everything we produce is extremely thoughtful and maniacally tested. After years of relentless and iterative feedback in the education arena, we learned how to bridge education gaps that conventional wisdom says are insurmountable. And we keep getting better every day. There's an even better product being trialed in a hidden beta now. More is coming.

After reading Posthog's blog about their recent issue and fix regarding their use of Tokio + Rayon, I decided to write about it. Unrelated to Rust, but a common problem I see with async/await as a primitive for concurrency. What do you think?

I'm hiring another researcher/writer. If you want to get paid to study and learn from the best about how to communicate complex subjects clearly, here's your chance. This isn't a job you can coast at. Lots of flexibility and autonomy, and few meetings, but weekend work is common. We have zero tolerance for mediocrity and lack of integrity, so don't waste your time applying if that scares you. Full-time only. You need to have demonstrated technical proficiency in at least one area of blockchain. Job application spam will not receive a reply. Link next.

8 kyū, 7 kyū and now 6 kyū. Codewars is really incredible to train on logic and discover how people really code. For someone like me (Rust as first language) I recommend: 1. @RareCodeAI to have solid fondations in Rust 2. @codewars to train on logic over and over again

2 weeks after public release, Tina is gaining some eyeballs. if you haven't already, check it out — don't say I didn't tell you :) I'm currently working on adding a HTTP lib extension, and in the process decided I had to change some things at the core for better socket handling.

May 12, 2026 Apply for cohort 2 of Invariant Testing Bootcamp taught by @GalloDaSballo from the audit firm @getreconxyz Did you know he's made over $500,000 in bug bounties? You'll look forward to your classes. rareskills.io/courses/invari…

If you are not learning/upskilling as fast as you want to, there are only three possible reasons: 1) You lack the prerequisites to understand your target learning objectives. You can't study compilers if you don't understand basic algorithms. Self-explanatory. 2) You lack good materials for the subject You know the prerequisites but you are still stuck. It may be due to a lack of good materials. Sure, any subject can be learned with effort, but you don't have unlimited time and energy. Inefficient learning materials that requires more time and energy than you have budget for become a soft barrier to learning. 3) You lack prioritization, focus, or energy Now suppose you have the prerequisites down, and you have good study materials (ahem @RareSkills_io). But you're still not progressing. Now the bottleneck is psychological. The psychological aspect of learning is not to be underestimated. It's the hidden reason why school sucks, but isn't going to disappear despite being literally centuries old technology. Classrooms create accountability, and accountability can manufacture the energy and focus to get through subjects you otherwise would not have. AI may replace teachers, but it won't replace classrooms.

What happens when you combine Erlang-style concurrency + @ScyllaDB's Seastar speed + @TigerBeetleDB deterministic simulation? Meet Tina: A strictly bounded, fault-tolerant, thread-per-core concurrency framework. 🧵👇

To understand what "good teaching" looks like you must understand the common failure modes of education, such as when designing a course or writing a textbook. I've spent years making hard subjects (like zero knowledge proof cryptography) accessible to engineers. Here's what I've learned are the common antipatterns in education: 1. Difficulty Spikes Video games keep users hooked by ramping up the difficulty very carefully, or at least giving you a strong warning that the difficulty will increase rapidly. Difficulty is part of learning of course, but unexpected difficulty is demotivating. If the teacher doesn't have a good mental model of what the student will find easy or hard, then the learning material will have difficulty spikes. Consider the psychological impact behind this. If I tell you "tomorrow you will have a bad day because of XYZ reasons" then when you actually experience XYZ, it won't be as bad as if it caught you by surprise. Experienced professors will warn students "this homework is harder than normal" but the better solution is to break up the homework into more manageable pieces. 2. Dangling Facts When teaching a subject, a lot of educators fall into the antipattern of "we need to teach this theorem/algorithm/proof because every other textbook teaches it." This tends to create "dangling facts." Facts need to be connected to be memorable. Teaching a student information that will never be used later diverts precious energy from impactful facts they need to put effort into internalizing. Example: most number theory/cryptography courses teach the euclidean algorithm to compute multiplicative inverses. The ZK book treats it as a black box. Multiplicative inverses are intuitive even if you rely on a library to compute them for you. So we spare the reader the effort of understanding the euclidean algorithm and focus on just using multiplicative inverses. The gap can always be revisited later with no harm to later knowledge. 3. Unmotivated Facts Related to the above, if a teacher cannot reasonably answer "why are we learning this" then that teacher isn't good. Motivation is one of the biggest factors in student success. Therefore, the course must be designed around what the student finds motivating as opposed to just telling the student to "trust me, tough it out." Now, I need to make a distinction here. When teaching children, they may not have the wherewithal to understand why they need to remember word spelling or memorize multiplication tables. So my comment has more to do with adult learning. 4. Asking for Generalization Too Early A lot of math textbooks make this mistake. They show a theorem and ask the reader to prove it. Unless the proof is trivial, this is the wrong move. Rather, they should test that the student actually understood the theorem and some first-order implications of it. 5. Underweight visual modality Now that frontier LLMs make creating visual diagrams/animations cheap, there's no excuse to not lead with visuals where possible. A good visual should not just be a sequence that says the same things text says. It needs to convey information in a way that words cannot do efficiently. 6. Bad prerequisite model If you spend time reminding readers how polynomial arithmetic works, but expect them to randomly recall some more advanced theorem from linear algebra, you have a bad prerequisite model which will cause a massive difficulty spike. Anyone who remembers the rank-nullity theorem or kernel-subspace duality probably remembers what roots of a polynomial are, but vice versa is not necessarily true. A good teacher cannot teach a student as a blank slate, but rather must have an update-able prior about what the student is already comfortable with and what they aren't. This model needs to actually reflect the actual distribution of real students.

I just published a new deep-dive article on the physical laws of queues and backpressure. How the Latency Death Spiral actually works, and why unbounded queues are a bug. [Read: Why Queues Don't Fix Overload (And What To Do Instead) →] pmbanugo.me/blog/why-queue…

As Fred Hebert famously wrote: "Queues don’t fix overload." They only absorb variance. If you want a system to survive sustained overload, you cannot "just queue".

@0xgodspower This is an amazing tool, man. I can also see how useful it can be as a tool for teaching.

Introducing mathbuilder.xyz, A tool that allows you compute anything. Think of how programming languages work. You are not restricted to a certain type of program rather you are given the building blocks to build whatever you want. That's the goal for mathbuilder.xyz. A turing-complete math platform that gives you the building blocks to calculate, experiment and build deep computational flows. This is the first of many demos. Try it out and join me on this journey as I build the best math and computation platform.

RareSkills makes what's supposed to be a hard subject a lot easier to understand and apply immediately 🎀🥂

It took me a few weeks, but I did it 🔥 All the 739 exercises in Rust from @RareCodeAI are finished. I currently learn how to code, and Rust is my first programming language. And RareCode helps me a lot to start my coding journey. More here: kairos-musubi.com/posts/why-im-l…