Understanding Code Through Direct Experience

🔍 In a recent MIT experiment, three student teams were asked to write software code in Fortran, a programming language none of them knew. The results were pretty interesting: 🥇 The team using ChatGPT finished the fastest 🥈 The team using a specific AI coding assistant (Code Llama) came in second 🥉 The team using just Google search finished last, breaking down the task into components and solving it the old-fashioned way. However, when tested on their ability to recall the solutions from memory, the situation was reversed. The ChatGPT team remembered nothing and failed, while half of the Code Llama team passed, and every student in the Google Search team succeeded. 📚 This experiment underscores a crucial educational lesson: hard work, sweat, and some measure of frustration are essential for learning. Spoon-fed solutions don't stick, and it is the process itself of struggling through problems where the value is. 🤖 As AI coding tools become more available, the demand for developers who can effectively use these tools will grow. But it's clear that solid computer science skills are essential before you can make good use of AI. You will have to learn these the old-fashioned way. 💡 The conclusion from this experiment is simple: there is no substitute for hard work 😊 Don't just rely on AI tools; learn to code, crash, debug, and repeat. Your coding future depends on it. Jason Gulya

My younger self would hate how I code now. Here's why that's a good thing. During a conversation couple of days ago, a friend asked me "If you had to build an in-memory cache, how would you do it?" I thought I knew the answer. After all, I'd been coding for years. But as I started designing it on paper, something unexpected happened. I realized how much my approach had changed over time. 8 years ago, I would've jumped straight into coding a complex system. Today? I took a step back and asked myself: 𝟭. 𝗖𝗮𝗻 𝘄𝗲 𝘂𝘀𝗲 𝗥𝗲𝗱𝗶𝘀 𝗼𝗿 𝗺𝗲𝗺𝗰𝗮𝗰𝗵𝗲 𝗶𝗻𝘀𝘁𝗲𝗮𝗱? • Younger me would've scoffed. "Build it yourself!" he'd say. How hard could it be? • But experience taught me: use off-the-shelf when possible. 𝟮. 𝗪𝗵𝗮𝘁'𝘀 𝘁𝗵𝗲 𝗯𝗮𝗿𝗲 𝗺𝗶𝗻𝗶𝗺𝘂𝗺 𝘄𝗲 𝗻𝗲𝗲𝗱? • I used to love adding features.  • Now I know: Reliability trumps bells and whistles every time. 𝟯. 𝗛𝗼𝘄 𝗳𝗮𝘀𝘁 𝗰𝗮𝗻 𝘄𝗲 𝗴𝗲𝘁 𝘁𝗵𝗶𝘀 𝘁𝗼 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻? • In the past, I'd spend weeks perfecting before deploying.  • Now I aim for MVP and learn from real usage. 𝟰. 𝗖𝗮𝗻 𝘄𝗲 𝘂𝘀𝗲 𝗮 𝘀𝗶𝗺𝗽𝗹𝗲 𝗮𝗿𝗿𝗮𝘆 𝗶𝗻𝘀𝘁𝗲𝗮𝗱 𝗼𝗳 𝗮 𝗳𝗮𝗻𝗰𝘆 𝗱𝗮𝘁𝗮 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲? • Complexity used to excite me.  • Now it scares me. Simple often outperforms complex in the real world. 𝟱. 𝗦𝗵𝗼𝘂𝗹𝗱 𝘄𝗲 𝗮𝗹𝗹𝗼𝗰𝗮𝘁𝗲 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀 𝘂𝗽𝗳𝗿𝗼𝗻𝘁? • I once thought dynamic allocation was always better.  • Experience showed me: failing fast saves night calls. 𝟲. 𝗪𝗵𝗲𝗿𝗲 𝗰𝗮𝗻 𝘄𝗲 𝘀𝗲𝘁 𝗵𝗮𝗿𝗱 𝗹𝗶𝗺𝗶𝘁𝘀? • "The sky's the limit!" was my motto.  • Now I know limits prevent surprises (and outages). 𝟳. 𝗛𝗼𝘄 𝗰𝗮𝗻 𝘄𝗲 𝗺𝗮𝗸𝗲 𝘁𝗵𝗶𝘀 𝗲𝗮𝘀𝘆 𝘁𝗼 𝘁𝗲𝘀𝘁? • Testing was an afterthought.  • Now it's built into the design from day one. 𝟴. 𝗪𝗵𝗮𝘁 𝘀𝗵𝗼𝘂𝗹𝗱 𝘄𝗲 𝗺𝗲𝗮𝘀𝘂𝗿𝗲? • I used to fly blind.  • Now I embed performance counters everywhere. These practices aren't just theory. They're battle-scars from countless projects, sleepless nights, and hard-learned lessons. And they've transformed how I approach every coding challenge. The result? Cleaner code. Fewer bugs. Happier teammates. Better sleep. That's the power of experience-driven engineering. It's not about knowing more. It's about knowing what matters. 𝙋.𝙎. 𝙒𝙝𝙞𝙘𝙝 𝙤𝙛 𝙩𝙝𝙚𝙨𝙚 𝙧𝙚𝙨𝙤𝙣𝙖𝙩𝙚𝙨 𝙢𝙤𝙨𝙩 𝙬𝙞𝙩𝙝 𝙮𝙤𝙪𝙧 𝙟𝙤𝙪𝙧𝙣𝙚𝙮? 𝘿𝙧𝙤𝙥 𝙖 𝙣𝙪𝙢𝙗𝙚𝙧 𝙞𝙣 𝙩𝙝𝙚 𝙘𝙤𝙢𝙢𝙚𝙣𝙩𝙨! #founderstory #lessons #developer #founder #startup #growthhacks

If you are a distributed systems engineer intimidated by the inference ecosystem, I feel your pain. When I started, terms like attention, KV cache, pre-fill, decode, tensor parallelism, and speculative decoding were scary. You can only learn so much about swimming by reading; sometimes, you just gotta jump in the pool. The inflection point for me was using Claude Code to set up vLLM on an EC2 g6.xlarge instance and simply routing requests to it. This allowed me to get a working system that I could poke at. I added LMCache, tried SGLang, ran benchmarks, noticed some missing pieces, wrote them up, and kept asking questions along the way. Within a week, I had developed the vocabulary required to navigate this foreign landscape. Meanwhile, the deeper I got into this, the more I recognized the patterns I had observed my entire career: routing, scheduling, utilization, sizing, cache pressure, and network tuning all affect the inference performance just as they do distributed system performance. So if you feel worried, go launch a G6.xl instance, install claude code (or codex on it), and get going with your inference journey. At about $0.80/hour, it might be the best career investment you can make. Once you get into it, it becomes addictive. A few nights go by, and the unfamiliar vocabulary becomes part of your mindset. Try it today. And poke me if you want help. It's surprisingly familiar, you'll see.

Reading a tutorial and terms like exponential backoff, jitter, and idempotency keys makes sense. Then you build the thing, the API returns a 500, and you watch your system crash. The happy path is the part everyone writes about. The request succeeds, the response looks like the example, and the system behaves. That is maybe 20% of the actual code you end up shipping. The other 80% is what you only discover by running the thing under real conditions. A queue that is supposed to be FIFO but is not under load, a dependency that is "always available" until it is not, or a database connection pool that gets exhausted when 3 slow queries stack up during a deploy. Hence, reading 10 blog posts about a system is no substitute for spending a weekend building it. The bugs you hit while building it (or, better yet, while running it in production) are the actual curriculum. The blog post is just the syllabus. Reading teaches the happy path. Building teaches the failure modes. So keep coding and keep shipping. Hope this helps.

Today, I witnessed my team lead interviewing a Full-Stack Web Developer with 2 years of experience, and I observed some interesting insights. The interview started with basic technical questions, which the candidate answered well. Then, my team lead gave him a coding task: 👉 "Write a function that removes duplicate values from a nested array while preserving its structure (PHP)." The candidate struggled and couldn’t solve it. So, my lead gave him another task: 👉 "Write a function that groups an array of associative arrays based on a specific key." Again, he couldn’t solve it. At this point, he admitted: "I don’t always have syntax and logic rules memorized, as I usually rely on resources like Stack Overflow and ChatGPT. Could you assign me a real-world task instead?" Here,I decided to step in. Since I was working on WooCommerce project, I gave him this challenge: 💡 "Implement a functionality where a logged-in user gets a 15% discount if they place two orders in a single day." We allowed him to use Google, ChatGPT, or any other resources. To our surprise, within 1.5 hour, he understood WooCommerce functionality, analyzed the existing code, and successfully implemented the feature. ✨ We ended up hiring him! ✨ Key Takeaway Many traditional interview techniques overemphasize logical puzzles and syntax-heavy questions, yet modern developers approach problem-solving differently. Rather than memorizing solutions, they adapt, learn, and implement on the spot using the tools and resources available to them. 💡 Instead of testing how well candidates remember syntax, we should focus on how effectively they apply problem-solving skills to practical challenges. What’s your take on this? Let’s discuss in the comments! 👇 #HiringTechTalent #TechCommunity #WhatDoYouThink

One of my fairly embarrassing intern memories involves very confidently telling my manager that I knew how to use print statements when asked if I knew how to debug. My manager smiled kindly and proceeded to teach me how to use breakpoints. I think she was looking for a more sophisticated answer than print statements. IDEs today offer many ways to debug your applications, but before I walk you through those, you might wonder why you should look past print statements. They seem to serve the purpose pretty well. Say you're debugging. Like we all do, you sprinkle a bunch of print statements in your app. You let it do its thing, but it takes so much time, and while the relevant variables are being printed to the console, you're questioning their values. customer_name shouldn't equal None. It should equal 'ABC.' You find yourself adding increasingly more print statements. If only there were a way to inspect variable values without the hassle of print statements. Well, there is! Let me walk you through them: 1. Breakpoints In general, breakpoints in an IDE allow you to stop the code at specific lines to inspect values, monitor the flow, and understand the current state. Conditional breakpoints only stop execution if certain criteria are met, allowing you to narrow down specific scenarios without manually filtering them out. For instance, you could set a conditional breakpoint in a loop to stop only when x exceeds 100. With Exception Breakpoints, you can tell your IDE to automatically pause execution whenever a specified type of exception is thrown, allowing you to inspect the state of the code. 2. Step Controls: Step Into, Step Over, Step Out One of the most powerful ways to debug complex functions is by walking through your code line-by-line, using Step Controls: Step Over: Runs the current line of code and moves to the next without diving into method calls. This is ideal when you don't need to see the internals of a called function. Step Into: Enters the function being called, allowing you to explore its workings. Perfect for when you're curious about what's happening within a specific method or want to trace the logic step-by-step. Step Out: Completes the current function's execution and returns to the calling function, which is useful for exiting deeper code and resuming inspection at a higher level. 3. Watches Print statements can tell you a variable's value at a specific time, but watches in an IDE offer real-time, ongoing monitoring of variables as your code executes, showing you changes dynamically at each step. Reading through all these options might feel overwhelming (this isn't an exhaustive list, btw), but you're just a YouTube search away from taking your debugging abilities to the next level. Learn how to debug - it's worth the investment. ---------- Looking for mentorship? Check out my profile or message me directly to discuss how I can help you reach your goals. #softwareengineering #careers

From Code to Context: Rethinking How We Train in Tech? At CodeNova, a growing tech consulting firm, they recently onboarded a talented group of junior software engineers.💡 Bright minds. 🔍 Eager learners. During their onboarding bootcamp, they were introduced to our core deployment architecture — a robust microservices setup with automated CI/CD pipelines. Within a few days, they had nailed the process: ☑️ Cloning repositories ☑️ Configuring YAML files ☑️ Running container builds ☑️ Deploying to staging and production with precision 🕺 It was like watching choreography. They had memorized every step — quickly and confidently. But just two weeks into a live client project, their DevOps team made a strategic shift: 🔄 Adopted a new orchestration tool and moved to a container-less deployment for scalability. ⚠️ Suddenly, the steps they had memorized didn’t apply anymore. That’s when the real learning began. While some engineers felt 😵 disoriented and stuck, others stepped up — not by asking “What’s the new process?” but by asking: 🧠 “Why did we change it?” ⚙️ “How does this system behave differently?” They weren’t just executing; they were reasoning. They weren’t just deploying code; they were understanding infrastructure logic. They had internalized the concepts — not just the procedures. And that made all the difference. 💥 🔍 The distinction here is subtle but powerful: ➡️ When you memorize steps, you’re efficient — until the context changes. ➡️ When you understand concepts, you’re adaptable — regardless of how the system evolves. In fast-paced tech environments, the steps are always subject to change. 🛠️ New tools. 📜 New protocols. 🧱 New platforms. Sometimes, even new languages. What stays timeless? ✨ The foundational understanding of how systems work, why we use certain patterns, and what principles guide decision-making. 👩💻 As a Learning Experience Designer, this experience was a wake-up call — not for the learners, but for the learning and people team. They realized training shouldn’t end with: 'Did they remember the steps?' But instead ask: 'Can they recreate the process from scratch, if needed?' That’s the mark of conceptual clarity. 💡We don’t just want developers who can follow workflows. We want engineers who can design new ones when the old ones break. 🔁 If you’re designing capability programs in the tech world, 👉 don’t just aim for compliance. Design for creative resilience. 🎯 #microlearning #learningwithhiral #learningeveryday #LearningExperienceDesign #TechLearning #CapabilityBuilding #AgileLearning #ConceptOverSteps #WorkplaceLearning #EngineeringExcellence #LXD #FutureSkills

🕵️♂️ Debugging: The Crucial Skill We Often Forget to Teach Beginners 🐛 I want to talk about a vital skill that's often overlooked when teaching programming: debugging. As an author and educator, I've seen firsthand how critical this skill is for new developers. As a professional developer working on a team, I've also experienced how strong debugging skills can make a huge difference in both productivity and the overall quality of our codebase. It's become a personal mission of mine to ensure that beginners not only learn to code, but also learn to effectively troubleshoot their code. Here's something interesting: When we were writing "Head First C#", we realized there was a significant gap in how debugging is taught. So, we created a feature called "Sleuth it Out" - essentially turning bug-hunting into a detective game. I want to tell you, developing these scenarios was incredibly rewarding, and it really ignited my passion for making debugging both fun and approachable for newcomers. Here's the detective-like approach I developed for "Sleuth it Out" sections: • Observe the Unexpected 👀 When your code misbehaves, don't panic. Take a step back and clearly define what's going wrong. • Gather Clues 🔍 Examine your code closely. What assumptions did you make? Where could things go off track? • Form a Hypothesis 🤔 Based on your clues, what do you think is causing the issue? •Test Your Theory 🧪 Make small, targeted changes to confirm your suspicion. • Solve the Case! 🎉 Once you've found the culprit, implement a fix and verify it works. We jump in starting at the very beginning of the book. In the first chapter's "Sleuth it Out" scenario, readers debug a matching game project. The game was ending prematurely because it counted blank squares as matches. By "playing detective," readers track down the issue to a single line of code that wasn't checking if a button was already cleared. This approach not only fixes bugs but helps new programmers understand their code better. It turns debugging from an intimidating chore into an engaging puzzle! I'm really curious to hear your thoughts on this. Does this "Sleuth it Out" approach resonate with you? How do you think we can better teach debugging to new programmers? Your insights could help shape how we approach this crucial skill in the future. #CSharp #Debugging #SoftwareDevelopment #ProblemSolving #DotNET #CodeQuality #TechEducation #ProgrammingSkills O'Reilly

𝗜’𝘃𝗲 𝘁𝗿𝗮𝗶𝗻𝗲𝗱 𝟱𝟬+ 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 — 𝗮𝗻𝗱 𝘁𝗵𝗲𝘆 𝗮𝗹𝗹 𝗺𝗮𝗸𝗲 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝗺𝗶𝘀𝘁𝗮𝗸𝗲. They reread notes. Rewatch tutorials. But rarely 𝘁𝗲𝘀𝘁 what they actually understand. That’s the biggest trap in learning — confusing 𝗳𝗮𝗺𝗶𝗹𝗶𝗮𝗿𝗶𝘁𝘆 with 𝗺𝗮𝘀𝘁𝗲𝗿𝘆. When I was learning my first programming language, I did the same thing — endless repetition, zero retention. Until I discovered Richard Feynman’s principle: “If you can’t explain it simply, you don’t understand it well enough.” That line changed how I learn — and how I teach. Now I use five proven methods that turn learning into a system: 𝗧𝗵𝗲 𝗙𝗲𝘆𝗻𝗺𝗮𝗻 𝗧𝗲𝗰𝗵𝗻𝗶𝗾𝘂𝗲 — simplify until it’s crystal clear. 𝗔𝗰𝘁𝗶𝘃𝗲 𝗥𝗲𝗰𝗮𝗹𝗹 — test yourself, don’t just reread. 𝗧𝗵𝗲 𝗟𝗲𝗶𝘁𝗻𝗲𝗿 𝗦𝘆𝘀𝘁𝗲𝗺 — repeat less, remember more. 𝗔𝗜 𝗣𝗿𝗼𝗺𝗽𝘁𝘀 — use AI to explain, quiz, and summarize. 𝗧𝗵𝗲 𝗛𝗮𝗿𝘃𝗮𝗿𝗱 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 — spaced repetition, self-testing, and feedback loops. And most importantly — 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲 𝗶𝗺𝗺𝗲𝗱𝗶𝗮𝘁𝗲𝗹𝘆. Real understanding doesn’t happen in your head. It happens in action. Since then, I’ve learned faster — and helped others do the same. Because smart learning isn’t about IQ. It’s about 𝗶𝘁𝗲𝗿𝗮𝘁𝗶𝗼𝗻 𝗮𝗻𝗱 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲. 💬 What’s one learning habit you’d change if you could start over? — Natan Mohart