Python Async Programming Book Review by Nicolas Bohorquez

Over the past few weeks, Carter Davis and I have been developing a tool that analyzes changes in Python code at the AST level. The project reads modified Python files, parses them with Tree-sitter, builds abstract syntax trees, and compares the old and new versions to detect structural similarities and differences in the code. Rather than only showing line-by-line changes, the tool currently identifies when functions have been added, deleted, or moved, making it easier to understand the overall structure of what changed in the code. To make the results easier to understand, we built a human readable summary layer that explains what changed in plain language, such as: - Added function “test” on line 4 - Added function “yFunction” on line 11 - Deleted function “anotherFunction” from line 17 - Function “ILikeMath” moved from line 13 to line 15 Throughout this project I gained a much stronger understanding of Docker and how to package and run applications in a consistent environment. I also learned more about GitHub Actions, where we created an automated workflow that compares the current version of Python files against the previous commit whenever new code is pushed. I also gained experience working with ASTs, parsing libraries, and designing algorithms to compare code semantically rather than just textually. We worked in an agile style environment, holding daily scrums and weekly reviews to discuss progress, challenges, and next steps. This project gave me a much better understanding of software engineering workflows, code analysis, and collaborative development. You can check out the project here: https://lnkd.in/gw5f_ipb

If you have ever tried to test a Python class and realized the test required spinning up a real database, you have already felt tight coupling — even if you did not have a name for it. Tight coupling happens when one class creates another inside its own constructor. That one design choice locks the two classes together, blocks substitution in tests, and causes changes to ripple across the codebase in ways that are hard to trace. The core fix is a single constructor change: accept the dependency as a parameter instead of building it internally. From there, typing.Protocol lets you depend on a contract rather than a concrete class, so any object with the right methods can be passed in without inheritance. The tight coupling tutorial on PythonCodeCrack covers every major form tight coupling takes in Python: hard-wired constructors, inheritance used as a shortcut for code reuse, global state that hides dependencies, and temporal coupling — the kind where two method calls must happen in a specific order but nothing in the interface communicates that. It also covers where loose coupling goes too far, when tight coupling is the correct choice, and how to refactor existing coupled code incrementally without breaking call sites. Complete the final exam to earn a certificate of completion — shareable with your network, current employer, or prospective employers as proof of your continuing Python programming education. https://lnkd.in/gq98uPPm #Python #SoftwareDesign #DependencyInjection

I just experienced a great reminder in why it is essential to practice and apply what you studied, not just absorb and take notes. It is that effort that makes you aware of what you didn't understand correctly and/or fully, so you can work through it, and truly become competent in the skill. During the short Python intro course I mentioned in my prior post earlier today, I noticed that the While / For Loop syntax in Python did not have neat and tidy "close loop" equivalent keywords that exist in Visual Basic for Loop logic there. I was wondering how that would impact real world code execution. And I found out quickly when I ran into difficulty getting my solution to work correctly for a simple Python exercise I found on YouTube (ref: "Programming with Mosh" video: https://lnkd.in/eXRfTZQj), where the challenge is to write a Python routine that only prints the even numbers between 1 and 10, and then at the end, print a statement that contains the count of how many of those numbers were even. Through having to research beyond what the short course I had just taken covered about Python Loop syntax, I discovered that Python is VERY sensitive to the indentation level of code that you place after your Loop code. Namely, to ensure code that you want to execute only after the Loop is exited, you must fully indent that code all the way to the left of the screen. Fascinating. Once I did that, the code I wrote worked exactly like what the exercise challenge intended with no errors. And I learned something critical about making code work in Python that follows Loop logic code.

loops in Python can be closed with the "else" keyword to show other programmers logic that is written with dependency on a loop body completing count=0 for I in range(1, 10): if I % 2 == 0: print(I) count+=1 else: print("We have",count,"even numbers") on termux python Python 3.12.12 (main, Jan 22 2026, 23:09:36) [Clang 21.0.0 (https://lnkd.in/gpRE8Azb 5e96669f0 on linux Type "help", "copyright", "credits" or "license" for more information. >>> count=0 >>> for I in range(1, 10): ... if I % 2 == 0: ... print(I) ... count+=1 ... else: ... print("We have",count,"even numbers") ... 2 4 6 8 We have 4 even numbers >>> exit()

🚀 Leveling Up My Python Skills with Advanced OOP Concepts Recently, I explored an insightful blog on mastering advanced Object-Oriented Programming (OOP) in Python and it completely changed how I think about writing clean, scalable code. Here are a few key takeaways from my learning journey: 🔹 Descriptors: The hidden engine behind Python magic I learned that features like @property, @staticmethod, and even methods themselves are powered by the descriptor protocol (__get__, __set__, __delete__). This mechanism allows Python to control attribute access in a very powerful and reusable way. (Calmops) 🔹 Metaclasses: Classes that create classes Metaclasses act as blueprints for classes, just like classes are blueprints for objects. Understanding that every class in Python is an instance of type really shifted my perspective on how Python works internally. (GeeksforGeeks) 🔹 Metaprogramming & real-world impact: These concepts are not just theoretical. They power frameworks like Django and SQLAlchemy. They enable dynamic behavior, validation, and cleaner abstractions at scale. (Calmops) 🔹 Polymorphism & clean design Revisiting polymorphism reminded me how important it is for writing flexible and reusable code where one interface can handle multiple object types seamlessly. (Howik) 💡 Big realization: Advanced Python OOP is less about writing classes and more about understanding how Python itself works under the hood. This learning pushed me from just using Python to actually understanding Python. 📚 Next, I’m planning to dive deeper into: Decorators Context managers Async programming If you're learning Python, I highly recommend exploring these advanced concepts. It’s a game changer. #Python #OOP #SoftwareEngineering #LearningJourney #Programming #Developers #PythonLearning

Most beginners use Python.   Very few understand what’s happening behind the scenes. Day 12 — Constructors in Python Today’s focus: controlling how objects are created. Progress in one line:   I stopped treating classes like templates… and started thinking like a system designer. Here’s what clicked: • `__init__` isn’t just setup — it defines how your object enters the system   • Clean constructors = predictable objects = fewer bugs later   • Passing the right parameters early saves hours of patchwork later The confusion? At first, constructors felt like “extra syntax” I had to write. The breakthrough? They’re actually your first layer of control — where structure meets logic. That shift changes how you design everything. Now I’m thinking:   “What should this object always have when it’s created?” That’s a different level of thinking. Showing up daily, building with intent — not just running code, but designing it. If you’ve worked with classes before: What’s one mistake you made with constructors early on? Comment “PYTHON” and I’ll share my notes + examples. --- X Post: Most people misuse Python constructors. `__init__` isn’t just setup — it’s control. If your objects are messy, your constructors are weak. Fix that → cleaner code instantly. #Python

🚀 I’m currently strengthening my skills in Python development, focusing on building a solid foundation in logic and clean coding practices 🐍 As part of this process, I’ve been working on: 🔹 Designing functions to solve specific problems in a structured way 🔹 Using lambda functions to simplify simple operations and write more concise code 🔹 Implementing logic to analyze and validate strings, such as detecting palindromes One of the most interesting exercises was building a function that checks whether a word is a palindrome by comparing characters from both ends toward the center: def is_palindrome(text): left = 0 right = len(text) - 1 while right >= left: if not (text[left].lower() == text[right].lower()): return False left += 1 right -= 1 return True print(is_palindrome("Racecar")) # True This type of exercise has helped me strengthen key skills such as: ✔️ Logical thinking ✔️ Index handling and control flow ✔️ Writing clean and efficient code I’ve also been applying lambda functions for simple operations in a more concise way: square = lambda x: x ** 2 print(square(2)) # 4 Understanding lambda functions has been a bit challenging, especially when deciding when to use them versus traditional functions. I’m still working on building that intuition. If you have experience with lambda functions, I’d really appreciate your insights #Python #SoftwareDevelopment #Programming #Code #ContinuousLearning

🐍 If you can’t handle files in Python, you’re missing real-world skills. Most tutorials focus on theory… But real projects? They read and write files constantly. Here’s what you actually need: 🔹 open() Open a file → First step to any file operation 🔹 read() Read file content → Extract data for processing 🔹 write() Write to a file → Overwrites existing content 🔹 append ("a") Add to a file → Keeps existing data, adds new lines 🔹 close() Close the file → Prevents memory leaks 🔹 with (best practice) Auto-manages files → No need to manually close 💡 Pro insight: Most beginners forget this: 👉 "r" = read 👉 "w" = overwrite 👉 "a" = append 👉 "r+" = read + write And one more thing… 👉 Always prefer with open() It’s cleaner, safer, and production-ready. 🎯 Want to build real Python skills? Start here: 💻 Python Automation 🔗 https://lnkd.in/dyJ4mYs9 📊 Data + Python 🔗 https://lnkd.in/dTdWqpf5 🚀 Python isn’t just about syntax. It’s about solving real problems. 👉 What’s one thing you’ve automated using Python?

Another book recommendation from my holiday reading list. I picked up Python Object Oriented Programming expecting a straightforward refresher, and it turned out to be much more helpful than that. The writing is clear, the examples are realistic, and the authors focus on how to apply OOP in a way that actually improves the structure of your code. What I appreciated most is that the book explains not only how Python’s OOP features work, but also when they are worth using. The discussions around composition, inheritance, and design choices feel grounded in real software engineering rather than abstract theory. The updates for Python 3.13 are genuinely useful. The chapters on type hints, asyncio, and testing with pytest are written in a way that makes these topics feel approachable, even if you’ve struggled with them before. I found myself applying several ideas directly to my own codebase. This isn’t a flashy book and it doesn’t try to oversell POOP 😁. It’s simply a well-structured, thoughtful guide that helps you write cleaner and more maintainable Python. If you’re moving from scripts to larger applications or you want to strengthen your design skills, this is a solid choice.