kenura

Bazel for Multi-Language Monorepos: One Build System for Go, C++, TypeScript, and WASM

Sun, 03 May 2026 00:00:00 +0000

What’s a Monorepo?

A monorepo is a single git repository that holds multiple related projects. Instead of having separate repos for your backend, frontend, and shared libraries, everything lives together. You can see all the code, make cross-cutting changes in one commit, and ensure that related projects stay compatible.

The challenge: different parts of the codebase use different languages and build tools. Go uses go build. C++ uses cmake or make. TypeScript uses npm and vite. How do you tie these together into one coherent build?

Building a Multi-Screen TUI in Go with Bubbletea

Sun, 03 May 2026 00:00:00 +0000

What Is a TUI?

A TUI (Terminal User Interface) is an interactive application that runs in the terminal but behaves more like a desktop app — it has screens, navigation, live-updating panels, and keyboard shortcuts.

Examples you’ve probably used: htop, lazygit, k9s, ncdu. These aren’t just text output — they’re full interactive applications that happen to live in your terminal.

Go’s ecosystem has an excellent framework for building these: Bubbletea (from Charm Bracelet). It uses the Elm architecture — a functional, message-driven model that makes complex TUIs manageable.

ClickHouse for Financial Data: Candles, Footprints, and the Timezone Trap

Sun, 03 May 2026 00:00:00 +0000

When you’re building a trading dashboard, you need to answer queries like:

“Give me all 1-minute candles for BTCUSDT between 9am and 5pm”
“Show me the buy/sell volume breakdown at each price level for the last hour”
“Enrich every candle with the open interest and funding rate at that time”

These are analytical queries — they aggregate millions of raw trades into summaries. ClickHouse is a database built specifically for this kind of work, and it handles these queries in milliseconds even on hundreds of millions of rows.

Docker, Docker Hub, GitHub Packages, and CI/CD Pipelines: The Complete Picture

Sun, 03 May 2026 00:00:00 +0000

What Is Docker and Why Does It Matter?

When you write code on your laptop, it works. When you deploy it to a server, it breaks. Different OS version, different library versions, different environment variables, different file paths. “It works on my machine” is one of the oldest problems in software.

Docker solves this by packaging your application with everything it needs to run — the OS libraries, the runtime, the config — into a single image. That image runs identically everywhere: your laptop, a CI server, a production server in a data center.

FlatBuffers and Protobuf in One System: Picking the Right Serialization Format

Sun, 03 May 2026 00:00:00 +0000

What Is Serialization?

When two programs communicate — a Go backend and a TypeScript frontend, or a Go server and a C++ desktop app — they need to send data over the network. But data in memory (structs, objects, arrays) can’t be sent directly over a socket. It needs to be converted to bytes first.

That conversion is serialization. The reverse — converting bytes back into usable data structures — is deserialization.

Git + GitHub CLI: A Unified Terminal Workflow

Sun, 03 May 2026 00:00:00 +0000

Two Tools, One Job

git and gh are different tools that work on the same codebase. Understanding the split helps you use them together effectively.

git talks to your local repository and git remotes. It manages commits, branches, merges, stashes, history. Everything git does is about the version control state of your code.

gh talks to the GitHub API. It manages pull requests, issues, GitHub Actions runs, releases, and repository settings. It’s essentially a CLI wrapper around GitHub’s web interface.

Go Error Handling: Patterns That Actually Work

Sun, 03 May 2026 00:00:00 +0000

Why Go Errors Look Weird to Beginners

If you’re coming from Python, JavaScript, or Java, Go’s error handling looks repetitive:

1
2
3
4
5
6
7
8
9


result, err := doSomething()
if err != nil {
 return err
}

data, err := doSomethingElse(result)
if err != nil {
 return err
}

In other languages, exceptions handle this automatically — an error thrown anywhere in the call stack bubbles up to the nearest catch. Go doesn’t have exceptions. Errors are just values returned from functions. You check them explicitly every time.

Monorepos: What They Are, Why You'd Want One, and When You Wouldn't

Sun, 03 May 2026 00:00:00 +0000

What’s a Monorepo?

A monorepo (monolithic repository) is a single git repository containing multiple related projects. Instead of one repo per service or library, everything lives together:

my-company/
├── backend/ # Go service
├── frontend/ # React app
├── mobile/ # React Native app
├── shared/
│ ├── proto/ # Protobuf schemas
│ ├── types/ # Shared TypeScript types
│ └── utils/ # Shared utilities
├── infra/ # Terraform, Kubernetes configs
└── tools/ # Internal tooling

One git clone, and you have the entire codebase. One PR can touch backend + frontend + shared types + infra in a single commit.

One C++ App, Two Targets: ImGui on Vulkan and WebAssembly

Sun, 03 May 2026 00:00:00 +0000

The Problem: Two Platforms, One Codebase

Most UI frameworks make you choose: build for desktop (native, fast) or build for web (JavaScript, runs everywhere). If you want both, you write it twice — once in C++, once in TypeScript/React — and then spend the next year keeping them in sync.

There’s a different approach: write the application logic once in C++, and compile it to both targets. Native binary for desktop with Vulkan. WebAssembly module for the browser. Same source, different compilation backend.

Redis as a Real-Time Data Pipeline: Streams, Pub/Sub, and Hash Patterns

Sun, 03 May 2026 00:00:00 +0000

Redis Isn’t Just a Cache

Most developers know Redis as a key-value cache — put data in, get data out, set a TTL. But Redis has several data structures that make it a powerful backbone for real-time pipelines:

Streams — append-only log with consumer groups (like Kafka, but simpler)
Pub/Sub — fire-and-forget message broadcasting
Hashes — key-value maps with field-level gets and sets
Sorted Sets — ordered data with score-based queries

A real-time market data pipeline uses all of these, each for a different job. Understanding which tool fits which job is the key.

Schema-Driven Codegen: One File to Rule Your Database, SQL Views, and Go Structs

Sun, 03 May 2026 00:00:00 +0000

Imagine you’re building a system that stores millions of financial trades in a database. You need three things that all describe the same data:

A database table — tells ClickHouse how to store the rows
A Go struct — lets your Go code read and write rows in a type-safe way
A SQL view — a stable “clean” layer your queries always read from

If you write all three by hand, they start identical. Six months later, someone renames a column in the database but forgets to update the struct. A type changes in the view but not in the Go code. These bugs are silent — everything compiles, but your data is wrong at runtime.

Self-Healing Data Pipelines: How to Build Systems That Fix Their Own Gaps

Sun, 03 May 2026 00:00:00 +0000

Here’s the reality of running any system that collects real-time data: things will go wrong. Your WebSocket connection will drop at 3am. Your process will restart in the middle of a busy trading session. The network will hiccup for 30 seconds.

When that happens, you miss data. The question is: does your system notice, and does it fix itself?

A “self-healing” pipeline is one that can answer yes to both. This post explains how to build one.

Serving gRPC and HTTP from One Go Server with ConnectRPC

Sun, 03 May 2026 00:00:00 +0000

The Problem with Standard gRPC in Browsers

gRPC is excellent for service-to-service communication. It’s fast, strongly typed from a .proto schema, and supports bidirectional streaming. But it has a fundamental limitation: gRPC requires HTTP/2, and browsers don’t support HTTP/2 in a way that gRPC can use directly.

The browser’s fetch API and XMLHttpRequest don’t expose the low-level HTTP/2 framing that gRPC needs. So a TypeScript frontend can’t call a standard gRPC server.

Taskfiles: A Better Makefile for Modern Projects

Sun, 03 May 2026 00:00:00 +0000

What’s a Task Runner?

When you work on a software project, there are repetitive commands you run all the time:

1
2
3


docker compose up -d
bazel build //backend:theron
./build/theron serve --collect

You could type these every time. Or you could write them down in a script. But scripts don’t give you dependency tracking (“run this only if that hasn’t been done”), parallel execution, or self-documentation.

That’s what a task runner does. The classic one is make — you’ve probably seen make build or make test. But make has decades of quirks and a syntax that trips up even experienced developers.

Three-Tier Data Collection: WebSocket, S3 Archives, and REST Gap Filling

Sun, 03 May 2026 00:00:00 +0000

The Problem With Just Using a WebSocket

If you’re collecting market data, the most obvious approach is: connect to the exchange WebSocket, receive every trade as it happens, write it to the database. Simple.

This works fine while your system is running. But what about:

Historical data? The WebSocket only gives you data from now forward. How do you get the last 3 years?
Downtime? If your system was offline for 2 hours, you missed 2 hours of data. The WebSocket doesn’t replay missed messages.
Slow REST backfill? Downloading a year of trades via REST API (limited to 1000 rows per request) would take days.

The solution is a three-tier architecture: each tier handles what it’s best at, and all tiers write to the same storage layer that automatically handles duplicates.

Using Make as a Task Runner: Beyond Just Compiling C

Sun, 03 May 2026 00:00:00 +0000

Make Isn’t Just for C

Most developers encounter make in the context of compiling C or C++ code. The default tutorials show you how to compile .c files into .o files and link them into a binary.

But make is actually a general-purpose task runner. Any project — Go, Python, Node.js, a data pipeline — can benefit from a Makefile as a collection of documented, runnable commands.

You’ve probably already used it without thinking about it:

WebAssembly Deep Dive: C++, Emscripten, WebGPU, and the Browser's New Runtime

Sun, 03 May 2026 00:00:00 +0000

What Is WebAssembly?

WebAssembly (WASM) is a binary instruction format that runs in the browser at near-native speed. It’s not JavaScript, not a plugin, and not a virtual machine in the traditional sense. It’s a compact binary format that browsers can parse and execute much faster than JavaScript.

Think of it this way: JavaScript is text that the browser interprets at runtime. WebAssembly is pre-compiled binary — closer to what your CPU actually executes. The browser still sandboxes it (it can’t access files or the OS directly), but within the browser sandbox, WASM code runs fast.

About

Thu, 01 Jan 2026 00:00:00 +0000

Kenura R. Gunarathna

Founder & CEO at KRAG. Full-stack developer building websites, web apps, and software across the stack — from embedded systems to production web services. Currently also at Thenex Global.

Education

Education
University of Colombo	B.Sc. Electronics & IT Special Degree · Physics Dept. (Years 1–2: Physics, Applied Mathematics, Statistics, CS)
Thurstan College, Colombo	Secondary · Grades 6–13
Asoka College	Primary · Grades 1–5

Skills

Languages

Level
Expert	HTML · CSS · JavaScript (ES6/ES7) · jQuery · PHP · SQL · Python · Go · C · Kotlin
Proficient	C++ · Java · MongoDB
Learning	TypeScript

Frontend — React · Next.js · Astro.js · SolidJS · Svelte · Tailwind CSS · Bootstrap · Jetpack Compose · ImGui (C++)