Rust content

    • Write a simple netcat client and server in Rust

      A guide on how to a simple Rust netcat client and server
    • Write a simple TCP chat server in Rust

      A guide on how to create write a simple TCP chat server in Rust using Tokio
    • tuify your clap CLI apps and make them more interactive

      A guide on how to add minimal interactivity to your clap CLI apps using tuify. It doesn't have to be an all or nothing approach w/ going full TUI or CLI.
    • Use just to manage project specific commands

      A guide on how to create just files (which are like make files) to manage project specific commands. In a cross platform way.
    • Create End-to-End Channels in Rust with Ockam Routing

      A guide on how to use Ockam Routing, using the Rust library, to secure your apps by building end-to-end channels. It is to get us thinking about security when building apps and consider the "who and where" for the data that is sent and received by our apps.
    • Guide to parsing with nom

      This tutorial is a guide to parsing with nom. It covers the basics of parsing and how to use nom to parse a string into a data structure. We will cover a variety of different examples ranging from parsing simple CSS like syntax to a full blown Markdown parser.
    • Create a simple DSL for CSS like syntax for TUIs

      Procedural macros are a way for you to extend the Rust compiler and provide plugins that you can use to extend the language. They allow to create your own DSL (domain specific language). This article goes into the details of creating a simple DSL to mimic CSS syntax but in Rust, for a TUI app framework.
    • Guide to Rust procedural macros

      Procedural macros are a way for you to extend the Rust compiler and provide plugins that you can use to extend the language. They allow you to reduce the need to write manual boilerplate code, and even allow you to create your own DSL (domain specific language). This article goes into the details of creating the 3 kinds of procedural macros in Rust.
    • Write a Redux library in Rust

      This article illustrates how we can build a Redux library in Rust. This library is thread safe and asynchronous (using Tokio). The middleware and subscribers will be run in parallel. But the reducer functions will be run in sequence.
    • Write code using async/await in Rust

      This article illustrates how to write concurrent and parallel code in Rust using Tokio. The pedagogical example we will use is building an asynchronous implementation of a middleware runner that you might find in a Redux store.
    • Build a grep CLI app in Rust

      This article illustrates how we can build a CLI app in Rust that is a very basic implementation of grep. This app will have 2 modes of operation: piping lines in from `stdin` and searching them, and reading a file and searching thru it. The output of the program will be lines that match the search term w/ the term being highlighted. Topics like `stdin` manipulation in a terminal, detecting when the terminal is in `tty` mode vs `piped` mode, doing simple file I/O, creating non consuming builders, and managing `Result`s, along w/ building a simple CLI interface are covered in this article.
    • Build a non-binary tree that is thread safe using Rust

      This article illustrates how we can build a non-binary tree in Rust using various approaches until we end up with a version that is thread safe and supports parallel tree walking as well. Topics like interior mutability, sharing ownership, weak and strong references, custom traits for polymorphic behavior, are covered in this article.

    Subscribe to RSS feed