OOP Fundamentals: Encapsulation, Abstraction, Inheritance, Polymorphism

Introducing Serena: An MCP Toolkit for AI Coding Agents 🚀 Instead of fragile text operations, Serena provides: • Symbol-level code retrieval across entire codebases • Intelligent cross-file renames & refactoring • Support for 40+ programming languages • Integration with Claude Code, Codex, and more • Problem solved: Agents can perform complex refactoring in one atomic operation vs. 8-12 error-prone steps • Real-world impact: Makes AI agents work faster and more reliably on complex codebases Built with: Python, LSP (Language Server Protocol), Model Context Protocol (MCP) https://lnkd.in/gzF9_UrB

Day 8/30 – Polymorphism and Alien Dictionary Day 8 of the challenge focused on learning one of the most important OOP principles and solving a graph problem based on topological sorting. Today’s learning showed how the same concept can behave differently in programming, and how ordering dependencies appear even in language-based problems. MERN / OOP Concepts – Polymorphism Today I learned about Polymorphism, one of the core pillars of Object-Oriented Programming. What is Polymorphism: • Polymorphism means “many forms” • The same method or interface can behave differently depending on the object Types of Polymorphism: Compile-Time Polymorphism (Method Overloading): • Same method name with different parameters • Decided during compilation Run-Time Polymorphism (Method Overriding): • Child class provides its own implementation of parent class method • Decided during runtime Why it matters: • Improves flexibility and code reusability • Helps write scalable and maintainable applications • Makes code easier to extend in future Real-world understanding: • A payment method can behave differently for UPI, Card, or Net Banking while using the same pay() method Key takeaway: • Same action, different behavior depending on context DSA – Alien Dictionary Today I solved Alien Dictionary, a problem based on graph creation and topological sorting. Approach: • Compare adjacent words from the dictionary • Find first differing character between two words • Create a directed edge representing character order • Build graph using adjacency list • Apply Topological Sort (Kahn’s Algorithm) • Result gives valid character ordering Key insight: • Characters are nodes • Ordering rules between characters become directed edges • Topological sort helps find dependency order Why this problem is interesting: • Converts string comparison into graph logic • Shows how graphs can appear in unexpected places Time Complexity: O(N × L + K + E) (N = words, L = average word length, K = unique characters) Space Complexity: O(K + E) Takeaways • Polymorphism makes code dynamic and extensible • OOP concepts become clearer with real-world examples • Many non-graph problems can be transformed into graph problems • Topological sort continues to be a very useful pattern Day 8 completed. Learning both software design and problem-solving patterns side by side. #30DaysChallenge #OOP #Polymorphism #Java #DSA #Graphs #TopologicalSort #Consistency #LearningInPublic

If you use AI coding assistants like Claude Code or Cursor, you may have noticed how quickly token usage scales when the AI scans an entire codebase for context. To solve this, take a look at code-review-graph. It’s an open-source tool that builds a local, structural knowledge graph of your code using Tree-sitter and SQLite. Instead of reading every file, the AI queries the graph to understand the exact "blast radius" of a change, including callers, dependencies, and test coverage. The Results: Efficiency: Aims for an 8.2x average reduction in tokens during code reviews. Speed: Incremental graph updates process in under 2 seconds. Compatibility: Auto-configures via MCP for Claude Code, Cursor, Windsurf, Zed, and others. Flexibility: Supports 19+ programming languages. If you're looking to optimize context windows and reduce token burn in your engineering workflows, this repository is worth exploring. 🔗 Repository: https://lnkd.in/dS4HzMYX

AI coding agents burn most of their context window just navigating your codebase. I built a tool that fixes this. Every time an agent needs to understand a function, it takes 5-6 tool calls of grep and read loops. It has no dependency awareness, no memory of project structure, and rediscovers your architecture from scratch every session. I built codesight to solve this. It's a Go CLI that uses tree-sitter to parse your code (Go, TypeScript, Python, C#, Rust, Java, JavaScript) and generates a .codesight/ folder of structured Markdown files that serve as a knowledge layer between your code and AI agents. WHAT IT GENERATES Each package gets its own MD file with extracted API surfaces (full function signatures with file:line references), type definitions with fields and methods, a bidirectional dependency graph (imports + imported-by), and linked test files. On top of that, it generates PRD-style feature specs with requirement checklists derived from actual code, and a symbol-level changelog that tracks what changed between syncs. BENCHMARKS (1,943-file .NET monorepo) "How does Login work?" went from 41K chars across 6 calls to 3K chars in 2 calls (92% reduction) "All auth endpoints?" went from 84K+ chars and 10+ calls to 3K chars in 1 call Reverse dependency queries ("what calls this?") are instant. With grep they're effectively impossible. Search latency: 0.37s vs 11.4s HOW SYNCING WORKS codesight hashes file contents and only regenerates MDs for packages with actual changes. Each MD has two zones: tree-sitter owns the top half (API surface, types, deps) and regenerates it on sync. The bottom half (architecture notes, usage examples, gotchas) is preserved across syncs, so nothing written by an agent or human gets overwritten. CLAUDE CODE INTEGRATION "codesight init" wires up SessionStart and PostToolUse hooks in .claude/settings.json. The agent gets project status on every session start and the vault auto-syncs after every git commit. It also generates a skill file so the agent knows how to use search, task, and status commands out of the box. The core idea: agents don't need to read raw source files to reason about your system. They need package-level abstractions with enough detail to trace dependencies and understand boundaries, without drowning in implementation. That's the level tree-sitter lets you extract reliably. Open source. https://lnkd.in/dSG9FU6V #OpenSource #DeveloperTools #AI #ClaudeCode

“I know how to code… until OOP walks in and humbles you.” 😄 That’s exactly what happened when I started learning Encapsulation. Initially, I thought: 👉 “Encapsulation = making variables private to prevent misuse.” But it’s much deeper. --- 💡 What changed Earlier: user.balance += 500 Now: user.deposit(500) 👉 Same result, but better design. Encapsulation is about: - Controlling access - Enforcing business rules - Designing clear interfaces --- 🔍 Game changer: "@property" @property def total_price(self): return sum(item.price for item in self.items) 👉 Looks like data, but runs logic 👉 Can evolve (tax, discounts) without breaking APIs --- 🧠 Key insight Encapsulation enables: - Low coupling - High cohesion - Safe refactoring It’s not about restricting access, it’s about: «Guiding correct usage through design» --- 🔥 Takeaway I thought I knew coding. Turns out, I was just writing instructions… not designing systems. Still learning, still improving 🚀 #SoftwareEngineering #Python #OOP #Encapsulation #BackendDevelopment #SystemDesign #CleanCode #Programming #Developers #Tech #LearningInPublic

mini-claw-code I rebuilt the core idea behind Claude Code in 68 lines of Python. It's a while loop. LLM receives input, calls tools, gets results, loops until done. 2 tools: bash and todowrite. 3 prompt files. That's it. The interesting part isn't the code. It's the context engineering. Tool descriptions aren't just API docs -- they're behavioral instructions in disguise. They tell the model WHEN to use a tool, WHEN NOT to, and HOW to think about it. Even the todowrite return message is a nudge to keep the model on track. 3 levers: 1. System prompt = who the agent is 2. Tool descriptions = how it behaves 3. Tool results = real-time context that the agent builds as it works This is just the idea. The real Claude Code is thousands of engineering hours: sandboxing, permissions, streaming, caching, LSP, IDE integrations, and countless edge cases. Massive respect to the Anthropic team. But if you want to understand the concept, 68 lines is enough. Repo: https://lnkd.in/gxBxH2dN #ClaudeCode #ContextEngineering #AI #AgenticLoop

We got Gemma 4 E2B coding at 97% accuracy on a 29-task programming benchmark. Running locally on an M1 Max. No API calls. No cloud. No cost per query. Full report: https://lnkd.in/eDAAr-Yi The journey started at 0%. Not because Gemma can't code -- it turns out the model already knew the algorithms. It wrote correct comments about recursive descent parsers and then returned `return 0` as a placeholder. The problem was infrastructure: broken CLI flag parsing, a 4K default context window (on a 131K model), a Node.js v25 breaking change, and a streaming API that silently ignored the reasoning_effort parameter. Fix the plumbing, add algorithmic hints (not solutions -- just "use greedy subtraction for Roman numerals"), feed test results back to the model, and suddenly a 27B parameter model running on your laptop is implementing merge sort, topological sort, dynamic programming, graph traversal, and matrix multiplication correctly. Every time. What 97% accuracy on local inference actually means: This isn't a party trick. A local coding model that reliably implements standard algorithms opens real workflows: • Automation scripts -- ETL pipelines, file processors, data transformers. The kind of code that's 80% boilerplate and 20% domain logic. Gemma handles the 80% without sending your proprietary data to anyone's API. • Prototype-to-production -- Spin up working implementations of data structures, search algorithms, graph algorithms. Test locally, iterate fast, no rate limits. • Offline development -- Planes, trains, restricted networks. Your coding assistant doesn't need WiFi. • Privacy-sensitive codebases -- Healthcare, finance, defense. Code that can't leave your machine now has an AI pair programmer that never phones home. • Content generation pipelines -- Build the automation that builds your content. Scrapers, formatters, analyzers, publishers -- all generated and tested locally. • Education and research -- Students and researchers get a capable coding assistant without subscription costs. Run experiments on model behavior without API billing anxiety. What it can't do (yet): Recursive descent parsers with 6 precedence levels. Regex engines from scratch. Complex multi-constraint problems where 5 rules must be satisfied simultaneously. These require 70B+ models or cloud inference. The boundary is clear and measurable -- which is the whole point of running a benchmark. The real finding: The gap between local and cloud AI coding is not a capability gap -- it's an infrastructure gap. Four one-line bug fixes accounted for more improvement than all the prompt engineering combined. The model was always capable. We just had to stop breaking its environment. 29 tasks. 8 categories. 160+ automated tests. 4 runs. All open source. COD repo: https://lnkd.in/ebmh7SS5 Benchmark: /benchmark/challenge_v3.md #LocalAI #Gemma #OpenSource #CodingBenchmark #AIEngineering #LMStudio #OnDevice

Been using the graphify skill to build knowledge graphs in Claude Code for a few weeks, and I’ve hit on the perfect verb for interacting with knowledge graphs: “Strumming.” A graph isn't just a database you query. It’s a stringed instrument; you pluck a node, the connected nodes hum. You play a chord (a few nodes together) and you listen for what resonates. Iterative melody and harmony creation. And you can incorporate those melodies and harmonies into the graph itself. A graph is USEFUL (as opposed to just, uh, “COOL”) because you’re continually tuning it, session after session. A graph is an instrument that evolves, that’s always been tuned to ring true when you strike it. Graphify isn't just for coding. It's for... anything? And Claude Code is worth it, even if this were all you could do with it. Link to repo below. https://lnkd.in/eVaqqbyp

Your AI code reviews are burning tokens they don't need to. Every time Claude reviews your code, it re-reads the entire codebase. 200 files. 150,000 tokens. For a change that touched 8 files. That's not smart. That's expensive. code-review-graph fixes this. It's an open-source tool that builds a persistent, incremental knowledge graph of your codebase using Tree-sitter and SQLite. Instead of dumping your entire repo into Claude's context, it sends only the changed files plus every file impacted by those changes. The result? 5 to 10x fewer tokens per code review. Before: 200 files scanned, ~150k tokens used. After: 8 changed + 12 impacted files, ~25k tokens used. Here's what makes it practical for real engineering teams: Works natively with Claude Code via MCP (Model Context Protocol). No extra setup, no new workflow to learn. Increments intelligently. After the first build (~10s for 500 files), subsequent updates take under 2 seconds. Only re-parses what changed. Understands blast radius. It traces dependency chains so Claude knows not just what changed, but what else that change could break. Supports 12+ languages out of the box: Python, TypeScript, JavaScript, Go, Rust, Java, C#, Kotlin, Swift, Ruby, PHP, and C/C++. Needs no external database. SQLite is all it takes. The architecture is clean: Tree-sitter parses your code into an AST, a SQLite + NetworkX graph stores the relationships, git diff drives incremental updates, and 8 MCP tools expose everything to Claude Code. Three review workflows ship with it: /code-review-graph:build-graph /code-review-graph:review-delta /code-review-graph:review-pr Whether you're a junior engineer just getting into AI-assisted development or a senior architect thinking about LLM cost optimization at scale, this tool addresses a real problem: context window efficiency. AI code review should be precise. Not brute-force. Check it out: https://lnkd.in/giHvG8pR #AIEngineering #ClaudeCode #LLM #TokenOptimization #CodeReview #OpenSource #DeveloperTools #SoftwareEngineering #MCP #GenAI