arf; go-typescript; Hidden Bash Gems

No theme, today, as life is somewhat bonkers right now, but these three resources have stuck in my head this week, so I’m going to try to make room in the noggin’ by putting them down here.

---

TL;DR

(This is an LLM/GPT-generated summary of today’s Drop. Ollama and MiniMax M2.1.)

• arf is a Rust-based R REPL that offers a modern interface with fuzzy help search, SQLite-backed command history, syntax highlighting, and useful meta commands for interactive exploration (https://github.com/eitsupi/arf)
• go-typescript is a Go package that wraps the goja runtime to enable high-performance, production-ready TypeScript execution within Go services without CGO dependencies (https://github.com/clarkmcc/go-typescript)
• This article presents ten bash tips and tricks, including features like extended globbing with shopt -s extglob, that may be new to many developers (https://slicker.me/bash/gems.html)

---

arf

The trusty ol’ R console has been around for quite a long time and hasn’t really been keeping up with the REPL joneses. Even icky Python got a recent REPL makeover. Sure, there’s Radian, but my goals is to have less Python around, noit more. Thankfully there’s a new REPL game in town — arf (Alternative R Frontend) — and, the fuzzy help search alone makes it worth a look.

The project is written in Rust (because ofc it is) and ships as a single binary with zero runtime dependencies. Installation is straightforward if you’ve got Rust’s cargo toolchain around (cargo install arf), or you can grab prebuilt binaries from the releases page (which is what I did). It integrates with rig, the R Installation Manager, so if you’re already managing multiple R versions that way, arf will let you switch between them with meta commands like :rig default 4.4-arm64.

The first big difference you’ll see in arf is that command history is stored in SQLite, which means it persists across sessions and you can actually search through it with fuzzy matching. Type :h ggpl and you’ll get ggplot2 help without needing to remember the exact spelling.

The reprex mode helps produce reproducible examples, which is great for teaching, documentation, or getting help fixing a bug or three.

There’s syntax highlighting via tree-sitter, configurable keybindings through a TOML (yay!) file, and a collection of meta commands for things like timing expressions (:time) or clearing the screen (:cls). The project’s still young enough that I wouldn’t bet my production workflows on it, but for interactive exploration and teaching sessions where you want a cleaner interface, it’s a genuinely useful addition to the R tooling landscape. Give it a spin and see if it fits how you actually work.

Oh, and the README and gif example are solid.

---

go-typescript

For folks looking to integrate TypeScript execution directly into their Go services, go-typescript offers a streamlined, high-performance solution. This package acts as a thin wrapper around the goja runtime, enabling seamless TypeScript compilation and evaluation without the heavy overhead of CGO or external V8 dependencies. It is built for production-grade reliability, boasting over 90% test coverage and a track record of evaluating over a billion scripts in real-world environments. With built-in support for multiple TypeScript versions (from 3.8.3 up to 4.7.2) and a context-aware API for execution cancellation, it provides the control necessary for building responsive, scalable applications.

The engine driving this capability is, as noted, goja, a pure Go implementation of ECMAScript 5.1. Unlike V8 wrappers that require complex build pipelines and suffer from CGO call overhead, goja is highly portable and easy to build on any platform Go supports. It emphasizes standard compliance, passing nearly all TC39 tests, and is efficient enough to run heavy-duty tools like the Babel and TypeScript compilers. By utilizing goja, go-typescript allows developers to pass complex Go data structures into a JavaScript environment and back again with minimal friction, making it an ideal choice for scripting engines that need to interact deeply with Go logic.

The bit that has my noggin’ stuck on this project/these projects is that the stack is, essentially, specialized handling of modern development patterns within a Go-native environment. For instance, goja handles the heavy lifting of memory management and regex execution, and will fall back to regexp2 when the standard Go library isn’t enough. It also provides robust interrupt mechanisms to stop runaway scripts. This means we can execute untrusted or dynamic TypeScript code with the safety and performance predictability that are hallmarks of idiomatic Go projects.

We’re doing a few things at work that are going to put some services (I cannot say more) in fairly hostile environments, and if this can help make the environments behave realistically without enabling DoS or exploitation, this dynamic duo might be coming in handy next quarter.

---

Hidden Bash Gems

We haven’t Bashed in a while, so here’s a short read that has ten “gems”, some of which (perhaps shopt -s extglob) may definitely be new to some folks.

---

FIN

Remember, you can follow and interact with the full text of The Daily Drop’s free posts on:

• Mastodon via @dailydrop.hrbrmstr.dev@dailydrop.hrbrmstr.dev
• Bluesky via <https://bsky.app/profile/dailydrop.hrbrmstr.dev.web.brid.gy>

☮️