Embedded languages, which are specialized languages written within another language, often require efficient virtual machines to optimize performance. Maria’s research, conducted within the innovative environment at Google, involved implementing and benchmarking five distinct types of virtual machines: a tree-traversal VM, three variations of stack-based VMs, and a register-based VM.

One notable aspect of her research was the use of Google Cloud Platform (GCP) for performance monitoring and analysis. Leveraging GCP’s robust infrastructure provided detailed insights into the performance characteristics of each virtual machine type under different scenarios, ensuring accurate and comprehensive results.

For those interested in a deep dive into her findings, we have made Maria Chizhova’s complete thesis available for download here.

Benchmark Performance of Various Virtual Machines​

Below is a graph illustrating the performance of various virtual machines based on different benchmarks such as Sum from 1 to 200, Alternating Sum from 1 to 200, String Concatenation, String Comparison & Logic Operations, and Sum of External Variables.

The graph shows the execution time (in nanoseconds) for each benchmark across different types of virtual machines:

• Tree Traversal VM
• Single Stack VM
• Multiple Stack VM
• Reflective VM
• Register-based VM

Each benchmark provides a comparative view of how each VM type performs under specific conditions.

For instance, the Tree Traversal VM shows higher execution times across most benchmarks, indicating it is less efficient compared to other VM types. On the other hand, the Register-based VM consistently shows the lowest execution times, suggesting it is the most efficient among the evaluated VMs.

This visual comparison highlights the strengths and weaknesses of each VM type, helping developers choose the most suitable VM for their specific embedded language requirements.

Impact on the Development of the Expr Language​

Maria’s research has had a significant impact on our work on the Expr language. By thoroughly evaluating the performance of different virtual machines, we were able to identify the most efficient approaches for implementing the core of Expr. Specifically, the insights gained from the performance of stack-based and register-based VMs guided us in optimizing our execution engine, resulting in faster and more reliable expression evaluation.

Moreover, the use of GCP for performance monitoring and analysis has influenced our ongoing development practices, ensuring that Expr remains not only powerful but also highly efficient. As a result, users of the Expr language can expect improved performance in real-world applications, particularly in scenarios requiring high throughput and low latency.

Welcome to an adventurous dive into the world of prime numbers, guided by none other than Expr, the sleek and flexible expressions language designed for Go. Whether you're safeguarding your business rules or simply indulging in the mathematical elegance of primes, Expr is your trusty sidekick. Today, we're embarking on a quest to uncover prime numbers in ways that are as engaging as they are enlightening. So, grab your math hat (yes, that's a thing now), and let's get started!

Prime Check: Is My Number a Lone Wolf?​

First off, let's tackle the burning question: "Is my number prime?" Imagine you're at a party, and 27 walks in. You whisper to Expr, "Hey, is 27 part of the prime clique?" Expr, always ready, responds with a slick one-liner:

let N = 27; none(2..N-1, N % # == 0)

Here, Expr takes the number 27 and checks if none of the numbers from 2 to 26 can divide it without leaving a remainder. It's like asking everyone at the party if they're best friends with 27 and finding out nobody is. Alas, 27 is not prime. But worry not, the party goes on.

Prime Gathering: Who's Coming to the Prime Party?​

Next up, we're throwing a prime party and need to send invites to all prime numbers from 2 to 1000. How do we find these exclusive guests? Expr to the rescue!

2..1000 | filter(let N = #; none(2..N-1, N % # == 0))

This nifty line asks Expr to hand out invites to numbers from 2 to 1000, but only if they pass the prime test. It's like having a bouncer at the door checking if the guests have any friends from 2 to one less than themselves. If not, welcome to the party!

Eratosthenes' Sieve: The Prime Filter Party Trick​

Now, for the grand spectacle: Eratosthenes' sieve. This ancient algorithm is like the coolest party trick for finding primes, and yes, Expr knows it too.

let numbers = 2..1000; 
reduce(numbers, { 
    let n = #; 
    filter(#acc, # == n || # % n != 0) 
}, numbers)

Here, we start with a list of numbers from 2 to 1000. Then, for each number, we filter out the non-primes by keeping only the number itself or those that it can't evenly divide. It's like having a magic sieve that only lets through the primes. Pure sorcery!

The Memory Budget: Expr's Party Limit​

But oh, what's this? There's a limit to how big our party can get. Expr comes with a concept called "memory budget," ensuring that our prime-finding escapades don't get too wild. For example:

runtime error: memory budget exceeded (1:39)
 | 2..1_000_000 | filter(let N = #; none(2..N-1, N % # == 0))
 | .......................................^

Trying to invite every prime between 2 and 1,000,000? Expr might just stop you there with a polite, "Sorry, that's beyond my memory budget." This ingenious feature prevents our prime quest from consuming more memory than allowed, ensuring that our computational party doesn't crash the server.

How Does Expr Calculate This Budget?​

Every operation in Expr has a cost, and as we weave through our expressions, these costs accumulate. Think of it as Expr having a certain amount of "computational currency" to spend on our tasks. If our expression's cost exceeds this budget, Expr kindly asks us to tone down the party. It's like trying to order a 5-course meal on a 2-course budget—something's got to give!

Conclusion: Prime Time with Expr​

And there you have it, folks! A whirlwind tour of finding prime numbers with the flexible and mighty Expr. From gate-crashing non-primes to hosting the most exclusive prime parties and managing our computational budget like a true event planner, Expr proves to be an invaluable companion in the realm of expressions.

Remember, the next time you're pondering the primeness of numbers or any other mathematical marvel, just call on Expr. It's your go-to for not just business rules but for unlocking the secrets of mathematics with elegance and a sprinkle of fun.

So, keep exploring, keep questioning, and most importantly, keep enjoying the mathematical festivities with Expr. Who knew prime numbers could be this much fun?

It's been 5 years since I started working on Expr. It's been a long journey, and I'm excited to share some of the highlights with you.

Introduction

Five years back, at Aviasales, we were transitioning our search engine from Python to Go. Our task was to revamp our business rule engine, but we were stuck without the right language to script these complex rules. I stumbled upon govaluate, but it was like finding a boat with holes – abandoned and not seaworthy for our needs.

The Birth of a New Language

&ast.BinaryNode{
    Operator: "+",
    Left: &ast.IntegerNode{1},
    Right: &ast.BinaryNode{
        Operator: "*",
        Left: &ast.IntegerNode{2},
        Right: &ast.IntegerNode{3},
    },
}

That's when I rolled up my sleeves. We needed a language that wasn't just about doing the job; it needed finesse – features like all() and none() predicates that you now see in Expr. So, I started from scratch, with a simple idea and ANTLR, a parser generator, as my initial tools. This first language version was basic – turning input into an AST and walking through this tree to get results. It was a humble start but it worked, and it worked well.

Evolving with Need

As we stretched the capabilities of our new language, we quickly realized its initial simplicity had its limits. A pivotal moment came when I decided to abandon the parser generator we were using. The reason? It wasn't just about its cryptic error messages, which were more puzzling than helpful. A more pressing issue was a specific bug in ANTLR's Go version, particularly on 32-bit machines. This limitation was a deal-breaker, as I envisioned Expr to be versatile, running seamlessly across various platforms, not restricted by such technical constraints.

Faced with these challenges, I took matters into my own hands. I crafted a bespoke parser from scratch. This wasn't just about fixing bugs or expanding compatibility; it was about creating something that resonated with users. My parser was designed to be clear, concise, and above all, user-friendly. It was a game-changer, transforming error messages from baffling codes into understandable, actionable insights. This shift significantly enhanced the language's usability and marked a major milestone in its evolution, setting the stage for Expr to be a versatile and accessible tool across diverse computing environments.

Chasing Efficiency

0  OpPush      <1>
1  OpPush      <2>
2  OpPush      <3>
3  OpMultiply
4  OpAdd

Then came the need for speed. The solution was clear – a virtual machine. I crafted a compiler to turn our AST into bytecode, and when I got this virtual machine running, it was like hitting the turbo button. Our language wasn't just faster; it was lightning-fast, encouraging more complex and extensive use at work. And soon, it wasn't just us at Aviasales using it – other companies started catching on, and my little project began to grow wings.

Community Engagement and Growth

Expr's journey has been a testament to the power of community and innovation. Beginning with blog posts and presentations at conferences like this one, Expr has captured the attention of the programming world. Today, it's thrilling to see it being embraced by a diverse and growing community, including developers and companies worldwide.

The impact of Expr has reached global proportions, with industry giants like Uber, ByteDance, GoDaddy, Philips, and Google (google3/third_party/golang/expr) integrating it into their ecosystems. This widespread adoption underscores the language's versatility and effectiveness in addressing complex programming needs.

Feedback from this vibrant community has been a cornerstone of Expr's development. Feature requests and bug reports have been particularly insightful, shedding light on how Expr is used in various contexts and what enhancements are most desired by users. This direct input has been invaluable in steering the language's evolution.

In response to every bug report, I've created a unit test, ensuring that each issue, once resolved, stays fixed. This commitment to quality and continuous improvement has been key in building trust and reliability within the Expr community.

Looking Ahead: The Future of Expr

The journey of Expr is far from over. As it gains momentum, being used by renowned companies and developers, the future looks bright and full of potential. My vision is to keep Expr dynamic, continually evolving to meet the changing demands of the tech world.

The roadmap for Expr includes several exciting features that are currently in development. These upcoming enhancements are designed to further solidify Expr's position as a powerful tool in the programming landscape, offering new capabilities that I believe will be enthusiastically received by the community.

Expr's niche focus on the Golang community and business rule engines, coupled with its growing popularity in major tech companies, positions it uniquely in the field of programming languages. As the technology landscape evolves, Expr is set to evolve with it, meeting the challenges and embracing the opportunities that lie ahead in this specialized domain.

In my lightning talk at GoWayFest 3.0, I delved into the complexities and necessities of developing our own bytecode machine. I discussed the various reasons why my team and I at Aviasales decided to embark on this challenging yet rewarding journey. From the desire for increased performance to the need for a highly customized solution tailored to our specific use cases in Go, I covered the technical considerations and the value such an undertaking brings. I also touched upon the importance of open-source work and community involvement in projects like this, which not only enrich the project but also contribute to the larger ecosystem.

I was invited to speak at GoWayFest 2018 in Minsk, Belarus. It was my first time speaking at a conference, and I was excited to share my experience with the Go community. I spoke about how I built Expr, a powerful expression language for Go.

It was a great experience, and I'm happy to share the video of my talk with you. I hope you enjoy it!