Saturday, January 14, 2023

Rust Life

I implemented Conway's Game of Life in the Rust programming language and compiled it to WebAssembly (Wasm) so that it runs in a webpage.  I initialized the project directory using the steps from Rust-webpack Project Setup checklist and re-used code from my animated interactive Evolve simulation.


Monday, January 02, 2023

Rust-webpack Project Setup

As part of capturing my lessons learned from converting CroftSoft Evolve from a Java applet to a Rust-WebAssembly application, I started writing a Rust-webpack Project Setup tutorial checklist.  There is enough there now to get the "Hello, World!" example code running that I created for my now obsolete rust-webpack-template tutorial.


Wednesday, December 21, 2022

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 WebAssemblyEvolve 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.


Thursday, November 24, 2022

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.


Monday, October 03, 2022

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();

Saturday, September 17, 2022

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.

Saturday, August 13, 2022

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.
 

Friday, August 12, 2022

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.