Rio; You Don’t Know JS; Writing A Container In Rust

It never fails.

When I declare “X is my new daily driver” one or more super cool new shiny objects enters the field of view and threatens to upend stability.

Such is the case with the first and last sections of today’s Drop. Sammich’d betwixt is a great, in-progress book on learning the in’s and out’s of JavaScript.

TL;DR

This is an AI-generated summary of today’s Drop.

• The post begins with a discussion about Rio Terminal, a modern terminal application built with Rust, WebGPU, and Tokio runtime. The terminal is designed to provide the best frame rate experience and supports a wide range of features including true color display, image display within the terminal, adaptive themes, hyperlink support, multi-window support, and navigation. The author also mentions the Alacritty-inspired Vim mode for mouse-free selection and the pending support for WASM plugins.
• The second section introduces the book series “You Don’t Know JS” by Kyle Simpson. The series delves into the intricate details of JavaScript, challenging readers to go beyond a surface-level understanding of the language. The second edition of the series is a complete rewrite, reflecting the evolution of JavaScript since the first edition. The series covers a range of topics from basics to advanced concepts like scope, closures, objects, classes, and types.
• The final section highlights a blog series titled “Writing A Container In Rust” by Litchi Pi. This tutorial provides a detailed guide on how to build a container using Rust, offering hands-on experience with Rust and an understanding of how containers work. The tutorial covers a range of topics from creating the skeleton for the container and preparing inter-process communication (IPC), to setting up user namespaces and restricting the binary running inside the container for system protection.

---

Rio

If you build something and slap the stickers “terminal” and “GPU” on it, it will almost certainly get me to look twice at whatever it is. Such is the case with Rio [Terminal], a modern terminal application that’s built with Rust, WebGPU, and Tokio runtime. It aims to provide the best frame rate experience for as long as you like. I can do this because it’s a hardware-accelerated GPU terminal emulator.

Now, we have WezTerm, which also fits that description. BUT! Rio runs not only on desktops, but is also desgined for browsers (thanks, ofc, to WebAssembly/WASM).

An especially appealing aspect of Rio is top-notch support for “true color,” which means it can display up to 16 million colors (many, many terminal emulators are limited to just 256 colors). It also supports the display of images within the terminal using iTerm2 and kitty image protocols (this is a WIP). Other features include adaptive themes, color automation for navigation, support for hyperlinks, multi-window support, and navigation. Rio also leverages the speed and safety of Rust, along with advanced rendering architectures to ensure fast performance.

I’m especially font of the Alacritty-inspired Vim mode for mouse-free selection, and the pending support for WASM plugins.

I’ve literally just started playing with it, and need to figure out what I’m doing wrong re: font configs (I haven’t had decent rendering luck with ones I really like). Stay tuned for a more in-depth reivew!

You Don’t Know JS

The beginning of a new year offers up the potential for us to pretend to have a demarcation for a “Clean Slate” (pro-tip: you do not need to wait for a calendar event to wipe the slate clean). Might I offer a mantra for said new slate this new year: build/write/create what you want. I know I’ve said that quite a bit in different ways, but I must stress how essential it is to learn and make things that bring you joy and fulfillment first. If it just happens to excite or intrigue others, 👍🏽.

If part of said Clean Slate was to learn or get better at JavaScript, then this middle-section is 100% for you.

“You Don’t Know JS” is a series of books by Kyle Simpson that delve into the nitty-gritty details of JavaScript. They are not your average programming guides, and are designed to challenge your understanding of JavaScript and push you beyond a surface-level grasp of the language.

The second edition of this series is a complete rewrite, addressing the evolution of JavaScript since the first edition. It’s a testament to Kyle’s commitment to keeping the content fresh and relevant, considering the rapid pace at which the language and its ecosystem evolve. The series covers a range of topics from the basics to more advanced concepts like scope, closures, objects, classes, and types.

The new series has lots of pretty spiffy code snippets (with explanations), and the series is also garnering 👀 for its depth and the way it encourages folks to think critically about JavaScript.

The ideal audience is beginner to intermediate, but it covers enough advanced topics that might not be immediately encountered in everyday coding; so, even more experienced folks might attain a more profound understanding of the language.

If you need more convincing to take a dive into JS using this series, it’s sponsored/endorsed by Frontend Masters, a platform that even manages to get Reddit users to give a nod of appreciation to

Writing A Container In Rust

Sure, with my sights set clearly on Go, it figures I’d discover an epic Rust resource that goes in deep on what these “container” things are all about.

Just to cover the bases before continuing, these “container things” (a.k.a. “containers”) are a solution to the problem of software isolation. They let us package an application with all of its dependencies into a single, self-contained unit that can run “anywhere” (as with all things tech, “it’s complicated”). This makes it easier to manage and deploy applications, and it ensures that they run the same way regardless of the environment.

“Writing A Container In Rust” is a blog series by Litchi Pi’s, a “Rust Software engineer, graduated in electronics and embedded systems, with side interests in information security as well.” This tutorial is a detailed guide on how to build a container using Rust (two Rust resources in one day…the Universe is 100% trying to tell me something).

Litchi Pi based the work on “Linux containers in 500 lines of code”, but rewritten in Rust. It’s a spiffy way to get hands-on experience with Rust, plus learn all about how containers work, while building an interesting project. The tutorial is beginner-friendly and doesn’t require prior experience, although having the Rust documentation handy might be useful.

Topics range from creating the skeleton for the container and preparing inter-process communication (IPC), to setting up user namespaces and restricting the binary running inside the container for system protection.

Perhaps I’ll get time in Q2 to poke at this a bit more.

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 ☮️