I built my own Parser + evaluator in Rust (from scratch) in 3 days. Features: - Lexer with identifiers, keywords, numbers, operators, comments, and line/column spans - Pratt parser with correct precedence and right-associative exponent - Statements: let, assignment, expression-stmt, blocks - Built-in functions: sin, cos, tan, sqrt, pow, log, exp, abs - Variables with lexical scopes, shadowing, and mutability - Pretty AST printer - REPL and unit tests, to see everything is working fine Example: > 2 ^ 3 ^ 2 512 > let x = 10 10 > x * 5 + sqrt(25) 55 This project taught me parsing theory, Rust’s borrow checker at scale, and error handling like a real compiler. Here's the github repo, please give a like as well: github.com/Abhisheklearn12/p…

Hot Take: Nothing in computing is truly asynchronous at the hardware and instruction level. Everything is synchronous, until a runtime fakes it. People talk about async like it's a magical property of the universe. But at the lowest level, every system is ultimately synchronous. -CPUs appear to execute instructions in order (even though they reorder internally) -Syscalls block unless the OS schedules around them -Hardware is event-driven but still bound by clocks -“Async” functions don’t run in parallel, the runtime schedules them So what’s actually happening? Async is an illusion built by runtimes: -JavaScript: event loop + callback/microtask queue -Rust: executor + waker + poll-based futures -Python: event loop + coroutines -Go: scheduler multiplexing goroutines over OS threads -OS kernels: interrupts + preemptive scheduling Under the hood, it’s all synchronous execution broken into chunks and interleaved by a scheduler. -Async ≠ “parallel” -Async ≠ “multithreaded” -Async = “scheduled synchronous steps that look concurrent” The runtime just decides when your synchronous fragments run. In summary: Every system is synchronous at its core. Async is a runtime abstraction that slices sync operations into interleaved steps that feel concurrent. It's the core concept of Asynchronous. I am always open to feedbacks, because through your feedback I get to know a lot.

The best book I’ve found to truly understand concurrency. The concepts apply to Rust, Go, or any modern concurrent system, literally. I’m reading it right now and it’s literally changing how I think about parallelism.

I need to write more js/ts with python this month I guess.

The less time we waste on our phone, the more your brain starts to actually live. Focus sharpens, energy returns, and you start to see real growth I guess. The more we feel happy as well.

>First principle thinking >Fuck around Find out >Experimentation mindset that's all you need

Sorry guys, I might just write a small post on this. This topic looks so simplified from the outside that most people completely think about it the wrong way. But the truth is, it’s insanely deep once you actually start looking at how it works under the hood with assembly code and opcodes. I’m currently diving into it line by line, registers, memory, how the CPU actually moves data, and computes and it’s mind-blowing. It’s the kind of thing that looks “basic” in C, but when you open the (.S) file and see what the compiler really generates, it hits different. I’ll write a detailed blog about this soon with real examples, actual assembly snippets, and full explanations of what’s really happening behind that one “simple” C statement. This is fucking deep, and honestly, it changes how you see code forever. Thanks for your time.

Sorry guys, I might just write a small post on this. This topic looks so simplified from the outside that most people completely think about it the wrong way. But the truth is, it’s insanely deep once you actually start looking at how it works under the hood with assembly code and opcodes. I’m currently diving into it line by line, registers, memory, how the CPU actually moves data, and computes and it’s mind-blowing. It’s the kind of thing that looks “basic” in C, but when you open the (.S)file and see what the compiler really generates, it hits different. I’ll write a detailed blog about this soon, with real examples, actual assembly snippets, and full explanations of what’s really happening behind that one “simple” C statement. This is fucking deep, and honestly, it changes how you see code forever.

Remember this line always and put it into your brain: This is the most fundamental truth about how a CPU actually executes instructions. Every single instruction your CPU executes ultimately does two things: -Move data between registers and memory, -then computation/processing happens using data inside registers. All actual computation/processing happens inside the CPU, in the ALU (Arithmetic Logic Unit), using registers. After that, results are written back to registers, and finally to memory if needed. That’s the entire essence of how a computer “thinks", literally, it is. Everything else like C, Rust, Python, javascript, frameworks or anything, is just abstraction on top of this.

it's a 4 days old video, I was just experimenting with blender

Blender compilation is some huge time consuming lolll.., but its fun, hahaha..

Whatever you learn means nothing if you don’t apply it. Until you experiment, build, reason it and play with what you’ve learned, you’re just memorizing, not learning.

>In 2015, people flexed cars. >In 2025, they flex GPUs. Welcome to the hardware era.

Honestly, the more I spend time learning and building, the more I drift away from social media. I’ve started enjoying the process so much that I barely post or engage anymore. I just love learning, every bit of it. Sorry, that’s why I don’t post much, guyss 😅

“Our success at Amazon is a function of how many experiments we do per year, per month, per week, per day.” ― Jeff Bezos This quote is something, I truly believe in this, more than anythinggg. It has a very very deep meaning.

The future isn’t “Rust vs Python.” It’s “Rust inside Python.” Rust is literally making Python fast. what you think guysss.

After 4 months of trying, I finally learned something I’ve been chasing for so long. Today’s literally my best day ever. The grind was worth it. Will push even more and more 100%. don't ask what, because I believe in actions, action always speak louder than words.

Every time I build or learn something new, I understand more deeply how crucial fundamentals are. You can write software without them, but you can’t design or maintain mission-critical systems without strong foundations. In real engineering, we don’t just write code, we make decisions, it's fucking true. Why this approach? Why not another? What are the trade-offs in performance, reliability, cost, and maintainability? Engineering is about reasoning, not just syntax. That's what makes a real engineer. I build stuffs to learn thinking, because without the right fundamental thinking we can't build crazy things.

I literally fall in love with problem solving with programming and calisthenics as f**ck, this is peak dopamine for me.

Trying to implement my own Compressed Inverted Index in Rust. basically, this is the core data structure behind search engines like Google, Elasticsearch, or Lucene, it’s what lets them answer queries like “find all documents and index” in milliseconds. a normal inverted index maps each term → list of document IDs where it appears. but a compressed inverted index goes a step deeper: -It stores those posting lists in compressed form (using variable-byte encoding, bit-packing, etc). -That means less disk I/O, smaller memory footprint, faster lookups. -It’s like building your own mini search engine, but you need to think about posting formats, term dictionaries, delta encoding, seek offsets, and more. I’m implementing it all in pure Rust, it's a basic one, but I want to understand how this stuff actually works under the hood. just playing with bytes, file I/O, and compression formats to understand how real search engines work under the hood. It’s such a beautiful mix of: algorithms + systems + data compression this project is teaching me so much about how information retrieval systems are actually built from scratch.

True confidence doesn’t come from dreaming. It always comes from consistent, honest hard work (actions), focus, and belief. Not from over thinking, over planning, or just talking.