Forem: Ali Amer

Why does performance debugging still suck so much?

Ali Amer — Wed, 08 Apr 2026 20:40:18 +0000

Recently I got laid off.

Weirdly, I didn’t feel stressed. I actually felt… excited.

For a long time I’ve wanted to build something meaningful in open source, but work always got in the way. Suddenly I had the time to try.

So I asked myself a question:

Why does performance debugging on Linux still suck?

I remember a moment back in college that stuck with me.

One semester we had to build a project using .NET on Windows.

It was the first time I had to seriously use Windows for development.

Honestly, I never liked .NET very much.

But there was one thing I really liked: Visual Studio.

When you run an application in the debugger, Visual Studio shows you live metrics:

CPU usage
memory usage
allocations
performance spikes

And the coolest part was watching what happened when you interacted with the app.

You could click a button in the UI and instantly see:

CPU usage spike
memory allocations change
performance graphs jump

That made performance debugging feel visual and intuitive.

You could literally see:

“I clicked this button… and something expensive just happened.”

Then you start digging:

Which function caused the spike?
Why did memory jump here?
What part of the code is slow?

It turned performance optimization into a kind of investigation.

And I loved that experience.

But there was a problem

Years later, working mostly on Linux systems, I realized something strange.

We have powerful tools:

perf
bpftrace
flamegraphs
eBPF

But none of them feel as simple and immediate as that Visual Studio experience.

Most tools are:

hard to set up
hard to understand
designed for experts

So I decided to build one.

The idea

I’m building a tool called Nusku.

The goal is simple:

A fast, modern performance profiler built with Rust + eBPF.

It should:

run instantly
require almost no setup
work on production systems
show useful information immediately

No complicated configuration.

No massive dashboards.

Just run it and see where your CPU time is going.

What I’ve built so far

So far Nusku can:

Attach to a running process
Sample CPU usage using eBPF perf events
Capture user-space stack traces
Symbolize addresses into real function names
Aggregate hot functions in real time
Show CPU usage and memory usage in a live terminal view

Example output:

── PID 132612 ── 98 samples ── CPU  99.0% ── RSS 2.0 MiB ── VIRT 3.1 MiB ──
     %     COUNT  FUNCTION                          SOURCE                           ADDRESS
────────────────────────────────────────────────────────────────────────────────────────────────
 27.6%        27  <core::ops::range::Range<T> as …  range.rs:773          0x00005efa8cfd4b95
 11.2%        11  testing::hot_c                    main.rs:7             0x00005efa8cfd4cc7
 10.2%        10  <i32 as core::iter::range::Step…  range.rs:197          0x00005efa8cfd4acd
 10.2%        10  <core::ops::range::Range<T> as …  range.rs:775          0x00005efa8cfd4b9f
  9.2%         9  testing::hot_c                    main.rs:8             0x00005efa8cfd4cf0
  6.1%         6  <core::ops::range::Range<T> as …  range.rs:771          0x00005efa8cfd4b69
  5.1%         5  <i32 as core::iter::range::Step…  range.rs:198          0x00005efa8cfd4b0b
  4.1%         4  core::hint::black_box             hint.rs:482           0x00005efa8cfd4d5a
  4.1%         4  core::iter::range::<impl core::…  range.rs:856          0x00005efa8cfd4b40
  3.1%         3  <core::ops::range::Range<T> as …  range.rs:776          0x00005efa8cfd4bba
  2.0%         2  <core::ops::range::Range<T> as …  range.rs:772          0x00005efa8cfd4b7a
  2.0%         2  <core::ops::range::Range<T> as …  range.rs:780          0x00005efa8cfd4bce
  2.0%         2  testing::hot_c                    main.rs:9             0x00005efa8cfd4d09
  2.0%         2  <i32 as core::iter::range::Step…  range.rs:195          0x00005efa8cfd4ac4
  1.0%         1  core::hint::black_box             hint.rs:483           0x00005efa8cfd4d64

Top frame:
  <core::ops::range::Range<T> as core::iter::range::RangeIteratorImpl>::spec_next
  /home/ali/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/lib/rustlib/src/rust/library/core/src/iter/range.rs
  line 773

Everything runs in real time.

Under the hood it uses:

Rust
libbpf-rs
eBPF stack sampling
Blazesym for symbolization

What’s next

Right now the output is pretty basic.

Next steps include:

building a proper terminal UI (Ratatui)
improving symbol aggregation
better stack analysis
eventually generating flamegraphs

The long-term vision is a tool that feels as simple as:

run with pid:

nusku --pid 1234

run binary:

nusku ./my-app

run with commend:

nusku -c node app.js

and immediately shows you where your program is spending CPU time.

Follow the project

I’ll be posting updates as I build this.

If you're interested in:

Rust
eBPF
performance debugging

follow along.

GitHub repo:
https://github.com/aliamerj/nusku

And if you have ideas or feedback, I’d love to hear it.

The Hidden Superpower of AI: How Smart Data Retrieval Is Revolutionizing Everyday Life

Ali Amer — Mon, 19 May 2025 10:40:29 +0000

A Day in the Life of “Invisible AI”
Imagine waking up and asking your smart assistant for:

“What’s my most urgent email? And remind me to follow up on that proposal if I haven’t heard back by Friday.”

Your AI not only scans your inbox, it understands which messages matter most and taps into your calendar, too. No more frantic searches for a lost attachment or digging through threads—you get answers instantly.

That’s the magic of AI‑powered retrieval, quietly hustling behind the scenes in apps you use every day.

Why We Need Better Search—Again
Keyword search felt revolutionary in the 2000s: type a phrase, get a list of links. But today, our data looks nothing like a neatly indexed webpage:

Voice notes from last week’s brainstorming session
PDFs with handwritten meeting minutes
PowerPoint decks shared in chat groups
Traditional search can’t connect the dots between “budget forecast” in a spreadsheet and that off‑hand mention in your voice memo. AI retrieval changes the game by understanding meaning, not just matching words.

5 Surprising Ways AI Retrieval Helps You Right Now
Smarter Personal Assistants

Your AI can pull relevant documents, chats, and even images to answer complex questions:
“Show me the contract version we signed last quarter and summarize its key dates.”
Instant Knowledge Base for Teams

No more “check our internal wiki”—AI bots can fetch and summarize policies, technical docs, or HR guidelines in natural language.
Contextual Shopping Recommendations

e‑commerce sites use retrieval to suggest products based on past purchases, reviews, and even your browsing behavior, all blended seamlessly.
Legal & Medical Research Made Simple

Lawyers and doctors can ask AI to surface past cases or similar clinical studies, saving hours of manual literature review.
Home Automation with a Brain

Ask your smart home:
“Which lights were on last night between 10 PM and midnight?”
and get a precise timeline without sifting through logs.
The Flip Side: When Search Breaks
Ever typed in a query and felt like your data was speaking a different language? That’s because:

Synonyms and slang confuse keyword search.
Unstructured formats (images, audio) aren’t easily indexed.
Volume & velocity overwhelm simple databases.
AI retrieval solves these by converting everything into “embeddings”—compact numerical fingerprints that capture meaning. Suddenly, “sales report Q1” and “Q1 numbers” live in the same semantic neighborhood.

Your Next Step with AI Retrieval
Curious to see how this works under the hood? Platforms like Dcup (open‑source RAG‑as‑a‑Service) let you:

Connect all your data sources in minutes.
Automatically chunk and embed documents, audio, and more.
Deploy a smart search API that speaks natural language.
Whether you’re building the next-gen digital assistant or just want your team to stop chasing files, AI‑powered retrieval is the secret sauce. Give it a spin—and transform chaos into clarity.

Want to experience invisible AI retrieval for yourself?
Head over to dcup.dev and start your free self‑hosted trial today! 🚀

Building Dcup: An Open-Source RAG Pipeline with a Twist

Ali Amer — Sun, 04 May 2025 11:57:05 +0000

Ever wrestled with a RAG pipeline and thought, “Why is this so damn hard?” We’ve been there—tearing our hair out over complexity and slow performance. So, I built Dcup, an open-source, self-hostable RAG-as-a-Service platform that actually works Very good.

What’s Dcup All About?

It’s a tool to hook your app up to user data with zero bullshit. Here’s the rundown:

Tech Stack: Next.js, BullMQ for job queues, OpenAI for embeddings, and Qdrant for vector storage. It’s lean, mean, and scales like a dream.
Killer Features: AI-driven retrieval and hybrid search that cuts through the noise. Plus, optional re-ranking if you’re a precision freak.
Learn more

At its core, Dcup is your bridge to smarter data handling. It takes the complexity out of RAG pipelines by automating the heavy lifting. Here’s how it works in plain English:

Data Ingestion: Hook up your data sources—think Google Drive, AWS, or wherever your files live—and Dcup keeps it all synced and current.
Data Processing: Your raw data gets chopped into bite-sized chunks and turned into embeddings using OpenAI. (More on embeddings later—they’re cool!)
Storage & Indexing: Those embeddings land in Qdrant, a lightning-fast vector database that makes searching a breeze.
Advanced Retrieval: Need answers fast? Features like re-ranking and hybrid search dig up the most relevant info in seconds.

Think of Dcup as your personal AI assistant that organizes, understands, and retrieves your data like a pro.

The Fight We Won

Big files used to choke us. Performance would tank, and we’d be staring at spinning wheels. Then we got smart—batching and parallel processing turned it around. Now, Dcup eats large datasets for breakfast.

Why You’ll Dig It

This isn’t some corporate ad. It’s a project by dev not shitty vibe coding or whatever the kids call it these days.

support the project

Star the repo if it vibes with you: Dcup on GitHub.

Wanna contribute? Hit me up! Let’s make RAG pipelines suck less together.

First Reverse Proxy Built with Zig

Ali Amer — Mon, 25 Nov 2024 11:45:37 +0000

The first-ever reverse proxy built with Zig. If you're a developer, sysadmin, or just someone interested in optimizing web traffic handling, Cloud Cup may be your new favorite tool. It's lightweight, fast, and built to scale. And it's open-source!

In this blog, I'll walk you through Cloud Cup’s architecture and the challenges I faced while building it. I’ll also talk about how you can help shape the future of this project, suggest new features, and contribute. I am just getting started, and your feedback and support can make all the difference.
What is Cloud Cup?

What is Cloud Cup?

Cloud Cup is a reverse proxy and load balancer designed with simplicity and performance in mind. It helps route traffic between clients and backend servers, distributing the load evenly to avoid overloading any single server. But here’s the twist – Cloud Cup is built using Zig, a low-level language known for its performance and control over memory usage.

Unlike traditional reverse proxies, which can be heavy on resources, Cloud Cup is lightweight, optimized for speed, and easy to configure. I believe it’s the next big thing in reverse proxies, and I want you to be a part of it.

Architecture

Cloud Cup’s architecture is designed to be as efficient and scalable as possible, and it revolves around the Master-Worker pattern. Let’s break it down:

Master Process

The master process is the heart of Cloud Cup. Here's what it does:

Configuration Management: The master process validates and applies configurations at startup, ensuring that everything is set up correctly before launching workers.
Dynamic Hot Reloading: Through the CLI tool (called cupctl), Cloud Cup can hot reload its configurations without needing to restart the entire system. This allows for seamless updates and scaling on the fly.
Worker Management: The master spawns multiple worker processes and ensures that they are always running. If a worker crashes, the master immediately spawns a replacement.
CLI Listener: The master also manages the command-line interface, which lets you interact with Cloud Cup, run diagnostics, and apply updates.

Worker Process

The worker process is responsible for handling actual network traffic:

Shared Port, Independent Threads: All workers listen on the same port, and the kernel manages the traffic distribution between them. Each worker has its own epoll instance for highly efficient I/O handling.
Concurrency with Thread Pool: Each worker has a dedicated thread pool for handling requests concurrently, making Cloud Cup highly scalable and responsive.
Configuration Updates: The workers dynamically receive updates from the master process, so configuration changes are applied across all workers instantly and consistently.

Challenges I Faced

Building Cloud Cup wasn’t without its challenges. Since I'm working with Zig, a language that is still relatively new in the ecosystem, I faced a steep learning curve when it came to optimizing networking performance and ensuring memory safety. But I was determined to keep the project lightweight, efficient, and easy to use.

Some of the challenges I overcame include:

Memory Management: Zig’s manual memory management gave us more control, but also required careful handling to avoid memory leaks or crashes. I've worked hard to ensure that Cloud Cup’s memory footprint remains minimal while still delivering high performance.
Concurrency and Scalability: I wanted Cloud Cup to handle heavy loads without sacrificing performance. Building the master-worker architecture allowed us to handle traffic distribution efficiently while maintaining responsiveness.

But I'm not done yet! I'm actively working on adding more features and improving performance even further.

How Can You Contribute?

As Cloud Cup is still in its early stages, I’d love your help! Whether you're a developer, tester, or just someone who wants to try out new software, you can contribute in many ways:

Feature Requests: Is there something you’d love to see in Cloud Cup? I'm listening! Submit your ideas, and I will review them.
Bug Reports: Encountered a bug? Let me know so I can fix it. Your feedback helps make Cloud Cup better for everyone.
Code Contributions: If you’re interested in contributing code, check out GitHub repo. I'd be happy to accept pull requests for new features or bug fixes.
Suggestions: Have suggestions on how I can improve documentation or features? Drop me a message. I want to make Cloud Cup as user-friendly as possible.

You can find all the information you need for contributing in our CONTRIBUTING.md file.
What’s Next?

I'm just getting started with Cloud Cup, but I already have big plans for future updates. In the next releases, I'm planning to improve:

Performance: Always looking to make Cloud Cup even faster!
Features: More advanced load balancing options and enhanced configuration management.
Documentation: I am committed to improving the docs, making it easier for developers to get started with Cloud Cup.

If you're passionate about reverse proxies, load balancing, or just want to see Cloud Cup grow, consider supporting me on our Patreon. Every bit of support helps me keep building and adding new features.

I Need Your Feedback!

I want to make Cloud Cup the best reverse proxy tool out there, and for that, I need your feedback. Whether it’s a suggestion for a new feature, an improvement to the documentation, or a bug you’ve encountered, I want to hear from you.

You can reach out via:

GitHub Issues: Create an Issue
Email: Send me a message at aliamer19ali@gmail.com

I am really excited about Cloud Cup, and I hope you’ll join me on this journey. Help me build the future of reverse proxies, one feature at a time!

Thanks for reading, and I can’t wait to hear what you think!

Github: https://github.com/cloud-cup/cloud-cup
DOC: https://cloud-cup.netlify.app/