Resolving Circular Imports and Performance Drops in Django

I wrote a JSONc formatter in Rust. It's basically just a clone of "fracturedJSON". JSONc is a variant of JSON that is commonly used for config files. It supports comments and trailing commas, unlike standard JSON. Anyhoo, my formatter renders this JSONc in a human-friendly way rather than what you'd see out of jq or python -m json.tool.

built a billing system from scratch to better understand how they work under the hood 🛠️ the hardest part wasn't writing the code, it was handling edge cases. if someone double-clicks "Pay," a poorly designed system charges them twice. i solved that using idempotency keys: duplicate requests return the same result, so customers are only charged once. What’s inside: - Atomic transactions: subscription and invoice are created together, or neither is saved. - State machine logic: invalid status changes are blocked (canceled subscriptions can’t be reactivated accidentally). - Idempotent payments: repeated requests don’t create duplicate charges. - Redis queue: payments are accepted instantly and processed asynchronously in the background. Learned more building this system than from most tutorials. github: https://lnkd.in/eKNz_6VE #backend #python #systemdesign

Day 34/90 Why does a related_name conflict matter? It is more than just a naming error; it is a system-wide blocker. Leaving these conflicts unresolved halts migrations and stops reverse lookups from working, which essentially freezes development. Resolving them was the only way to unblock my API logic and keep the database clean for handling the complex, nested data I'm building now. Backend EdTech Project: •Database Integrity: Resolved critical model-level bugs by fixing related_name conflicts in the Material model and aligning the Teacher status default with single-character choice keys. •Query Optimization: Implemented select_related('teacher') for nested actions to eliminate N+1 query patterns, handling complex table joins in a single SQL execution. •Specialized Serializers: Built minimal serializer variants to strictly follow the API documentation, ensuring the system only exposes required institutional data without leaking personal info. I spent a lot of time today fixing small things—like a status default that didn't match its key or a naming conflict that blocked my migrations. It’s not the "exciting" part of coding, but I’m realizing that matching the database exactly to the documentation is the most important part of the job. When you're building out relationships like these, do you lean on the database to enforce constraints via UniqueConstraint? #python #django #backend #drf #90daysofcode #sql #refactoring #coding

I built a RAG layer for Claude Code that cuts token usage by 80–90%                            Most devs using Claude Code don't realize they're burning tokens on files Claude doesn't need to read.                                                Ask Claude "how does auth work?" and it reads 3 full files — 1,500+ tokens just to answer with 40 relevant lines. I fixed that. What I built: A local hybrid RAG system that sits between Claude and your codebase:  → Late chunking — splits every file into overlapping 40-line windows  → Dense retrieval — semantic search with all-MiniLM-L6-v2 (runs fully local, no API key)  → BM25 sparse retrieval — keyword matching for exact symbol names  → Cross-encoder reranking — picks the 3 best chunks from 20 candidates  → File watcher — auto-rebuilds the index within 2 seconds of any file save Claude Code reads the CLAUDE.md and knows: run pip package before opening any file. It gets back 3 precise snippets with file path + line range. It reads only those lines. Nothing else. Real numbers on my Volta Engine project (76 files):  - Without RAG: 17,235 chars across 3 files for one question  - With RAG: 3,073 chars the exact 3 chunks that matter  - 82% fewer tokens. Same answer. The whole thing runs offline. No cloud embeddings. No API calls. Just a one time pip install and run it. Stack: sentence-transformers · rank-bm25 · watchdog · Python If you use Claude Code daily on a real codebase, this pays for itself in the first session. DM me if you want the scripts. 🧠  #AI #ClaudeCode #RAG #DeveloperTools #Python #LLM #Productivity

𝗗𝗮𝘆 𝟲𝟲/𝟳𝟱 | 𝗟𝗲𝗲𝘁𝗖𝗼𝗱𝗲 𝟳𝟱 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: 714. Best Time to Buy and Sell Stock with Transaction Fee 𝗗𝗶𝗳𝗳𝗶𝗰𝘂𝗹𝘁𝘆: Medium 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗦𝘂𝗺𝗺𝗮𝗿𝘆: Given an array prices where prices[i] represents the stock price on day i, and a transaction fee, find the maximum profit you can achieve. Constraints: • You can make multiple transactions • You must sell before buying again • Each transaction incurs a fixed fee 𝗠𝘆 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: This problem is solved using Dynamic Programming with state optimization. Instead of maintaining a full DP table, we track two states: • buy → Maximum profit when holding a stock • sell → Maximum profit when not holding a stock • Initialization: – buy = -∞ (we haven’t bought yet) – sell = 0 • Transition for each price: – buy = max(buy, sell - price) (Either keep holding or buy today) – sell = max(sell, buy + price - fee) (Either keep not holding or sell today after paying fee) • Final answer: sell This works because at every step, we decide whether to take an action (buy/sell) or skip, while always keeping track of the best possible profit. 𝗖𝗼𝗺𝗽𝗹𝗲𝘅𝗶𝘁𝘆 𝗔𝗻𝗮𝗹𝘆𝘀𝗶𝘀: • Time Complexity: O(n) • Space Complexity: O(1) 𝗞𝗲𝘆 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆: Stock problems often reduce to state machines. Tracking “holding” vs “not holding” states and optimizing transitions can simplify even complex trading constraints like transaction fees. 𝗤𝘂𝗲𝘀𝘁𝗶𝗼𝗻 𝗟𝗶𝗻𝗸: https://lnkd.in/gz6hgkXw #Day66of75 #LeetCode75 #DSA #Java #Python #DynamicProgramming #Greedy #MachineLearning #DataScience #ML #DataAnalyst #LearningInPublic #TechJourney #LeetCode

🚀 DAY 105/150 — NAVIGATING FILE SYSTEM LOGS! 📂🧭 Day 105 of my 150 Days DSA Challenge in Java and today I solved a problem based on stack simulation and directory navigation 💻🧠 📌 Problem Solved: Crawler Log Folder 📌 LeetCode: #1598 📌 Difficulty: Easy 🔹 Problem Insight The task is to determine the minimum number of operations needed to go back to the main folder after performing a series of folder operations. 👉 Operations include: • "../" → move to parent folder • "./" → stay in current folder • "x/" → move into a child folder 🔹 Approach Used I used a Stack-based simulation (or counter optimization): ✅ Stack Approach: • Push folder names when moving into a directory • Pop when encountering "../" • Ignore "./" ✅ Optimized Approach (Counter): • Maintain a variable depth • "x/" → depth++ • "../" → depth-- (only if > 0) • "./" → ignore ✔️ Final depth = minimum steps to return ⏱ Complexity Time Complexity: O(n) Space Complexity: • Stack → O(n) • Optimized → O(1) 🧠 What I Learned • Simulation problems can often be optimized using simple counters • Stack helps visualize hierarchy (like folders) • Edge case: cannot go above root directory 💡 Key Takeaway This problem taught me: How to simulate file system operations How to optimize stack-based solutions Importance of handling boundary conditions 🌱 Learning Insight Now I’m getting better at: 👉 Identifying when to use stack vs simple variables 👉 Writing clean and efficient logic 🚀 ✅ Day 105 completed 🚀 45 days to go 🔗 Java Solution on GitHub: 👉 https://lnkd.in/eadhHjNW 💡 Simplify the process, and the solution becomes obvious. #DSAChallenge #Java #LeetCode #Stack #Simulation #DataStructures #150DaysOfCode #ProblemSolving #CodingJourney #InterviewPrep #LearningInPublic

🌳 Today I tackled a Binary Search Tree challenge — implementing a Level-Order Traversal (BFS) in Java. Honestly? At first it looked like just "organizing data in a tree shape." But digging deeper made me realize how far this concept actually goes: 🗺️ Google Maps uses BFS to find the shortest path between two points 🤝 LinkedIn's "People you may know" explores connections level by level 📡 Internet routers use BFS-like logic to send data packets across networks 🎮 Game AI uses it for enemy pathfinding The solution itself uses a Queue (FIFO) to process nodes row by row — enqueue the root, poll a node, print it, enqueue its children, repeat until empty. The biggest takeaway? These fundamentals look simple on the surface but the rabbit hole goes deep. Every "basic" algorithm is powering something you use every day without knowing it. Keep grinding. The code is just giving names to things that already exist around us. 🚀 #Java #DataStructures #BFS #BinarySearchTree #CodingChallenge #100DaysOfCode #SoftwareEngineering #ClaudeAI #AI #Anthropic

Mastered the HTTP Request-Response Cycle & Methods! 🐍 Moving deeper into my Python Backend journey, I’ve realized that a great API isn't just about the code—it’s about how it communicates. Today, I took a deep dive into HTTP (HyperText Transfer Protocol), the backbone of every interaction on the internet. Here is what I explored today: 🔄 The Request-Response Cycle: Learned how a Client (Browser) and Server (Backend) talk to each other. Understanding that every request I send from the frontend needs a structured response from my FastAPI server. 🛠️ The "Big Four" HTTP Methods: GET: Fetching data safely (The "Read" operation). POST: Sending new data to the server (The "Create" operation). PUT: Replacing or updating existing data (The "Update" operation). DELETE: Removing data from the system (The "Delete" operation). 🚦 Status Codes & Headers: Started identifying the "secret language" of servers—from the successful 200 OK to the dreaded 404 Not Found and 500 Internal Server Error. This knowledge is the bridge between my local Python scripts and the global web. I'm now ready to start building RESTful APIs that can handle real-world traffic! #Python #WebDevelopment #HTTP #BackendDeveloper #CodingJourney #FastAPI #SoftwareEngineering #RESTAPI #TechCommunity #ContinuousLearning

I spent a weekend building a tool I actually needed : A PDF-to-Flashcard pipeline that runs 100% locally. The Win: No subscriptions, no data exposure, and zero latency. Just Python and local intelligence. The Stack: → PyMuPDF : Clean text extraction → Ollama to run Llama 3 locally:: High-performance local LLM. → Streamlit for the interface (and Sithara Hayavadana — the standalone local UI is genuinely great for this kind of project) → Pandas: Instant Anki-compatible CSV exports. The Biggest Learning: Data preparation beats model size every time. I found that chunking strategy mattered more than prompt engineering or model choice. The stack is entirely free — and yes, Keming Wang, free and open source tools were enough to buIld this 😁 I have shared the full article and technical breakdown in the comments below! 👇 Have you experimented with Ollama for your local workflows yet?

Your Claude Code token bill drops 36% the day you stop dumping your repo into context. Your agent's token usage drops 27x on the same task. Same model. Different retrieval. Here's what's broken right now. Your README is from six months ago. Your architecture doc predates the rewrite. Your agent quotes both like they're scripture and burns tokens doing it. Repowise(https://lnkd.in/gxjrWD8T) scores every doc by confidence. Every git diff updates the score. When a function changes, the docs that referenced it get flagged before your agent ever reads them. Four layers feed retrieval. Git history. Code graph. Versioned docs. Decision records. Your agent pulls from the layer that matches the code you shipped yesterday, with a confidence number attached. Stale wiki page from 2024 scores low. Decision record from last week scores high. Your agent picks accordingly. Seven MCP tools. Self-hosted. Code never leaves your machine. Works with Claude Code, Cursor, any MCP client. pip install repowise Python 3.11+ v0.3.0 AGPL-3.0 Benchmarks run against naive full-repo context on Claude Code. 36% cheaper. 27x more token efficient. Numbers in the repo.