Rust Evolve

Two decades ago, I wrote the book Advanced Java Game Programming which taught readers how to make animated 2D games that would run in a webpage.  Now I am learning how to do that using Rust and WebAssembly.  Evolve is an animated interactive evolutionary algorithm simulation that you can play with that I recently converted from Java to Rust.  The code is available from my open source repository.

Using the rust-webpack-template

Using the rust-webpack-template is a checklist that I made for setting up projects that use Rust and WebAssembly instead of JavaScript to dynamically create webpage content.  Since rust-webpack-template has not been updated for a few years, the checklist includes steps for dealing with outdated dependencies.  It also includes starter code and an extensive list of related links.

Into ZAMs

Previously I wrote about using Zero Arguments Methods (ZAMs) as a work-around for the Rust programming language not yet supporting named arguments.  Here I show how an Into trait implementation can be used as a ZAM.  I start from a conventional unnamed arguments function that I gradually convert into an Into ZAM.

Start with an output structure for your calculation:

pub struct RotationMatrix {
  pub rows: [[f64; 3]; 3],
}

Make an associated function that takes in a number of unnamed arguments, performs the calculations, and then returns the result as the output structure.

let rotation_matrix: RotationMatrix
  = RotationMatrix::from_degrees(-45.0, 90.0, 135.0);

Next, to support named arguments, modify your associated function to accept an input structure as the sole argument:

pub struct RotationDegrees {
  pub x: f64,
  pub y: f64,
  pub z: f64,
}

let rotation_matrix: RotationMatrix
  = RotationMatrix::from_degrees(
    RotationDegrees {
      x: -45.0,
      y: 90.0,
      z: 135.0,
    });

To make a ZAM, you could move the calculation code from an associated function on the output structure to a method on the input structure:

let rotation_degrees = RotationDegrees {
  x: -45.0,
  y: 90.0,
  z: 135.0,
};

let rotation_matrix: RotationMatrix
  = rotation_degrees.to_rotation_matrix();

Instead, however, move the calculation code to a From trait implementation:

impl From<RotationDegrees> for RotationMatrix {
  fn from(rotation_degrees: RotationDegrees) -> Self {
    // [...]
  }
}

let rotation_matrix: RotationMatrix
  = RotationMatrix::from(rotation_degrees);

Implementing the From trait automatically implements the Into trait which now serves as your ZAM:

let rotation_matrix: RotationMatrix
  = rotation_degrees.into();

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.