Optimize Python Backend Performance with Background Workers

When I recently posted about the speed-up in Mark Burgoyne's pyResToolbox using Rust, there was some push back concerning the Rust benchmarks as I was showing that my Java implementation was faster. https://lnkd.in/dgk-WyZA The general comment was that Rust should be faster than Java. I'd agree. Rust is compiled ahead of time and can optimise the compiled code for the target CPU. Java is compiled using a [just-in-time compiler](https://lnkd.in/deEMcCnm) from bytecode that is generated to be run on any CPU. Since my previous intent was just to show Java versus Python, or Java versus Python with Rust acceleration in a casual way, I decided to undertake a more comprehensive comparison which would allow fairer comparison. Mark Burgoyne has supplied a [variety of code examples](https://lnkd.in/dm7HyCd9) for the BNS viscosity method, including a pure Rust implementation and VBA for Excel. The results for this more comprehensive comparison are shown in the image along with this post. Note the logarithmic scale for calculations per second! Note the difference between single pressure and multiple pressure, is that multiple pressure does calculations for an array of pressure points on the same composition, so the loop can be optimised. This shows that Rust with parallel threaded execution for the multiple pressure point solutions is by far the fastest implementation, reaching ~ 61 million calculations per second. In comparison VBA for Excel manages a paltry 772 calculations per second. Rust is about 80,000 times faster, or nearly 5 orders of magnitude. As a long time advocate that most speed comes from the algorithm design itself, it is still remarkable to see just what a difference the language and environment makes. Remember, these are benchmarks for an **identical** algorithm. The difference is purely the language implementation. This dramatically illustrates the difference between speed and convenience. Where Excel and Python are (arguably) more accessible, parallel algorithms in Java and Rust deliver better speed. I think the Rust-accelerated Python solution that Mark wrote is a good compromise between the two. As an aside, this is the first Rust code I've ever written / used. I'm pretty impressed.

Most developers switching to Go from Java or Python hit the same wall: there is no try-catch. Instead, Go returns errors as ordinary values and asks you to check them with `if err != nil` on almost every line. It looks like boilerplate. It is actually a design decision. Here are the 4 patterns every Go developer needs to know. 🧱 Pattern 1: Basic error return + defer A function signals failure by returning an error as its last value. `defer` guarantees cleanup runs when the function returns, on any path. No finally block needed. 🎁 Pattern 2: Wrapping errors with context Returning a raw error loses all information about where it happened. Use `fmt.Errorf` with `%w` to add context while preserving the original: return nil, fmt.Errorf("readUserFile: opening %q: %w", path, err) This turns error messages into a readable breadcrumb trail through your codebase. Use %w to wrap (callers can inspect). Use %v only when converting to a final log string. 🚩 Pattern 3: Sentinel errors + errors.Is When callers need to distinguish a specific condition, define a named sentinel at the package level and check it with errors.Is, not ==. Direct equality fails for wrapped errors. errors.Is unwraps the chain layer by layer until it finds a match. 🏗️ Pattern 4: Custom error types + errors.As When the caller needs structured data from the error (not just recognition), define a struct that implements the error interface. Extract it with errors.As, which searches the entire error chain by type to give you typed fields directly. ⚖️ The honest trade-offs ✅ Every error is visible at the call site ✅ No hidden control flow, no surprise jumps ✅ Code review is easier: no distant catch blocks to hunt through ❌ if err != nil repeated throughout every function ❌ No automatic stack trace (wrap consistently with function names as a fix) ❌ Errors can still be ignored with _ (use errcheck or staticcheck in CI) Go's philosophy: errors are normal outcomes, not exceptional events. Explicit is better than implicit. The verbosity is the feature. We built a full hands-on article where we construct a working CLI called userstore that demonstrates all 4 patterns together in one runnable program. 🔗 https://lnkd.in/gqVCS9ib

Embabel treats LLMs as participants in strongly typed workflows — not black boxes — and the Spring creator Rod Johnson spring says that gives Java developers an edge Python can't match. By Darryl Taft

Stopping "The Red Lines": 5 Java Mistakes Every Beginner Makes ☕️🚫 Java is a powerhouse language, but it’s a strict one. When you’re first starting out, it feels like the compiler is constantly judging your life choices. If you want to write cleaner code and save hours of debugging, watch out for these five common traps: 1. The == Trap for Strings In Java, == checks if two objects occupy the same spot in memory. To check if two Strings actually contain the same words, you MUST use .equals(). ❌ if (input == "Yes") ✅ if (input.equals("Yes")) 2. The "Final Boss": NullPointerException Trying to call a method on a variable that hasn't been initialized is the fastest way to crash your app. Always initialize your objects or use a null-check before diving in. 3. Static vs. Instance Confusion The main method is static, meaning it exists without an instance of your class. Beginners often try to call "regular" methods directly from main and get hit with a "non-static method cannot be referenced" error. Either make the method static or create an object first! 4. Case-Sensitivity Struggles Java is unapologetically picky. MyVariable and myvariable are strangers to the compiler. Stick to camelCase for variables and PascalCase for classes to keep your sanity intact. 5. Off-by-One Array Errors Remember: Java starts counting at 0. If your array has a length of 10, the last index is 9. Using i <= array.length in a loop is a guaranteed ticket to ArrayIndexOutOfBoundsException. Building a foundation in Java isn't about avoiding mistakes—it's about learning to recognize them faster. Which of these gave you the most trouble when you started? Let’s hear your "horror stories" in the comments! 👇 #Java #CodingTips #SoftwareDevelopment #ProgrammingBeginner #CleanCode

Embabel treats LLMs as participants in strongly typed workflows — not black boxes — and the Spring creator Rod Johnson says that gives Java developers an edge Python can't match. By Darryl Taft

🌳 TreeSet in Java — simple, but powerful. Most developers use List or HashSet… but ignore TreeSet, even when it’s the perfect choice. 🔹 What is TreeSet? A sorted Set in Java 👉 Stores unique elements 👉 Maintains elements in sorted order 🔹 Why is it important? Because sometimes you don’t just need data… 👉 You need it ordered automatically No extra sorting step required. 🔹 When should you use TreeSet? ✔ When you need sorted data ✔ When you want no duplicates ✔ When frequent range queries are needed 🔹 Example 👇 Set<Integer> set = new TreeSet<>(); set.add(5); set.add(1); set.add(3); System.out.println(set); 👉 Output: [1, 3, 5] 🔹 Behind the scenes 👀 TreeSet uses a Red-Black Tree 👉 Operations (add, remove, search) → O(log n) 🔹 Interesting fact 💡 👉 TreeSet doesn’t use equals() for uniqueness It relies on compareTo() / Comparator That means: If comparison says two elements are equal → one will be ignored 💡 Real-world example: Think of a leaderboard 🏆 👉 Always sorted 👉 No duplicates 👉 Easy to get top/bottom performers 👉 HashSet = Fast 👉 TreeSet = Sorted Choose based on your need. Want to go deeper into Java & System Design? 👉 https://lnkd.in/gjQhR3_Y Follow for more on AI, Java & System Design 🚀 #Java #TreeSet #JavaDeveloper #Collections #BackendDevelopment #SoftwareEngineering #Developers #Tech #Learning

Java and JavaScript are not call by reference. It's time to clarify a common myth: “Java / JavaScript pass objects by reference” is not true. Both languages strictly use call by value, similar to Python. Why the confusion? When you pass objects, changes can sometimes reflect outside the function, which may appear to be call by reference. However, it’s actually value copying. To understand this, consider the memory architecture: - Stack: Stores variables and function calls, with each call creating a new stack frame. - Heap: Stores actual objects. Here’s what happens during a function call: 1. Variable Creation: - Primitives store actual values. - Objects store references (memory addresses). 2. Function / Method Call: - A new stack frame is created, and parameters become new local variables. 3. Core Step — Value Copy: - The value of the argument is copied. For primitives, the data is copied; for objects, the reference (address) is copied. It’s still a copy in both cases. 4. Inside Function: - Mutation works (e.g., 'obj.name = "Ishwar"' changes the same object in the heap). - Reassignment does not work (e.g., 'obj = new Object()' only changes the local copy). 5. Function Ends: - The stack frame is destroyed, and original variables remain unchanged. Mental Model: The caller variable copies the value to the function parameter, providing no direct access to the original variable—only a copy is used. This behavior applies to multiple languages: - Java: Call by value - JavaScript: Call by value - Python: Call by value (object reference) - C#: Call by value (default) Final truth: “Everything is pass by value. Some values just happen to be references.” 🔖 Follow CodeWithIshwar for more deep dives into real-world programming concepts. #CodeWithIshwar #Java #JavaScript #Python #Programming #SoftwareEngineering #BackendDevelopment #Coding #Developers #Tech #ComputerScience #OOP #Debugging

Tail-call optimization is one of those programming features that once you learn it, you can't believe it's not in every language (it sadly still isn't in Java). If you haven't heard of it, here's the idea. Many algorithms are easily understood in terms of recursion, but everyone knows what the problem with that is. Each recursive call consumes a new stack frame, so if you recurse too deep, you overflow the stack and run out of memory. Tail-call optimization cleverly fixes this. It's a compile-time language feature that transforms recursive functions so that they reuse the current stack frame instead of adding new ones. That means you can recurse to unlimited depths without blowing the stack. Notably, this only works if the recursive call is the last operation in the function. Otherwise it's impossible to reuse the current frame. But that usually isn't a problem. Elixir and OCaml (I've heard) do this for you automatically. Scala and Clojure do it with hints (tailrec and recur, respectively). I'd love it if it came to Java since it's something I've come to rely on. But it's been debated for many years and it hasn't happened yet. Maybe someday. 🤷

𝗣𝘆𝘁𝗵𝗼𝗻 𝗩𝗦 𝗝𝗮𝗩𝗔 𝗩𝗦 𝗝𝗮𝗩𝗔𝗦𝗰𝗿𝗶𝗽𝘁: 𝗪𝗵𝗮𝘁'𝘀 𝗧𝗵𝗲 𝗗𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝗰𝗲 You want to learn programming. Python, Java, and JavaScript are popular choices. But what are they used for? Python is a simple language. It has clean syntax and is easy to learn. Key features include: - Easy-to-learn syntax - Dynamically typed - Huge ecosystem of libraries - Interpreted language You can use Python for: - Data Science and Machine Learning - Artificial Intelligence - Automation and scripting - Web development Java is a robust language. It is widely used in enterprise applications. Key features include: - Strongly typed language - Platform independent - Highly secure and scalable - Runs on the Java Virtual Machine You can use Java for: - Enterprise applications - Banking and financial systems - Android app development - Large backend systems JavaScript is used for web development. It creates dynamic and interactive web pages. Key features include: - Runs directly in web browsers - Event-driven and asynchronous - Dynamically typed - Can be used for both frontend and backend You can use JavaScript for: - Frontend web development - Interactive UI elements - Real-time applications - Backend development Source: https://lnkd.in/gA6fJDVj