Correct Code Fails in Python due to Execution Context

2026 is the year of democratizing code. Before tools like Claude Code existed, you actually had to know how to program. But contrary to the name, Claude Code doesn't actually require you to be a "Coder". It just requires you to understand logic. If you can explain a process step-by-step to a human, you can ask it to build scripts and agents to do it for you. The bar isn't "can you write Python from scratch." anymore. I've been using this to run large parts of my business for the last month, and I can't believe how powerful it is. To get started, here's a free course from Anthropic on the basics: https://lnkd.in/guB-5Rgf I'll be posting more use cases throughout the year as this evolves.

🚀 LeetCode Daily Challenge – Day 8 Problem #1458: Max Dot Product of Two Subsequences (Hard) This was by far one of the hardest problems I’ve worked on so far in my daily streak. 🧭 How I Approached the Question: At first, the problem looks similar to classic subsequence DP questions, but the non-empty subsequence constraint makes it tricky — especially when all values can be negative. A greedy approach doesn’t work here, so I knew this had to be solved using Dynamic Programming. 🧠 Key Idea: Let dp[i][j] represent the maximum dot product using subsequences from: first i elements of nums1 first j elements of nums2 For each pair of indices, I had three choices: Take both elements and extend a previous subsequence Skip current element of nums1 Skip current element of nums2 The most important insight: 👉 When starting a new subsequence, we should not carry forward negative values, so we use max(0, dp[i-1][j-1]). This ensures: The subsequence is non-empty We always keep the best possible dot product 🛠️ Transition: Multiply the current elements Either start fresh or extend a previous valid subsequence Compare with skipping options ⏱ Time Complexity: O(n × m) 📦 Space Complexity: O(n × m) This problem really tested my: DP fundamentals Edge case handling Patience 😄 👉 A great reminder that “Hard” problems are hard for a reason — but breaking them down step by step makes them manageable. 📌 Consistent practice, even when the problem feels overwhelming. #LeetCode #DailyCoding #DynamicProgramming #HardProblem #DSA #ProblemSolving #Python #CodingJourney #LearningInPublic

🔧 Backend Project-2 : Flask Debugging & Refactoring As part of my learning journey, I worked on debugging and improving a Flask-based notes application where users can submit notes and view them instantly on the same page. While refactoring the code, I identified and resolved multiple backend issues: • The endpoint was restricted to only one HTTP method, leading to request failures • Form data was incorrectly accessed using query parameters instead of form data • The HTML form lacked proper action and method attributes • No validation was in place, allowing blank entries to be stored ✅ After addressing these problems, the application now functions reliably—users can submit notes through a clean interface, and the updated notes list renders immediately without errors. 🔍 Key Learnings from this Project: → Clear understanding of Flask routing and HTTP methods (GET vs POST) → Correct handling of form submissions in Flask → Dynamic page rendering using Jinja2 templates → Importance of validating input and writing maintainable backend logic Grateful to Innomatics Research Labs for the hands-on assignments and supportive learning environment that encourage real-world problem solving and clean coding practices 🚀 #Flask #Python #BackendDevelopment #Debugging #WebDevelopment #LearningByDoing #InnomaticsResearchLabs

I’ve just released a new open-source Python library: easy-rag-pdf. easy-rag-pdf is built on top of LangChain, with the goal of making PDF-based RAG and question-answering easy and practical without requiring users to wire together multiple LangChain components themselves. PyPI: https://lnkd.in/g2JiPPDb What it focuses on : - A simple, developer-friendly API - PDF → chunking → retrieval → answer workflow - Support for answers with source documents - Designed for stability, clarity, and real-world usage To install : >>> pip install easy-rag-pdf To import >>> from chat_pdf import load_pdf, ask_question GitHub (open for collaboration) https://lnkd.in/gp_776mm This project is intentionally kept simple and extensible. I’m happy to collaborate with developers interested in improving RAG workflows, adding local model support, or exploring practical document-AI use cases. Feedback, issues, and PRs are very welcome. #OpenSource #Python #LangChain #RAG #LLM #AIEngineering #DeveloperTools #easyrag #library #PythonLibrary #pip #chatpdf

From “command not found” to a fully working Jupyter project — in 3 hours. Today was one of those days that truly reminded me how real learning happens. I started from absolute scratch: Git Bash not installed properly Conda environment issues Jupyter not detecting the correct folder Environment conflicts (Python 3.12 vs Conda) ModuleNotFoundError, PATH issues, broken .pth files For nearly 3 hours, it felt like nothing was moving forward. Every fix revealed another issue. But step by step, I: Understood how Git Bash interacts with Windows paths Learned how Jupyter actually decides which folder and Python it uses Fixed environment conflicts the right way (not hacks) Successfully ran my data ingestion project inside Jupyter 🎉 ✅ Everything is now working end-to-end. Biggest takeaway (moral): Real learning doesn’t look like tutorials. It looks like confusion, debugging, frustration — and then clarity. Tools will break. Errors will look scary. But if you stay patient and debug systematically, you don’t just solve the problem — you level up. Feeling more confident today as a Data Engineering learner, because I didn’t give up when things got messy. #LearningByDoing #DataEngineering #Python #JupyterNotebook #GitBash #Conda #Debugging #GrowthMindset

A fundamental rule about building that I have learned over time: Always try to keep your code as small and simple as possible and this means paying for expensive and fancy APIs. Try to outsource as much code and functionality as possible. I realized this when trying to add YouTube videos as an option for the type of material a user could upload. Before using Supadata's transcript API, I tried to build a pipeline where my server would download the video, then use a speech to text API or I would use the standard Python youtube-transcript-api. A complete hassle and waste of time; I had to whip another server running python code for the Python youtube-transcript-api. At some point I realized I wasn’t actually building my product anymore — I was just fighting infrastructure and edge cases that had nothing to do with the core value I wanted to ship. I may or may not have opened 5 different account to get a key and wrote some code to switch out the key whenever I run out credits for one key.

🧠 LeetCode Insight — Minimum Window Substring Lately, I’ve been focusing on strengthening my core problem-solving fundamentals, especially patterns that show up repeatedly in real-world engineering problems. One such problem is Minimum Window Substring, which combines: sliding window frequency tracking and careful state management 💡 Core Logic The goal isn’t just to find a valid window — it’s to find the smallest valid window. To do that efficiently: Track required character counts using a frequency map Maintain a dynamic window over the string Expand the window to satisfy constraints Shrink it only when validity is preserved The balance between correctness and optimality is what makes this problem interesting. ✅ Python Implementation: https://lnkd.in/gN-93eB8 🧩 Why This Matters Problems like this test more than syntax — they test: how you manage state how you reason about constraints how you optimize without breaking correctness These are the same skills required when working on scalable backend systems and data pipelines. 🎯 Takeaway The biggest learning for me here was: Sliding window problems aren’t about moving pointers — they’re about knowing exactly when a condition becomes true and when it breaks. Getting that right is what leads to clean, reliable solutions. 👉 Curious how others reason about shrinking windows — what’s your mental model for this pattern? #Python #ProblemSolving #SlidingWindow #DataStructures #SoftwareEngineering #LeetCode #LearningInPublic

Day 25 of #100DaysOfCode: Mastering File Handling & Building the Mail Merge Project 📁✉️ Today I explored one of Python's most practical features - working with files, directories, and paths. From reading/writing files to understanding file systems, this was all about making Python interact with the real world! 📚 Learning Highlights: File Operations - Opening, reading, and writing files using the "with" keyword File Path Systems - Understanding relative vs absolute paths Data Persistence - Saving and retrieving data from external files File System Navigation - Working with directories and file structures 🎯 Project: Mail Merge Automation Built an automated letter generator that: → Reads names from an input file → Opens letter template with placeholder text → Replaces placeholders with actual names → Generates personalized letters for each recipient → Saves individual files automatically 🛠️ Technical Implementation: Enhanced the Snake Game with high score persistence Implemented file reading/writing with proper error handling Used the "with" keyword for safe file operations Practiced string manipulation for template replacement Mastered relative and absolute path navigation Created scalable solution for bulk file generation 💡 Key Takeaways: File handling opens up endless possibilities - from data persistence to automation. The Mail Merge project showed how a simple script can save hours of manual work by automating repetitive tasks. Understanding file paths and the "with" keyword ensures clean, safe, and efficient file operations. This is where programming becomes truly practical - solving real-world problems and automating tedious tasks! #Python #FileHandling #Automation #MailMerge #DataPersistence #CodingJourney #LearnInPublic #PythonProgramming #SoftwareDevelopment #100DaysOfCodeChallenge

🗓 Day 59 / 100 – #100DaysOfLeetCode 📌 Problem 961: N-Repeated Element in Size 2N Array Today’s problem focused on identifying a repeating pattern in an array with well-defined constraints. The task was to find the element that appears n times in an array of size 2n, where all other elements are unique. 🧠 My Approach: I used a set-based approach to track elements as I traversed the array: Iterated through each element in the array. Stored visited elements in a set. If an element was already present in the set, that meant it was the repeated element → returned it immediately. This works efficiently because the problem guarantees exactly one element is repeated n times. 💡 Why this works well: Sets provide O(1) average time complexity for lookup. The repeated element is guaranteed to appear early due to frequency, so we can exit early. Simple logic with clean and readable code. 💡 Key Learning: This problem reinforced: ✔ how problem constraints can simplify the solution ✔ effective use of hash-based data structures ✔ recognizing patterns instead of overcomplicating logic ✔ writing efficient solutions even for “easy” problems A great example of how understanding constraints leads to elegant solutions 🚀 #100DaysOfLeetCode #LeetCodeChallenge #Python #ProblemSolving #Arrays #HashSet #Simulation #Algorithms #DSA #CompetitiveProgramming #SoftwareEngineering #CodingJourney #DeveloperJourney #LearningInPublic #TechStudent #CareerGrowth #Programming #KeepLearning

🧠 LeetCode Insight — Total Fruit (Sliding Window with Constraints) I’ve been working on problems that involve maintaining constraints over a moving window — a pattern that shows up often in real systems. Problem: Given a row of fruit trees, collect the maximum number of fruits using only two baskets, where each basket can hold only one type of fruit. 🌍 Real-World Analogy Think of this like a service processing pipeline: You can handle only two types of requests at a time Requests keep coming in continuously Your goal is to process the longest uninterrupted sequence without exceeding capacity Once a third type appears, you must: release older requests adjust your window continue efficiently That’s exactly what this problem models. 💡 Core Logic Use a sliding window to track the current range Maintain a frequency map of fruit types in the window Expand the window while the constraint (≤ 2 types) holds Shrink from the left as soon as the constraint breaks ✅ Python Implementation: https://lnkd.in/gFPwnh9Y 🧩 Why This Works The window always represents a valid state Each element enters and exits the window once Constraints are enforced immediately when violated No unnecessary recomputation 🎯 Takeaway This problem reinforced an important idea for me: Sliding window problems are about enforcing constraints dynamically, not just expanding ranges. Once the constraint logic is clear, the solution becomes both clean and efficient. 👉 Where have you seen similar “limited capacity” constraints in real systems? #Python #SlidingWindow #ProblemSolving #DataStructures #LeetCode #SoftwareEngineering #LearningInPublic