I used to hate Python. Coming from C++ and Java, it felt fragile, inconsistent, and way too forgiving. Indentation defines scope, types are optional, performance isn’t great… and don’t get me started on packaging. The interesting part is: most of those things are still true. In today’s video, I talk about why I still use Python anyway, and the bigger lesson behind it. At some point, you realize it’s not about finding the “best” language. It’s about understanding trade-offs and choosing the right tool for the problem you’re solving. If you want to grow as a developer, that shift in thinking matters much more than the language you use. 👉 Watch here: https://lnkd.in/eJtP_jHF. #python #softwareengineering #programming #developers #careergrowth

I used to hate Python. Coming from C++ and Java, it felt fragile, inconsistent, and way too forgiving. Indentation defines scope, types are optional, performance isn’t great… and don’t get me started on packaging. The interesting part is: most of those things are still true. In today’s video, I talk about why I still use Python anyway, and the bigger lesson behind it. At some point, you realize it’s not about finding the “best” language. It’s about understanding trade-offs and choosing the right tool for the problem you’re solving. If you want to grow as a developer, that shift in thinking matters much more than the language you use. 👉 Watch here: https://lnkd.in/eXAPr3wq. #python #softwareengineering #programming #developers #careergrowth

I thought and and or worked the same everywhere. They don’t. Same idea. Very different outputs 🧠 What this means Same operators… different behavior: Python → returns values JavaScript → returns values C/C++ → returns 0/1 Java → strict boolean only ⚠️ Why this matters If you switch languages: 👉 Your code might “work”… 👉 but behave very differently 🎯 One-line takeaway 👉 and / or are not universal — they follow the rules of the language you’re in What language surprised you the most with this? #Python #JavaScript #Programming #Coding #Developers #LearningInPublic

Switching from Python to Java: Coming from a Python-heavy background, working with Java has been a real shift in perspective. In Python, a lot is taken care of for you through powerful high-level abstractions. You can move quickly, write less code, and focus on solving problems. But Java? It makes you slow down in a good way. You start paying attention to details you might have overlooked before: type definitions, structure, and the mechanics behind what your code is actually doing. It demands more explicitness, more discipline, and a deeper level of understanding. And that’s the beauty of it. Different languages, different strengths, but stepping outside your comfort zone is where real growth happens. https://lnkd.in/deNbabM5 #Java #Python #SoftwareEngineering #CodingJourney #LearningToCode

🐍 Most Python developers use try/except… but ignore else and finally. That’s a missed opportunity. If you’re only using try/except, your code might be less clear and harder to maintain than it needs to be. The underrated parts: else: runs only if no exception occurs finally: runs no matter what (even after return or errors) Why this matters: ✅ Enforces clear separation between execution logic and failure handling ✅ Reduces the risk of masking hidden bugs due to overly broad try blocks ✅ Guarantees deterministic cleanup of critical resources example: try: file = open('data.txt', 'r') content = file.read() except FileNotFoundError: print("File not found!") else: print("File read successfully!") finally: file.close() # Always runs! #Python #Programming #CodingTips #SoftwareDevelopment #LearnToCode #PythonDeveloper #ExceptionHandling

The internet will tell you to learn Python. Then JavaScript Developer. Then Go. Then Rust. Then whatever is trending this month. Here’s what nobody tells you. The engineers who compound the fastest aren’t the ones who know the most languages. They’re the ones who understand systems deeply enough that every new language takes them two weeks to pick up, not two years. A programming language is a tool. Systems thinking is the skill. How does data move through this application? Where are the failure points? What happens under load? How does this decision affect what gets built on top of it two years from now? Those questions have the same answers in Python, Go, and Rust. The engineers worth hiring aren’t the ones who can recite syntax. They’re the ones who ask the right questions before they write the first line. 👇 What’s one skill every engineer should develop that has nothing to do with code? #Gisax #SoftwareEngineering #ProductThinking #SystemsThinking #TechLeadership #BuildingRight

Announcing Shiny for Python 1.6: Toolbar Components and Production Observability 🔭 We are pleased to announce the release of Shiny for Python 1.6. This update focuses on making applications more compact and their underlying processes more transparent. • New Toolbar Components: Designed to optimize screen real estate, the new toolbar components allow for more compact and professional UIs. • Built-in OpenTelemetry Support: This release introduces native OpenTelemetry integration. You can now emit traces and spans to track app performance and health, providing much-needed observability for production environments. Create more robust, performant, and observable applications today! Learn more about Shiny for Python 1.6 and its new capabilities here: https://lnkd.in/gFeG_QTk

🐍 Python Developer Nuggets — Day 17 Retries in APIs Why do APIs fail even when everything looks correct? Because failures happen… and your system doesn’t retry smartly. The problem: Request fails once and stops User sees an error Even though it might have worked on retry The solution: Retry the request Add delay between retries Limit number of retries request = call_api() # retried on failure What changes: First attempt → may fail Retry → succeeds Better user experience Fewer visible failures Don’t retry everything Retry only when: Retry when: Network issues Timeout Temporary failures Don’t retry when: Wrong input Validation errors Golden rule: Retry only when failure is temporary Retry turns small failures into success #Python #Django #BackendEngineering #SystemDesign #CleanCode #Performance #DeveloperTips

Tips for larger Python programs! (I am not referring to small scripts, but program that are over 20,000) lines of code! 1 - modularize your design, this means split it into different python files for the different functional parts of your overall program! SUPER Important! 2 - if you cram everything into a single python file - maintenance will be a nightmare! How are you going to find anything ? the Human brain has limitation in very large program files no matter how smart you are! It doesn't matter if you have 50 years of experience or even if you invented the language! 3 - compiling a single large python file into a C code to protect you IP will take a very long time to run as the GCC compiler has limitations! even if you have a powerful computer - the rule is 1 python file to 1 core when compiling, you can not split that into Parallel, which will take forever to compile and you will waste a lot of time!!! 4 - after implementing modules, implement a Cache system / example you have 20 modules, but only made change to 1 Python file, why would you recompile the other 19 if there was zero change ? "BIG waste of time" and Unproductive! 5 - I written this, not used AI #python #tips #large #programs

After years of reading and writing code, I find that the dumbest code is the best code. It doesn't matter if it's C#, C++, or Python. Make your code simple. Don't use complex abstractions or difficult syntactic sugar, and you'll have a codebase that anyone can jump into and quickly add features without introducing bugs (or bugs that are less likely to happen). This matters more than anything else.