Jorge M. Mendes’ Post

Python vs Go — When to Use What? 🤔 Both Python and Go are powerful, but they solve different problems. Choosing the right one can make your system faster, simpler, and easier to maintain. 🔹 Python — Best for Speed of Development Python is easy to learn, flexible, and has a huge ecosystem. Use Python when: • You are building APIs quickly (FastAPI, Django, Flask) • Working on Data Science, AI, or Machine Learning • Writing automation scripts or internal tools • You need rapid prototyping and quick iterations Why Python? • Simple and readable syntax • Huge community support • Tons of libraries for almost everything 🔹 Go (Golang) — Best for Performance & Scalability Go is designed for concurrency and high-performance systems. Use Go when: • Building microservices or distributed systems • Handling high traffic APIs • Working with cloud-native tools (Docker, Kubernetes) • Need fast execution and low memory usage Why Go? • Built-in concurrency (goroutines) • Compiled language → faster than Python • Simple, clean, and production-friendly ⚖️ Quick Comparison: • Python = Productivity & Flexibility • Go = Performance & Scalability 🚀 Real-world tip: Many companies use BOTH. 👉 Python for data & business logic 👉 Go for high-performance services Final Thought: Don’t ask “Which is better?” Ask “Which fits my problem?” #Python #Golang #BackendDevelopment #Microservices #SoftwareEngineering #TechCareers

Stop scrolling for a second. If Python still feels confusing or messy to you, this will fix it. One simple sheet can save you hours every single day. Learn Python the easy way without stress, without heavy words. It doesn’t matter if you are just starting or already writing code. A clear, simple reference always helps when your mind goes blank. This Python sheet covers the real basics that every program needs. 1. Basics :- This is where everything starts. Printing text, saving values, checking data type, and taking input. Like saying “Hello” before a conversation. 2. Data Types:- Think of them as different boxes. Lists for items in order, dictionaries for name–value pairs, sets for unique items. Choose the right box, and life becomes easy. 3. Conditions (if–else) :- This is how Python makes decisions. Example: If marks are above 35 → pass. Else → fail. Simple thinking. Real-life logic. 4. Loops :- Doing the same work again and again? Loops do it for you in seconds. Like checking 1,000 rows of data without manual effort. 5. Functions :- Write once. Use many times. Instead of repeating code, call a function. Just like saving a contact instead of dialing the number every time. 6. Classes & OOP :- Think of real objects. A “Car” has color, speed, and brand. Classes help you organize big projects neatly. 7. File Handling :- Your code talks to files here. Read data. Write results. Save logs. Always use with open() it keeps things safe and clean. 8. Error Handling :- Mistakes will happen. Always. Try–except helps your program stay calm instead of crashing. Like wearing a helmet while riding a bike. Keep this sheet nearby while coding. Whenever you solve a problem, connect it to one concept from here. That’s how real learning happens. Now your turn 👇 What is one Python shortcut or trick you use all the time? Comment it right now. Someone reading your comment today might thank you tomorrow. If you found this helpful, share ♻️ this post so others can see it too! Join our group to stay updated on new hiring opportunities and industry trends Referrals https://lnkd.in/gVvKzHCV

Python for Developers | Step 4 — Terminology That Actually Matters One part of this course that looked trivial at first, but turned out to be important, was terminology. Function, method, attribute, module, package, library — these are often used interchangeably. They shouldn’t be. A built-in function is something Python gives you out of the box: -len(), type(), print() No import, no setup. Just available. A custom function is something you define yourself: def add(x, y): return x + y Both are functions. The difference is the source, not the behavior. A method is still a function, but attached to an object: lst.append(3) The key difference is not syntax — it’s binding. The method operates on the object it belongs to. Calling a method on an object that does not implement it raises an error, because methods are type-specific behavior, not universal functions. x = 10 x.append(3)  # AttributeError: 'int' object has no attribute 'append' An attribute is not something you call — it’s something you access: obj.x This is where confusion happens: obj.method() → behavior obj.attribute → data Accessing an attribute returns the value stored in that attribute, which represents the object's state or metadata. Mixing them leads to incorrect assumptions when reading code. A module is a single Python file. A package is a directory of modules. That distinction matters when imports start getting deeper: from package import module A library is what you install and use as a complete tool. For example: NumPy or Pandas. It usually contains multiple packages and modules, but from your perspective, it’s one unit of functionality. This might look like just naming things correctly, but it’s not. It affects: how you read documentation how you structure code how you understand what is actually being used Small detail that stood out: When you write: len([1, 2, 3]) and: [1, 2, 3].append(4) Both look similar in usage, but they are fundamentally different: one is a built-in function, the other is a method bound to an object Same language, different mechanisms.

Shipping Python code shouldn’t feel like rolling dice in production. Modern tooling has quietly changed the game — not by adding complexity, but by removing entire classes of bugs before they ever exist In my latest Towards Data Science article I break down how a lightweight but powerful toolchain can turn your dev pipeline into a safety net: black → zero-effort format consistency ruff → lightning-fast linting pytest → confidence through real, maintainable tests mypy → catching type-related bugs before runtime py-spy → understanding performance without touching code pre-commit → enforcing all of the above automatically The real takeaway isn’t the tools themselves — it’s how combining them creates a feedback loop that catches issues early, standardizes quality, and speeds up development instead of slowing it down. If your pipeline still relies on “we’ll catch it in review” or “we’ll fix it later”… this is worth your time. Read the full breakdown and setup guide: https://lnkd.in/ewuXn6NF

Typed-FFMpeg 4.0 Release I built typed-ffmpeg, a Python package that lets you build FFmpeg filter graphs with full type safety, autocomplete, and validation. It’s inspired by ffmpeg-python, but addresses long-standing issues like lack of IDE support and fragile CLI strings. What’s New in v4.0: TypeScript support — Full TypeScript bindings with the same API as Python. Works in Node.js and the browser. Code-generated from FFmpeg source, so every filter and option is typed. parse() — reverse-engineer any FFmpeg command — Paste an FFmpeg CLI string and get back a typed filter graph object, in both Python and TypeScript. Useful for learning, migrating legacy scripts, or building tools on top of FFmpeg. Per-version packages — Instead of one 10 MB bundle with all FFmpeg versions, you now install only what you need: pip install typed-ffmpeg-v7 (~300kb). Packages exist for FFmpeg 5 through 8. FFmpeg 8.0 support — Full compatibility with the latest FFmpeg release. GitHub: https://lnkd.in/gHZAV7QG I’d love feedback, bug reports, or ideas. Thanks! — David (maintainer)

Stop Writing "Mystery Code": The Power of Python Docstrings 🐍 When we build functions, we often focus solely on making the code run. However, well-designed code isn't just about execution; it's about communication. If you've ever returned to a project after a few months only to realize you’ve forgotten how your own functions work, you know the struggle. This is where docstrings become your best friend. A docstring is a specialized string used to describe what a function does, acting as a built-in manual that stays with your code wherever it goes. How to Structure Your Documentation To move beyond basic notes and write professional grade documentation, you should follow a multi-line format. This is particularly useful for complex research or data science functions that handle multiple variables: The One-Line Summary: Always start with a brief, high-level description of the function's purpose immediately following the function definition, wrapped in triple quotation marks """. Defining Arguments (Args): After a blank line, list the function’s arguments. For each one, specify the name, the expected data type in brackets, and a brief description of what it represents. Describing Returns: Finally, include a "Returns" section. This tells the user exactly what the function will output and what data type to expect (e.g., a float, a list, or a dataframe). The Bottom Line Writing documentation might feel like an extra step, but it is the hallmark of a disciplined developer. Whether you are working on academic research or building a commercial app, docstrings ensure your work is scalable, shareable, and most importantly understandable. How do you document your projects? Let’s share best practices in the comments! 👇 #PythonProgramming #CleanCode #DataEngineering #CodingTips #TechCommunity

Recently I published an open-source utility I built back in 2024: skeletonpy. TL;DR: If you do AI-assisted Python coding and want a simple way to include your project's code summary without bloating the context, with pretty much zero setup or installation, give it a try. Simply run this in your project's source root: uvx skeletonpy src And include the generated `summary.py.txt` file in your favorite LLM's context. The Backstory I built this because I had no luck with RAG. Granted, back then it was just naive RAG, and there were very few good reranking models. Maybe RAG is simply not a good fit for code, or maybe it was just me. Either way, I always ended up with a context half-full of irrelevant garbage. Furthermore filling up the prompt often leads to standard context rot or the "lost in the middle" phenomenon, where models just start ignoring or confusing data. Today top-tier models got better but some performance degradation is still there. I use skeletonpy occasionally when coding Python projects even today, especially when working with coding assistants like Cline and I want to have full control and insight into the generated code (no vibes :-) ). It gives the AI a focused, accurate map of the repo with class-level resolution to quickly find what it needs. How it works Skeletonpy is deliberately "simple and stupid": it does exactly one thing. It parses your source code offline using AST (no LLMs, no vector DBs, no complex local indexers) to generate a highly compressed skeleton of your repository. It squashes a few pages into a few lines while still providing references back to the original code so the LLM agent can "dig deeper" in the right location. At the same time, the output summary perfectly resembles Python. I've tested it against various LLMs over the last two years and they all had no problems navigating and understanding this structural pseudo-code. https://lnkd.in/dW7QYBkF

This week, I went deep into Python environment management. It may not sound like the most exciting topic, but I can say with confidence — understanding this correctly is what separates developers who struggle with broken setups from those who move fast and build with clarity. Here is a precise breakdown of every tool I studied, and what each one actually does: 🔷 Anaconda A complete Python distribution. Bundles Python, the conda package manager, and 250+ scientific libraries into a single installer. The go-to choice for data science and ML projects, particularly when GPU support (CUDA) or complex system-level dependencies are involved. 🔷 Miniconda The lightweight alternative to Anaconda. Provides only conda and Python — nothing extra. Gives developers full control over what gets installed, keeping environments lean and purposeful. 🔷 conda The core tool within the Anaconda ecosystem. Used daily to create isolated environments, manage package versions, and install dependencies that go beyond Python — something pip alone cannot handle. 🔷 pip Python's built-in package installer. Pulls packages directly from PyPI (the public Python package index). Works reliably inside conda environments as a fallback when packages are unavailable through conda channels. 🔷 UV A next-generation package and project manager built in Rust. UV replaces pip, venv, and pip-tools in a single unified tool. It runs 10–100× faster, manages Python versions natively, and dramatically reduces environment setup time. I started using UV , and the difference in speed and simplicity was evident from day one. Less time on setup means more time focused on what actually matters — learning and building. The principle that stayed with me: in any technical discipline, your tools shape your pace. Mastering them early is not overhead — it is a foundation. Thanks to Sunny Savita and Krish Naik for the clarity and depth of instruction at Krish Naik Academy. #GenAI #Python #ArtificialIntelligence #AgenticAI #ProfessionalGrowth #LearningAndDevelopment #ContinuousLearning #UV

Python for Developers | Step 4 — Functions, Modules, and Errors Completed I’ve just finished the second course in my restart journey: Intermediate Python for Developers. The course builds on the fundamentals but shifts the focus toward using Python more intentionally. Chapter 1 Built-in functions Modules Packages Chapter 2 Defining custom functions Default and keyword arguments Arbitrary arguments (*args, **kwargs) Docstrings Chapter 3 Lambda functions Introduction to errors Error handling On paper, this looks simple — and it is. But it highlights a trade-off: Python is easy to write, but requires precision to use correctly. The built-in functions, modules, and packages part was straightforward, but it refreshed practical use cases and structure. It also forced a quick reset on working with packages — not just installing from PyPI, but understanding what each command does, how to interact with the terminal, and not relying on memorization. The functions section was the most valuable. It covered the different ways arguments can be passed — positional, keyword, and arbitrary — and how to handle different types of data inside a function. This is where things stop being “just syntax” and start depending on how well you understand data structures and how they behave when passed around. It also corrected terminology that is often mixed up: function, method, attribute, module, package, and library. Using each term correctly matters more than it seems, especially when reading documentation or working in larger systems. The error handling part was the biggest addition. This is not something I was exposed to in university, and it changed how I think about writing functions. Instead of assuming correct usage, the idea is to expect misuse: validate inputs, understand different types of errors, and raise clear exceptions when something goes wrong. The instructor also emphasized making functions resilient by anticipating how they can be used incorrectly. Overall, short but informative. It refreshes key parts of the foundation, clears small gaps, and builds momentum toward deeper topics — especially for anyone aiming toward machine learning or AI engineering. Going forward, I’ll keep sharing small “tricky” or easy-to-miss details from each course — similar to what I did with data structures. Next step: deciding what to tackle next. Object-Oriented Programming, or something else?

I tried using asyncio to speed up my Python code recently… and yeah - it worked. But it also made me realize something I didn’t expect. Most tutorials teach you how to use asyncio. They don’t really tell you when it actually makes sense. The problem I noticed In normal Python code, everything just… waits. API calls wait DB queries wait File uploads wait And your program isn’t really doing anything during that time. What asyncio actually changed for me With asyncio, instead of waiting, the program switches to another task. So while one request is stuck waiting, another one keeps moving. That’s where the speedup comes from. Where it felt really useful Calling multiple APIs together Trying out some basic scraping Anything where the app spends more time waiting than computing If it’s I/O-heavy, it just makes sense. Where things got confusing One CPU-heavy function slowed everything down Had to think “async” across the whole stack Missed an await once… and spent way too long figuring it out That part was frustrating. What I took away from this asyncio isn’t about making Python “faster” in general. It’s more about not wasting time while waiting. So now I think of it like: A lot of waiting → asyncio helps Heavy computation → probably not the right tool Still figuring this stuff out, but this was a useful lesson. when did asyncio actually help you in a real project?