Rust Podcast List

Previously I wrote about how I have been enjoying listening to Rust programming language podcasts.  Since then, I have discovered three more Rust podcasts for a total of six.  Today I updated my list of all Rust podcasts on the CroftSoft Links webpage.

Sycamore Prototype

Today I launched a new open source project, the CroftSoft Sycamore Prototype.  This is a conversion of one of my old Angular-based CSS Grid Layout demonstrations to the Rust-based front-end framework Sycamore.  My portfolio page has a link to a demonstration of the in-progress prototype.

Previously I was focusing on the far more popular Yew framework but according to this comparisons webpage on the Perseus website, Yew does not support static site generation (SSG) and server side rendering (SSR).  Perseus appears to be a framework layered on top of Sycamore which does support SSG and SSR.  Besides Sycamore / Perseus, another framework that I am considering is Dioxus.

Rust Project Setup

I started a new tutorial webpage providing a Rust Project Setup checklist. In addition to project directory creation and customization, it includes preliminary development steps such as tool installation. I am going to be adding to this over time as I use it.

 

Rust Podcasts

I have enjoyed listening to the Rust programming language podcast Rustacean Station. I like this podcast because it is not always the same host speaking. Now that I am all caught up with all eighty-eight episodes published to date, I searched for a different Rust podcast to listen to while I wait for the next episode to come out.

Fortunately one of the more recent episodes of Rustacean Station is an interview with the former host of the now defunct podcast New Rustacean with one hundred and three episodes available. I listened to the first episode tonight and it sounds like I am in for a high quality experience. I have also sampled the start of the first of nine episodes of the podcast Rust Game Dev.

Zero Arguments Methods

In my book Advanced Java Game Programming, I have a sidebar recommending named notation as a work-around for the Java programming language not supporting named arguments.  Here is the example from the book as converted to the Rust programming language:

let game_data = SerializableGameData::new(
  10,  // health
  99,  // wealth
  18); // wisdom

There is a proposal to bring named arguments to Rust but until this proposal is adopted I have started using a new work-around which I am calling "zero arguments methods".  Here is a static function to be converted:

pub fn periodic_savings_needed(
  f: f64,
  r: f64,
  t: f64,
) -> f64 {
  f * r / ((1.0 + r).powf(t) - 1.0)
}

Here is the equivalent using a zero arguments method:

#[derive(Clone, Copy, Debug)]
pub struct PeriodicSavingsNeeded {
  pub future_value: f64,
  pub interest_rate: f64,
  pub time_periods: f64,
}

impl PeriodicSavingsNeeded {
  pub fn calculate(&self) -> f64 {
    let f = self.future_value;
    let r = self.interest_rate;
    let t = self.time_periods;
    f * r / ((1.0 + r).powf(t) - 1.0)
  }
}

Here is how the zero arguments method can be called:

let calculated_value = PeriodicSavingsNeeded {
  future_value:  1_000_000.0,
  interest_rate: 0.12,
  time_periods:  10.0,
}.calculate();

 

First Published Crate

Today I published my first Rust crate to crates.io.  Crate com-croftsoft-core is an adaption to Rust of the Java-based CroftSoft Core Library.  After publishing this crate, I was able to use it as a dependency in my Yew-based retirement calculator.

The crate only has a single financial calculation function and a few constants right now.  I hope to eventually expand it to include most of the code from the CroftSoft Core Library.  Converting my old Java code library is another way for me to learn the Rust programming language.

Rust, WebSockets, and Yew

Almost two decades ago when I wrote my book Advanced Java Game Programming, I ended it with three chapters on the subject of multiplayer network communications over Hypertext Transfer Protocol (HTTP).  The final chapter demonstrated a browser-based chat applet in which 2D characters would move about in response to player clicks on the screen.  I described how to use what I called "HTTP Pulling", now known as HTTP Long Polling, to receive messages from the server through the firewall.

The modern replacement for HTTP Long Polling is WebSockets which is now supported in all major browsers.  Last weekend I was able to write my first browser-based application in the Rust programming language by using the Rust-based front-end framework Yew.  Today I was pleased to be able to successfully implement a browser-based chat application using WebSockets and Yew by following the instructions in the online tutorial Let’s Build a WebSockets Project With Rust and Yew 0.19 by Johnny Tordgeman.

 

The Rust Book

Tonight I finished reading The Rust Programming Language, informally known as "The Rust Book", by Steve Klabnik and Carol Nichols with contributions from the Rust Community.  The print copy published by No Starch Press covers the 2018 Edition of Rust.  There is also a free online version which is updated continuously.

I had started reading the Rust book last year and made it three-quarters of the way through.  This year I restarted from the beginning so I could refresh on the fundamentals.  It helped me understand a couple of Rust game programming books that I was reading simultaneously.

The book is well written with many code examples which are described in detail.  The authors ease the readers into the subject but then rapidly advance to more complicated topics in later chapters.  I assume that this is because they wanted to cover the entire programming language in just over five hundred pages.

I searched the Web to see if there is a second edition of the book coming out that covers the 2021 Edition of the Rust programming language.  Apparently there is not so I might start reading the online version for the updates and to review the material.  To help take me to the next level, I ordered from the same publisher Rust for Rustaceans: Idiomatic Programming for Experienced Developers by Jon Gjengset.

Retirement Calculator

Back in 1999 when the stock market was doing well, I wrote a browser-based retirement calculator application using the Java Servlet framework.  Since a Java Servlet renders the Hypertext Markup Language (HTML) server-side, the application stopped working when I stopped using the Java application server.  Since the application does not fetch or store data using a back-end server, I could have re-written the calculator as a JavaScript-based application and simply hosted it on a website fronted by a Content Delivery Network (CDN).

Now in 2022 when the stock market is not doing so well, I converted the application to my new favorite programming language Rust using the front-end framework Yew.  Yew compiles the Rust code to WebAssembly (Wasm) which then runs in the browser just like JavaScript.  You can view the converted source code and play with an online demonstration hosted on one of my websites deployed using Amazon Web Services (AWS) Amplify Hosting.