Presenters

Source

Composable, Polyglot Magic: Unlocking Efficiency with Razi P3! 🚀

Ever felt like your applications are stuck in their own little silos, unable to talk to each other efficiently? Or maybe you’ve wrestled with getting different programming languages to play nicely together without a mountain of boilerplate code? Well, buckle up, because we’re diving into the exciting world of composable, polyglot architectures with Razi P3, and it’s a game-changer! ✨

Our journey today is guided by Torson and Carik from Firmian, who walked us through a real-world scenario demonstrating the power of P3. Get ready to see how complex problems can be elegantly solved by stitching together components written in different languages.

The Humble Beginning: A Python Uppercaser 🐍

Let’s set the scene with a common challenge. Imagine a Slack channel, aptly named “Ying,” where every message needs to be in uppercase. A straightforward requirement, right? Carik kicked things off by building a simple Python service to handle this.

  • The Goal: Take any incoming message, uppercase it, and send it back.
  • The Implementation: A lean Python app that reads the incoming request body as a stream and applies an uppercase function to each chunk.
  • The Tool: The demonstration utilized Spin, a CNCF project, to run this Python logic.

The demo was a success! A curl request with random text sent to the running app resulted in a beautifully uppercased response. Business logic: check! ✅

The Bandwidth Bottleneck: Compression Woes 😩

But as often happens in the real world, success brings new challenges. The “Ying” channel got noisy, with tons of messages flying back and forth. This meant a significant drain on network bandwidth. The obvious solution? Compression.

The team tried sending compressed data, expecting their Python app to handle it.

  • The Attempt: Sending compressed data with a Content-Encoding header.
  • The Result: Failure. The Python app, expecting UTF-8 strings, choked on the compressed bytes.

This is where the magic of composability and polyglot programming truly shines!

Enter Rust for Performance: The Compression Middleware 🦀

The problem: the Python app wasn’t designed for compressed data. The solution: introduce a compression middleware. And to ensure blazing-fast performance, Rust was the language of choice.

  • The Vision: A Rust component that acts as a transparent middleware. It would decompress incoming data before it hits the business logic and compress outgoing data after the business logic has processed it.
  • The Key: This middleware should be reusable across multiple business logic components, without requiring any changes to the original logic.
  • The Mechanism: The Rust component intelligently inspects Content-Encoding and Accept-Encoding headers to perform decompression and compression as needed.

The Power of Composition: Weaving it Together with P3 🧩

This is where Razi P3 truly shines. The team demonstrated how effortlessly they could compose these disparate components:

  1. The Python Business Logic: The original uppercaser.
  2. The Rust Compression Middleware: The high-performance compression/decompression layer.

Using P3’s declarative approach, they described how to “take the middleware and the logic” and compose them into a new, enhanced application. This new composed application was then built and run.

The “Oops” Moment: Debugging Live! 😅

As with any live demo, things don’t always go according to plan. There was a moment of collective head-scratching as the composed application initially failed to process the compressed data. The audience even chimed in with suggestions – a truly interactive debugging session!

After some sleuthing, the culprit was identified: the curl request was sending the data incorrectly, not as binary data. Once this was corrected, the composed application sprang to life, beautifully handling both compressed and uncompressed requests! 🎉

  • The Takeaway: Even with a slight hiccup, the ability to transparently swap components and debug in real-time showcased the power and flexibility of the P3 approach.

Key Takeaways from the P3 Experience 💡

The presentation highlighted some crucial benefits of using Razi P3:

  • Component Composition: Effortlessly combine different components, each potentially written in a different language.
  • Concurrency and Async IO: P3 embraces concurrency as a core concept, with enhanced support for async functions and generic future/stream types. This streamlines the design of asynchronous operations.
  • Transparent Middleware: Business logic remains completely unaware of surrounding middleware, allowing for modularity and reusability.
  • Language Agnostic: Build components in the best language for the job (Python for simplicity, Rust for performance) and compose them seamlessly.

The Nitty-Gritty: Performance and Overhead ⚡

A pertinent question from the audience touched on the overhead of calling Rust functions from Python within the P3 environment. Here’s the fascinating insight:

  • Not Traditional FFI: You’re not dealing with the typical overhead of Foreign Function Interface (FFI) calls between separate language runtimes.
  • Wasm Execution: Both components, when executed, are running within the WebAssembly (Wasm) runtime. Wasm is compiled to native code, meaning the execution itself is highly optimized.
  • Optimized Inter-Component Communication: The overhead lies at the Wasm instance boundary. This communication is specifically designed and highly optimized to be fast, leveraging standards like wit (WebIDL Interface Types) and canonical APIs.
  • Nanosecond-Level Performance: Early benchmarks suggest inter-component calls can be in the nanosecond range, highlighting the incredible efficiency of this approach.

Wrapping Up: The Future is Composable! 🌐

The session with Torson and Carik was a fantastic glimpse into the future of building applications. Razi P3 offers a powerful way to create flexible, performant, and maintainable systems by embracing composability and polyglot programming.

You can explore the source code on GitHub and find the Firmian team at booth 442. Don’t hesitate to reach out with your questions – the world of composable architectures is open for exploration! 🚀✨

Appendix