DEV Community: tanishparashar

Rate Limiting Microservice in Rust

tanishparashar — Mon, 12 May 2025 00:44:35 +0000

This is a submission for the Amazon Q Developer "Quack The Code" Challenge: Exploring the Possibilities

What I Built

I recently embarked on an ambitious project to build a high-performance, multi-tenant rate limiting service in Rust. Despite being a Rust novice (I'm still learning the language!), I managed to create a sophisticated microservice that serves as a critical entry point for modern distributed architectures.

Rate Limiter v2: A Comprehensive Solution

My rate limiter service isn't just a simple API throttler—it's a full-featured system designed for production environments with the following capabilities:

Multi-Tenant Architecture

The service supports multiple tenants with complete isolation between them. In this context, tenants represent different applications, services, or customers that need rate limiting capabilities. Each tenant can have:

Their own API key for authentication
Custom rate limiting rules and quotas
Different service tiers (free, standard, premium, enterprise)
Isolated usage tracking and metrics

Multiple Rate Limiting Algorithms

I implemented four different rate limiting algorithms to suit various use cases:

Token Bucket: Provides smooth rate limiting with burst capability
Leaky Bucket: Ensures constant outflow rate limiting
Fixed Window: Offers simple time-window based limiting
Sliding Window: Delivers more accurate time-window limiting with less boundary issues

Comprehensive Observability

Monitoring and debugging are critical for production services, so I integrated:

OpenTelemetry tracing: For distributed request tracing across services
Prometheus metrics: For collecting and exposing performance metrics
Grafana dashboards: For visualizing metrics with pre-configured dashboards
Jaeger UI: For exploring and analyzing traces

Resilient Storage Options

The service supports multiple storage backends:

In-memory storage for high performance
Redis for distributed deployments
Hybrid storage with Redis + memory fallback for resilience

API Documentation and Testing

Swagger/OpenAPI: For interactive API documentation
Load testing scripts: To validate performance under various conditions

Containerization

The entire solution is containerized with Docker and Docker Compose, making it easy to deploy and scale.

The Amazon Q Developer Experience

What makes this project truly remarkable is how I built it. Despite my limited Rust knowledge, I was able to develop this complex system with the help of Amazon Q Developer. The experience was transformative—it felt like I was managing Amazon Q while it handled 90% of the coding work.

We followed an iterative development process where Amazon Q:

Helped plan out the project iterations
Generated the core code structure
Implemented complex algorithms and patterns
Assisted with integrating various technologies
Provided debugging support when issues arose

It was genuinely shocking to experience firsthand the reality of AI-assisted development, where I could focus on architecture decisions and requirements while the AI handled the implementation details. This is the future—developers managing AI agents that generate most of the code, dramatically accelerating development cycles.

For my next iteration, I'm planning to implement gRPC for internal service communication instead of HTTP, which should further improve performance. I'm incredibly excited about continuing this project and exploring more ways to leverage Amazon Q in my development workflow.

Demo

Code Repository

https://github.com/tanishparashar/rate-limiter-final

How I Used Amazon Q Developer

Throughout the development of my Rate Limiter v2 service, Amazon Q Developer became my virtual coding partner—a software developer who worked alongside me, executing commands, writing
code, and debugging issues. This collaboration transformed my development workflow in ways I hadn't anticipated.

An Iterative Development Approach

My journey with Amazon Q began when I decided to take an iterative approach to building the rate limiter. I simply prompted, "This is iteration 1, code for me," and Amazon Q responded by
generating the initial codebase. This moment marked the beginning of a new development paradigm for me—one where I could focus on the big picture while Amazon Q handled the implementation
details.

For each iteration, I followed a process that looked something like this:

Planning: I'd describe the features and components needed for the current iteration
Code Generation: Amazon Q would generate the necessary Rust code
Review & Refinement: I'd review the code, ask questions, and request modifications
Integration: We'd integrate the new code with existing components
Testing & Debugging: Amazon Q would help identify and fix issues

Overcoming Challenges

The journey wasn't without its challenges. There was a particularly difficult moment when I faced over 100 compilation errors in my Rust code. I felt overwhelmed and considered abandoning
the project—it seemed impossible to fix so many issues, especially with my limited Rust knowledge.

After taking a break to clear my head, I returned to the project and decided to tackle the errors one by one with Amazon Q's help. I shared the error messages, and Amazon Q:

Explained what each error meant in plain language
Identified patterns among the errors
Suggested systematic fixes for groups of related issues
Provided corrected code snippets
Explained the underlying Rust concepts so I could learn from the experience

This debugging marathon not only saved my project but also significantly improved my understanding of Rust's ownership model, lifetimes, and type system.

Tips for Effective Collaboration with Amazon Q

Based on my experience, here are some insights for working effectively with Amazon Q Developer:

Provide Clear Context: The more context you provide about your project, the better Amazon Q can assist you. Include information about your project structure, dependencies, and goals.
Iterate Incrementally: Break your development into small, manageable iterations rather than trying to build everything at once.
Ask Specific Questions: When you encounter issues, be specific about what you're trying to achieve and what's not working.
Learn from the Code: Don't just copy-paste the generated code. Take time to understand it, which will improve your skills and help you make better requests in the future.
Verify and Test: Always review and test the generated code. Amazon Q is powerful but not infallible.
Use Natural Language: Explain your requirements in plain language, as if you were talking to a human developer.

The Transformation

Amazon Q has helped me become a better and more productive developer. It's not just about writing code faster—it's about having a knowledgeable companion throughout the development process
who can explain complex concepts, suggest best practices, and help troubleshoot issues.

The experience has changed my perspective on AI-assisted development. Rather than replacing developers, tools like Amazon Q amplify our capabilities, allowing us to tackle more complex
projects and focus on the creative aspects of software development.

I'm incredibly grateful for this challenge and the opportunity to work with Amazon Q. It's opened new possibilities for what I can build, even with technologies I'm still learning.

Why i dropped Golang and started rust.

tanishparashar — Sun, 16 Mar 2025 18:20:06 +0000

Why I dropped Golang and started Rust.

So, I was learning Golang and then became obsessed with the raw performance of a language. That's when I discovered Rust. Everyone was saying Rust is the GOAT, as fast as C, can build anything, and has various attractive features like:

Async
Strict types
Memory safety
Fast performance
Concurrency features
Hard to reverse engineer (Beware, if I ever attack you, you won't know)

So here I am, dropped Golang and now struggling with Rust, haha. Let's see what happens on this journey.

Post2: Golang Print Functions

tanishparashar — Wed, 11 Dec 2024 11:34:06 +0000

series: Golang

Printing Functions in Golang

In Golang, several functions are available for printing text, and each serves specific use cases. Here's an explanation of the most commonly used printing functions:

1. `fmt.Print`

Description:
Prints the provided arguments as plain text without adding a newline. It does not format the output.

Use Case:
For simple concatenated text or values where no specific formatting is required.

fmt.Print("Hello")          // Output: Hello
fmt.Print("World")          // Output: HelloWorld
fmt.Print(123, " GoLang")   // Output: HelloWorld123 GoLang

2. `fmt.Println`

Description:
Prints the provided arguments as plain text and appends a newline at the end.

Use Case:
For simple outputs where you want automatic line breaks after printing.

fmt.Println("Hello")         // Output: Hello (with newline)
fmt.Println("World")         // Output: World (on a new line)
fmt.Println(123, "GoLang")   // Output: 123 GoLang (on a new line)

3. `fmt.Printf`

Description:
Formats and prints text according to a specified format string. Does not add a newline unless explicitly included in the format string.

Use Case:
For dynamic or formatted outputs (e.g., integers, floats, strings, etc.).

name := "Alice"
age := 25
fmt.Printf("My name is %s and I am %d years old.", name, age)
// Output: My name is Alice and I am 25 years old.

Common Formatting Verbs:

Verb	Description	Example
`%s`	String	`fmt.Printf("%s", "Go")`
`%d`	Integer (base 10)	`fmt.Printf("%d", 123)`
`%f`	Floating-point	`fmt.Printf("%.2f", 3.14)`
`%v`	Default format for any value	`fmt.Printf("%v", true)`
`%T`	Type of the variable	`fmt.Printf("%T", name)`
`%+v`	Struct with field names	`fmt.Printf("%+v", obj)`

4. `fmt.Sprintf`

Description:
Formats text like fmt.Printf, but instead of printing to the console, it returns the formatted string.

Use Case:
For preparing strings for later use (e.g., logging, building responses).

formatted := fmt.Sprintf("Hello, %s!", "Alice")
fmt.Println(formatted)
// Output: Hello, Alice!

Why learn Golang?

tanishparashar — Sun, 24 Nov 2024 21:17:38 +0000

I was diving deep into JavaScript for a while, but eventually, I hit that “meh” phase. You know the one where you’re itching for something fresh? That’s when I thought, why not try Golang? So, here I am, learning this new language, and I’m excited to share the journey with you! 🚀

Let’s start with the basics: Why should you even care about Go? Why did the creators feel the need for another programming language? And what’s the buzz around its scope? Let’s unpack all that.

Why was Go designed?

Go (or Golang, if you’re feeling fancy) was cooked up by Robert Griesemer, Rob Pike, and Ken Thompson at Google back in 2007. So, what made Google say, “Yeah, we need a whole new language”?

Well, at the time, Google’s developers were grappling with some pretty frustrating challenges while building big, scalable systems.

Here’s what was bugging them:

Complexity: C++ and Java were powerhouses but had become way too complex. Writing clean, efficient, and scalable code felt like wrestling an octopus.
Concurrency: With CPUs adding more cores, writing concurrent programs that could actually use those cores efficiently was a nightmare in most existing languages.
Compilation Speed: Developers were twiddling their thumbs waiting for C++ code to compile. Ain’t nobody got time for that!

To address these challenges, the creators of Go aimed to design a language that was:

Their vision? Create a language that’s:

Simple: Clean and minimalistic, so it’s easy to learn and use without a 500-page manual.
Concurrent: Built-in tools to handle concurrency like a pro, making it faster and safer to write multi-core programs.
Fast: Quick compilation because waiting for your code to build shouldn’t feel like eternity.

What Does Golang Have to Offer?

Golang (or Go, for short) comes packed with features that make it a superstar for building scalable, concurrent, and efficient systems. Let’s take a quick tour of what makes Go so awesome:

Language Features

Simplicity: Go’s clean and minimalistic syntax is like a breath of fresh air. It’s super easy to pick up, even if you’re new to programming.
Statically Typed: No nasty surprises at runtime! Go catches errors during compile time, so your code behaves as expected.
Compiled Language: Go compiles to machine code, which means it runs fast—like really fast.
Garbage Collection: Say goodbye to manual memory management. Go’s built-in garbage collector handles it for you.

Concurrency Features

Goroutines: Think of goroutines as lightweight threads but with way less overhead. They make writing concurrent programs a breeze.
Channels: Need goroutines to talk to each other? Channels are here to help, making communication between them efficient and safe.
Mutexes and Locks: When you need to control access to shared resources, Go’s mutexes and locks have your back.

We’ll dive deeper into these features soon because, honestly, I’m amazed at how tempting they are! Stay tuned. 🚀

In What Technologies Is Golang Being Used?

Ever wondered where Golang shines? Spoiler alert: it’s everywhere! From cloud computing to web development, Go has carved a niche in some of the most exciting areas of tech. Let’s check out where it’s making waves:

Cloud and Infrastructure

Google Cloud: Go is all over Google Cloud, powering tools like Google Cloud Storage, Google Cloud Datastore, and Google Cloud Pub/Sub.
Amazon Web Services (AWS): Even AWS is on the Go bandwagon! Services like Amazon S3, DynamoDB, and Lambda have Go under the hood.
Microsoft Azure: Azure’s got love for Go too, using it in Azure Storage, Cosmos DB, and Functions.

Networking and Distributed Systems

Kubernetes: Yep, the legendary container orchestration tool is written in Go.
Docker: The backbone of containerization? Go plays a huge role in its core components.

Web Development

Netflix: Go powers parts of Netflix’s web services, including its API gateway and load balancer.
Dropbox: From file uploads to downloads, Go helps keep Dropbox fast and efficient.

DevOps and Automation

Terraform: This popular infrastructure-as-code tool is a Go creation.
Ansible: While mostly Python, Ansible taps into Go for some of its components.
Prometheus: The monitoring tool you probably love? It’s written in Go.

As you can see, Go’s versatility makes it a powerhouse in tech. It’s exciting to see how much ground it’s covered—and it’s just getting started!

JavaScript's Secret Sauce: How Single-Threaded Becomes Asynchronous

tanishparashar — Sun, 22 Sep 2024 15:48:44 +0000

JavaScript is single-threaded, so how does it manage asynchronous operations? The answer is simple: it doesn't—at least not directly.

JavaScript delegates these tasks to the browser or Node.js runtime, which is more than just the V8 engine executing JavaScript code.

Here's what really happens behind the scenes:

Web APIs

These are provided by the browser (or Node environment) to handle asynchronous tasks. Examples include setTimeout, XMLHttpRequest, and DOM events.

Callback Queue

Once an asynchronous operation (like a timeout or an AJAX request) is completed, its associated callback is placed into a callback queue.

Event Loop

The event loop is constantly checking the call stack (where JavaScript code executes). If the stack is empty, the event loop picks the next callback from the callback queue and pushes it onto the stack for execution.

Let’s look at a piece of code that demonstrates how the event loop manages asynchronous operations:

$.on('button', 'click', function onClick() {
    setTimeout(function timer() {
        console.log('You clicked the button!');    
    }, 2000);
});

console.log("Hi!");

setTimeout(function timeout() {
    console.log("Click the button!");
}, 5000);

console.log("Welcome to loupe.");

Remember, JavaScript doesn't wait for setTimeout or other async functions to finish before moving on. It delegates those tasks, and once they're done, the callback is added to the queue.

Hi!
Welcome to loupe.
Click the button!
You clicked the button!

What Happens Here?

Synchronous Tasks: When JavaScript runs, the call stack executes the tasks in order. First, it logs "Hi!", then "Welcome to loupe." because these are synchronous operations.

Asynchronous Tasks: The setTimeout function creates timers. But instead of blocking execution, these tasks are handed off to the browser’s Web APIs to wait for 2000ms and 5000ms, respectively.

Callback Execution: Once the specified time elapses, the callbacks (console.log("You clicked the button!") and console.log("Click the button!")) are moved into the callback queue. The event loop checks if the call stack is empty and then pushes these callbacks back onto the stack to be executed.

Visualizing the Call Stack

JavaScript’s call stack is LIFO (Last In, First Out). Only one task is processed at a time. If there's a long-running task (like a loop), it blocks the stack, which is why asynchronous callbacks like setTimeout help avoid blocking, allowing smoother execution.

The Importance of Asynchronous Callbacks

Understanding JavaScript’s event loop, call stack, and Web APIs is crucial because it gives insight into how asynchronous operations are handled, enhancing the efficiency and responsiveness of web applications.

In JavaScript, asynchronous callbacks are not optional. They're necessary to avoid blocking the main thread, especially for tasks like AJAX requests or setTimeout. This ensures your app runs smoothly, with no interruptions to the user experience.

To truly master JavaScript's asynchronous behavior, understanding the event loop is key. Be sure to check out this video and visualize the process with Loupe.

How JS works behind the scenes?

tanishparashar — Wed, 18 Sep 2024 05:04:52 +0000

How JavaScript Works

JavaScript operates in a single-threaded environment, meaning it executes one task at a time. It handles the execution of code in Execution Contexts (EC), which can be either Global or Functional.

Global Execution Context (GEC)

Created when the code file is loaded.
The GEC is responsible for setting up the global object (in browsers, it's window) and the (this) keyword.
All variables and functions declared in the global scope are stored in the Global EC.

Execution Context Phases

Memory Creation Phase:
During the memory phase, JavaScript allocates memory for variables and functions.
Variables are assigned the value undefined initially, while functions are stored in memory with their full definition.
Execution Phase:
After the memory allocation phase, JavaScript starts executing the code line by line.
Variables are assigned actual values and functions are executed.

Functional Execution Context (FEC)

Whenever a function is invoked, JavaScript creates a new Execution Context specifically for that function.
Execution context for each function has two phases:
Memory Phase: Memory is allocated to the local variables, and functions inside the function.
Execution Phase: The function body is executed, and variables get their actual values.
After execution, the function's execution context is destroyed, freeing up memory.

Return Statements
Once a function reaches a return statement, the function immediately exits, and its execution context is removed from the Call Stack. Any code written after a return statement won't execute.

The Call Stack
JavaScript uses the Call Stack to manage execution contexts.

LIFO (Last In, First Out) concept is used:
When a function is called, its execution context is placed on top of the stack.
Once the function completes (or reaches return), its execution context is popped off the stack.

JavaScript is Single-Threaded

Single-threaded means JavaScript can only perform one operation at a time but still it can perform asynchronous operations isn't that interesting in my next post we will discuss about this amazing functionality of JavaScript.