Revisiting Python Classes for Deeper Understanding

With all the AI FOMO right now, it feels like everyone is rushing to generate code rather than understand it. But if you still appreciate the "old style" of actually getting your hands dirty to learn the mechanics of a language—specifically Rust—the tutorial fatigue is real. Watching hours of videos just isn't the same as building something yourself. That's why I put together something for those of us who learn best by doing: Rust Learning Bytes. 🦀 Inspired by platforms like CodeCrafters and the awesome "Build your own X" repositories, I wanted to create a hands-on path to picking up Rust. Instead of just handing you the final code, each file in the repo includes helpful comments formatted like feature tickets. They give you just enough of a hint to nudge you toward the solution without ruining the "aha!" moment of figuring it out. 💻 You can jump into the repo and start building here: https://lnkd.in/eTuFxwzC If you get stuck or want a deeper dive into the "why" behind the code, I'm also writing a companion blog series called "Rust by Doing - Build your own X." I'll be posting walkthroughs for each section there. 📝 Check it out here: https://suhird.me/series I'd love to hear what you think. Let me know in the comments, or feel free to open a GitHub Issue or PR if you spot any mistakes or have ideas for new chapters I should add. Happy coding! 🚀 #Rust #RustLang #SoftwareEngineering #LearnByDoing #Programming #OpenSource

RefCell<T> in Rust: Flexibility with Safety (at Runtime) When learning Rust, one concept that feels a bit “strange” at first is `RefCell<T>` — but once it clicks, it becomes a powerful tool in your toolbox. So what is it? `RefCell<T>` is a smart pointer that enables interior mutability meaning you can mutate data even when it’s wrapped in an immutable structure. Normally, Rust enforces borrowing rules at compile time: * Either one mutable reference * Or many immutable references But `RefCell<T>` changes the game by enforcing these rules at **runtime instead**. Why does this matter? There are situations where Rust’s strict compile-time checks are too limiting, especially when: * You’re working with shared ownership (like `Rc<T>`) * You know your code is safe, but the compiler can’t prove it That’s where `RefCell<T>` comes in. How it works Instead of `&` and `&mut`, you use: * `.borrow()` → immutable borrow * `.borrow_mut()` → mutable borrow If you violate the borrowing rules, your program will **panic at runtime** instead of failing to compile. Simple Example ```rust use std::cell::RefCell; fn main() { let value = RefCell::new(5); *value.borrow_mut() += 10; println!("{}", value.borrow()); } ``` When to use it When you need mutable access inside immutable structures * When combining with `Rc<T>` for shared, mutable state * In scenarios like graph structures, caches, or test mocks But be careful ⚠️ `RefCell<T>` shifts safety checks from compile-time to runtime. That means: * More flexibility ✅ * But potential runtime panics ❌ So use it only when necessary, not as a shortcut. In short: `RefCell<T>` gives you controlled flexibility bending Rust’s rules *without breaking them. As you go deeper into Rust, understanding when (and when not) to use it is a key step toward writing clean, idiomatic code. #Rust #SoftwareEngineering #RustLang #LearningInPublic #Programming

What does running 21km have to do with debugging code? Everything. 🏃♂️💨 I recently completed a half-marathon, and during those final few kilometers, I realized that distance running and Software Engineering require the exact same mental muscle: — The ability to stay focused when things get uncomfortable. --> The 5km mark: Everything is exciting (Like starting a new Python project). --> The 15km mark: The "Wall." Your legs hurt, and the logic gets fuzzy (Like hitting a bug that won't resolve). --> The Finish Line: It’s not about how fast you went; it’s about the fact that you didn't stop. In IT, just like in a half-marathon, consistency beats intensity every time. I’m carrying this "endurance mindset" into my A-Level exam prep and my future in tech. #HalfMarathon #Discipline #TechMindset #Persistence #StudentAthlete

𝗘𝗣𝗗. 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴. 𝗣𝗿𝗼𝗱𝘂𝗰𝘁. 𝗗𝗲𝘀𝗶𝗴𝗻. Most people have heard it. Very few understand how it actually works. Saturday's session opened with one question "𝗪𝗵𝗮𝘁 𝗲𝘃𝗲𝗻 𝗶𝘀 𝗮 𝗽𝗿𝗼𝗱𝘂𝗰𝘁?", and the answers in the room told a different story than what any classroom ever taught us. We talked about the gap between college projects and real industry work. The difference isn't just the tech stack. It's the mindset, the ownership, the chaos. Then we broke down the EPD model, how Engineering, Product, and Design actually work together, and why knowing only one side limits you more than you think. We wrapped with Python basics because every big idea still starts with the fundamentals. If you missed it, this is the kind of session that reframes how you think about what you're building and why. Join us for more such amazing sessions!

Today I learned that not all loops are the same and it actually blew my mind.I'm not going to lie. I thought a loop was just a loop.Turns out, there's a whole world in there. Here's what I uncovered today: 🔹 for loop → when you already know how many times you need to repeat something. Clean, predictable, in control. 🔹 while loop → when you don't know how many times, you just keep going until a condition is met. A little unpredictable just like real life. 🔹 while True → runs forever until YOU decide to stop it. At first it scared me. Then I realized how powerful that actually is. 🔹 Nested loops → a loop inside a loop. Each one exists for a reason. Choosing the right loop isn't just about making code work it's about making it make sense. That's the part nobody tells you when you start coding. It's not just logic. It's judgment. Still a beginner. Still figuring it out. But days like today remind me why I started. #Python #Loops #LearningToCode #CodingJourney #PythonProgramming #GrowthMindset #TechCommunity

Markdown is quietly becoming the primary programming language of our time. It’s not about syntax or compilers anymore. It’s about what actually gets used by both humans and AI agents. I'm seeing developers spending more time writing (and debugging) Markdown than traditional code. Skills, context files, prompts, specs, and documentation are often the things devs actually change to ship features and improve AI behavior. It feels like the next programming language isn’t another fancy syntax. It’s the one we already know how to write. #Markdown #AI #Developer #FutureOfCoding

🚀 Learning Rust with Opencode I'm excited to share my journey of learning Rust using Opencode AI assistant! Here's what I built: What I Learned ✅ Variables, data types, functions   ✅ Ownership & Borrowing - Rust's core memory safety model   ✅ Structs, Enums, Option & Result   ✅ Traits & Generics   ✅ Collections (Vec, HashMap)   ✅ Closures & Iterators   ✅ Testing with #test   ✅ Modules & error handling Project Built A CLI Todo application with: - Add/Delete/List tasks - Mark complete/incomplete - JSON persistence using serde - Full test coverage How Opencode Helped - Step-by-step explanations with code examples - Interactive Q&A to test understanding - Helped debug issues in real-time - Guided through project structure The best part? Learning by doing. I wrote code, got feedback, and built something functional while understanding why Rust works the way it does. If you're starting your Rust journey, I'd highly recommend: 1. The Rust Book (official docs) 2. Build small projects early 3. Don't skip ownership & borrowing concepts Special thanks to Opencode for making this learning journey smooth and interactive! #RustLang #Learning #Programming #Opencode

Check out Runcorder: (https://lnkd.in/gRgxPbXP) For years of working full time, my family and my hobbies were in line for a slice of my time. Now, the wait is over — I spend much more time with both, and it's been very rewarding! I'm still passionate about coding, though. I (we?) work on side projects, and today I'm starting to publish them. First up is Runcoder (https://lnkd.in/gRgxPbXP) — a continuation of the theme of "invisible" intelligent tools that lean on existing knowledge and skills to improve the efficiency of a developer's work. Runcoder is a lightweight "flight recorder" for your Python projects. It reduces the need for logging and observability instrumentation and makes debugging your scripts and jobs faster. It's lightweight and non-intrusive, so it can be always on. Give it a try and let me know what you think! (do not forget to star the repo https://lnkd.in/gRgxPbXP)

After several days of building, debugging, and refining, I successfully structured and shipped a reproducible Machine Learning project setup using UV + Git 🥰 I simply wanted to build a clean and scalable foundation for ML workflows following my recent class on Git and GitHub Workflow. What I implemented: • Initialized a structured Python ML project using UV • Managed dependencies with uv.lock for reproducibility • Set up a clean virtual environment workflow • Organized project structure for real-world ML development • Integrated Git for proper version control • Successfully pushed the complete workflow to GitHub This is not just setup, it is a production-style ML foundation that ensures consistency, reproducibility, and scalability across environments. What I learned: • How modern Python tooling (UV) simplifies dependency management • Why reproducible environments matter in ML engineering • The importance of clean project architecture before model building • How Git integrates into real ML workflows This is the foundation I will continue building on as I move into full machine learning projects. Mentorship for Acceleration 🔗 GitHub Repository: https://lnkd.in/eqRmyY5p #MachineLearning #Python #DataScience #Git #MLEngineering #UV #BuildInPublic