Dominikus Nold’s Post

Have you ever been frustrated at the Pyright’s performance? I’ve been working on a long-term systems project: building a Python language server from scratch in Go. Over the past few weeks, I implemented the full frontend pipeline required for a real LSP, without relying on existing compiler frameworks. This includes a hand-written lexer with Python-style INDENT/DEDENT handling, a recursive-descent parser that produces a structured AST, and a complete semantic analysis layer. The semantic phase constructs lexical scopes from builtin → global → function, maintains explicit symbol tables with scope ownership, and resolves names using Python’s LEGB rules. It correctly handles parameters, defaults, shadowing, loops, and control flow, while modeling built-in functions like print and range as first-class symbols. Every identifier in a file can now be deterministically resolved, with accurate source spans suitable for editor tooling. The goal is to understand how language servers work under the hood and to build the core infrastructure needed for features like go-to-definition, hover, and diagnostics. This has been a deep dive into parsing theory, static analysis, and language tooling architecture, which has significantly sharpened my understanding of compilers, IDEs, and large-scale developer systems. If you’re interested in language tooling, compilers, or LSP internals, I’m happy to discuss! Feel free to check out the project at: https://lnkd.in/epB9CaVm

I shipped an open-source Python developer tool focused on code execution explainability. While debugging and building Python applications, I noticed how difficult it is to clearly trace runtime behavior—especially control flow and variable state changes. So I built explainflow: • Visualizes execution step by step • Tracks variable state transitions • Supports decorator-based and CLI workflows • Distributed via PyPI under the MIT license PyPI: https://lnkd.in/gC7Tszax GitHub: https://lnkd.in/gD8rXfHu Open to feedback and collaboration from Python developers. #Python #OpenSource #DeveloperTools #SoftwareEngineering #DevTools

🟧🟩🟨 (3/4) The Complete Guide to Python Virtual Environments! BY teclado (https://lnkd.in/g4ChGY85) Q: Why does flask.exe appear in the Scripts folder? A: Because Flask installs a command-line executable. Q: When can Python successfully import Flask? A: When the virtual environment is activated and its Python interpreter is used. Q: How often should you create virtual environments? A: Usually one per Python project. Q: Why should every project have its own virtual environment? A: Because most projects have dependencies that need isolation. Q: Why is tracking dependencies important? A: So others can install the same dependencies and run the project. Q: Why is dependency tracking useful long-term? A: It allows reinstalling dependencies later if needed. Q: What file is commonly used to track dependencies? A: requirements.txt. Q: Does the file have to be named requirements.txt? A: No, it is a convention, not a requirement. Q: What kind of dependencies go into requirements.txt? A: Libraries required to run the project. Q: What are examples of common web project dependencies? A: Flask, Requests, and Gunicorn. Q: How are development-only dependencies handled? A: They are listed in a separate file, commonly dev.requirements.txt. Q: Why separate development dependencies from runtime dependencies? A: Because they are not needed to run the application in production. Q: How do you install all dependencies from a requirements file? A: Activate the virtual environment and run pip install -r requirements.txt. Q: What happens if a dependency is already installed? A: Pip skips reinstalling it. Q: Why should exact library versions be recorded? A: Because newer versions may break existing code. Q: How do you specify an exact library version? A: Using == followed by the version number. Q: What does flask==1.0.0 mean? A: Only version 1.0.0 of Flask should be installed. Q: Why should dependency updates be deliberate? A: Because updates may require code changes. Q: Why should you avoid blindly updating all libraries? A: Because it can introduce breaking changes. Q: What is semantic versioning? A: A versioning system using major, minor, and patch numbers. Q: What does the major version represent? A: Breaking changes. Q: What do minor and patch versions usually represent? A: Backward-compatible improvements and fixes. Q: Why do developers often pin only the major version? A: To allow safe updates while avoiding breaking changes. Q: Why should you still verify library behavior after updates? A: Because not all libraries strictly follow semantic versioning. Q: How can you allow minor and patch updates but block major ones? A: By specifying version ranges using comparison operators. Q: What does flask>=1.0.2,<2.0 enforce? A: Any Flask version from 1.0.2 up to but not including 2.0.

Day 322: Making Python wait efficiently (Asyncio) ⚡ Synchronous vs. Asynchronous One of the hardest concepts to wrap my head around initially was asyncio. Standard Python code is like waiting in line for coffee: you order, you wait, you get coffee, then the next person orders. Asyncio is like ordering via an app. You place the order and sit down to do other work while the coffee is being made. For things like web scraping or calling multiple APIs (which I do a lot in Data Analysis), this effectively stops your program from freezing while waiting for a server response. import asyncio async def fetch_data(): print("Fetching data...") await asyncio.sleep(2) # Simulating an API call print("Data received!") asyncio.run(fetch_data()) Challenge: Try rewriting your web scraper with async and watch the execution time drop. 📉 #Python #Asyncio #Concurrency #DataEngineering #Coding

Top Python Libraries in 2025: General‑Use Tools That Raise the Bar Python’s general‑purpose tooling in 2025 shows a clear push toward speed, clarity, and production safety. A new wave of Rust‑powered tools like ty and complexipy focuses on making everyday development feedback fast enough to feel invisible, while grounding quality metrics in how humans actually read and understand code. The result is tooling that helps teams move faster without sacrificing maintainability. Developer productivity and correctness are a strong theme. ty rethinks Python type checking with fine‑grained incremental analysis and a “gradual guarantee” that makes typing easier to adopt at scale. Complexipy complements this by measuring cognitive complexity instead of abstract execution paths, helping teams identify code that’s genuinely hard to understand rather than just mathematically complex. Several tools address long‑standing infrastructure pain points. Throttled‑py modernizes rate limiting with multiple algorithms, async support, and strong performance characteristics, while Httptap makes HTTP performance debugging concrete with waterfall views that reveal where latency actually comes from. These libraries focus on observability and control where production systems usually hurt the most. Security, code health, and extensibility also get serious attention. FastAPI Guard consolidates common API security concerns into a single middleware, while Skylos tackles dead code and potential vulnerabilities with confidence scoring that respects Python’s dynamic nature. Modshim offers a powerful alternative to monkey‑patching, allowing teams to extend third‑party libraries cleanly without forking or global side effects. Finally, there’s a clear move toward better interfaces and specifications. Spec Kit reframes AI‑assisted coding around executable specs instead of vague prompts, while FastOpenAPI brings FastAPI‑style documentation and validation to multiple frameworks without forcing a rewrite. Together, these libraries show a Python ecosystem that’s maturing—not by adding more abstractions, but by making the fundamentals faster, safer, and easier to reason about. Read https://lnkd.in/dwUShkiZ #python #softwareengineering #developertools #productivity #opensource

Most developers ask the wrong question: “Python or TypeScript?” The real question is: How do I make good technology decisions without wasting months? In this article, I show how I used NotebookLM as a decision-making system, not a tutor — combining: • project context • time horizons • learning maps • consistency audits Result: Python for thinking, TypeScript for delivery. If you work on real projects (not toy examples), this approach changes everything. https://lnkd.in/dX4-yBuH

Hey folks 👋 Was getting a bit bored recently, so decided to build something that actually felt interesting and useful from an engineering point of view. I’ve been working on a small Python tool called FastAudit — it checks whether a Python app is actually production-ready before deployment. Things like: • DEBUG flags • settings misconfigurations • unsafe defaults • Python setup issues that usually show up at the worst time Right now it works in Django mode only, and it’s still very much a work in progress. I’m focusing on making the Django side solid first before extending it to other frameworks like FastAPI, flask, etc. Not trying to make it perfect — just building in public, learning a lot about Django internals, packaging, and real-world edge cases along the way. Will keep improving it, and later plan to cover other Python frameworks too. If you’ve faced similar “it works locally but breaks in prod” moments, you’ll know why this exists 🙂 More updates soon. #BuildingInPublic #Django #Python #BackendEngineering #SoftwareEngineering #DeveloperTools

Why I stopped using "For Loops" for everything in Python As a Python Developer, it’s easy to fall into the habit of writing standard loops. But as the codebase grows, efficiency and readability become the real game-changers. Lately, I’ve been focusing on writing more "Pythonic" code. Here are 3 things that significantly improved my workflow: List Comprehensions & Generators: Not just for shorter code, but for better memory management. The Power of functools & itertools: Stop reinventing the wheel. These built-in libraries handle complex iterations like a pro. Type Hinting: In large-scale applications, typing isn't optional—it’s a lifesaver for debugging and team collaboration. Writing code is easy. Writing efficient, maintainable, and scalable Python is the real craft. What’s one "hidden gem" in Python that changed the way you code? Let's discuss in the comments! 👇 #PythonDevelopment #BackendEngineering #CleanCode #Pythonic #SoftwareEngineering #Scalability

Your Python Code Doesn’t Just “Run” — It’s Orchestrated 🐍⚙️ If you’ve ever wondered why Python feels both slow and blazing fast—or how your script magically turns into machine instructions—you’re not alone. Most coders never peek under the hood. Let’s change that today. The diagram below breaks down the Python Functional Structure — the exact path from idea to execution: 📝 Code Editor → Where you write human-readable Python. 💾 Source File (.py) → Your saved script. 📚 Library → Pre-built modules your code calls. 🖥️ Machine Code → What the CPU actually executes. But here’s what happens invisibly ⚙️🔁: 1️⃣ Compilation: Your .py file is compiled into bytecode (.pyc). 2️⃣ Interpretation: Bytecode runs inside the Python Virtual Machine (PVM). 3️⃣ Execution: The PVM interacts with libraries — many of which are pre-compiled to machine code for speed (like NumPy, Pandas). This layered system is why Python is high-level yet powerful — it abstracts complexity while leveraging C-based libraries for performance. 💡 Pro Tip: Want to see the bytecode yourself? python import dis def hello():   print("Hello, LinkedIn!") dis.dis(hello) It’s a game-changer for debugging and optimization. 🚀 Key Takeaway: Understanding this flow helps you: Write more efficient code Debug like a pro Optimize knowing where bottlenecks live Python isn’t just a language — it’s a well-orchestrated system bridging human logic and machine execution. ✅ Like if you learned something new. 🔄 Share to help your network see the engine behind the code. 💬 Comment below: What’s one Python internal concept that changed how you code? Tag a developer who should see this. 👇 #Python #Programming #SoftwareEngineering #Developer #Coding #PythonProgramming #Tech #Bytecode #PythonVM #SoftwareDevelopment #CodeOptimization #LearnToCode #DeveloperTips #TechCommunity

Python is eating the world, but many developers are still writing it like it's 2015 I review a lot of Python code. And something keeps bugging me. Python 3.10+ shipped game-changing features. But production codebases are still stuck on patterns from a decade ago. 𝗪𝗵𝗮𝘁 𝗜 𝗸𝗲𝗲𝗽 𝘀𝗲𝗲𝗶𝗻𝗴: 👉🏽 Massive if-elif chains instead of match/case 👉🏽 Type hints missing or half-implemented 👉🏽 Plain classes instead of dataclasses with slots=True 👉🏽 No asyncio where IO dominates the runtime 👉🏽 Manual string formatting instead of f-strings with = debug syntax 𝗧𝗵𝗲 𝗴𝗮𝗽 𝗶𝘀 𝗿𝗲𝗮𝗹. Features like structural pattern matching, walrus operators, and proper type annotations exist to make code safer and more readable. But teams skip the upgrade because "the old way works." 𝗧𝗵𝗲 𝗰𝗼𝘀𝘁? Technical debt accumulates silently. New team members struggle with inconsistent patterns. Bugs hide in verbose conditional logic. Performance stays on the table. 𝗧𝗵𝗲 𝗳𝗶𝘅 𝗶𝘀 𝘀𝗶𝗺𝗽𝗹𝗲. Pick one modern feature. Refactor one module. Make it the new standard for PRs. Repeat. You don't need to rewrite everything. 𝘞𝘩𝘢𝘵'𝘴 𝘵𝘩𝘦 𝘰𝘭𝘥𝘦𝘴𝘵 𝘗𝘺𝘵𝘩𝘰𝘯 𝘱𝘢𝘵𝘵𝘦𝘳𝘯 𝘴𝘵𝘪𝘭𝘭 𝘭𝘶𝘳𝘬𝘪𝘯𝘨 𝘪𝘯 𝘺𝘰𝘶𝘳 𝘤𝘰𝘥𝘦𝘣𝘢𝘴𝘦? #python #ai #llm #coding