Aaron Christiansen

@aaronc.cc

Software Engineer in Leeds, UK. Web, Ruby, Rust, and electronics. he/him Cross-posting to Mastodon: @aaronc81@ruby.social

Screenshot of the new Archive page, showing a colour-coded calendar of different puzzle days

Conductor UI. There are filters "Show all previous days, reveal today/tomorrow/future days" and a tools section with "All CRSes to date", "Quick check", and a "re-run routing" button. Underneath is a list of all stations queued up, with buttons to reorder or edit them.

A screenshot of Loconundrum with dark mode activated

Screenshot of the macOS menu bar for Arc, with the "File" menu expanded. There are about 20 options, but only one of them has an icon, "Save Page As", which causes a bizarre-looking intendation for the icons around it.

$#[test] fn test_no_subcommand() { let test_env = TestEnvironment::default(); test_env.run_jj_in(".", ["git", "init", "repo"]).success(); let work_dir = test_env.work_dir("repo"); // Outside of a repo. let output = test_env.run_jj_in(".", [""; 0]); insta::assert_snapshot!(output, @r#" ------- stderr ------- Hint: Use `jj -h` for a list of available commands. Run `jj config set --user ui.default-command log` to disable this message. Error: There is no jj repo in "." [EOF] [exit status: 1] "#);$

Screenshot of the game. There's 01:24 left on the timer. From my hand, I'm playing a Runner Bean, which reads "On Harvest: Enhance this tile's growth rate by 20%." I'm hovering the game grid, which has crops at various stages of growth already, to decide where to plant my Runner Bean.

Your HTML page should have a <link> tag in its <head> with rel="icon", type="image/svg+xml" and with the href containing a link to the SVG file as attributes.

SVG is an XML format and can contain a <style> tag to describes CSS. As with any CSS, it can contain media queries like @media (prefers-color-scheme: dark). This will allow you to toggle the same icon between light and dark system themes.

A side-by-side comparison of SF Symbols and Material Symbols. The SF Symbol icons are named "arrow.clockwise" whereas the material icon is named "Refresh". This is repeated for fullscreen and reply icons.

A particle simulation in a Chrome browser window. Large blobby red and orange particles surround a yellow point, similar to a flame.

A screenshot of the "Leap Motion Control Panel" for Windows

A Windows dialog with this text:

This program can only be installed on versions of Windows designed for the following processor architectures: x64

A macOS camera selector menu listing "Leap Motion Controller" as an option

A screenshot of the "Ultraleap Control Panel" showing my hands with some tracking skeletons overlaid.

The box for a "Leap Motion" controller. It shows the device on the front - a light-grey metal cuboid with a piano-black top. The copy on the front of the box reads "The remarkably accurate, incredibly natural way to interact with your computer."

$A VS Code window with three editors: shapes.rb: class Rectangle export end class Circle export end assertion.rb: export def assert_equal(expected, actual) end canvas_test.rb: import { from 'canvas', :Canvas } import { from 'shapes', :Rectangle, :Circle } import { from 'assertion', :assert_equal }$

$YASCAD code editor, with dark theme. On the left, a Monaco code editor, with file and rendering controls. On the right, an orange cuboid with rounded corners on a grid. The code in the editor is: operator rotate_around_centre(angle) { c = buffer() children(); // Move so that centre is on (0,0), rotate, then move back dx = c.origin.x + c.size.x / 2; dy = c.origin.y + c.size.y / 2; translate([dx, dy]) rotate(angle) translate([-dx, -dy]) copy(c); } // Subtract this from a rect to round its closest corner to the origin module rounded_corner(r) { translate([r, r]) rotate(180) difference() { square(r); circle(r=r); } } module rounded_rect(w, h, r) { difference() { square([w, h]); rounded_corner(r); rotate_around_centre(90) translate([w-r, 0]) rounded_corner(r); rotate_around_centre(180) translate([w-r, h-r]) rounded_corner(r); rotate_around_centre(270) translate([0, h-r]) rounded_corner(r); } } linear_extrude(1) rounded_rect(5, 6, r=1);$

Code editor showing cylinders repeated on a 3x4 grid.

Code:

```
// Repeat the children a certain number of times in the
// X and Y directions to form a grid
operator repeat(xs, ys) {
// Draw the children to a virtual buffer once
t = buffer() children();

for (x = [0:xs-1]) {
for (y = [0:ys-1]) {
// Based on the size of that virtual buffer,
// stamp out copies of the children
translate([t.size.x * x, t.size.y * y]) {
copy(t);
}
}
}
}

repeat(3, 4)
cylinder(5, 5);
```

A code editor showing an STL preview with a small cube on top of another big cube. The code beside is:

```
// Create an object and make a binding for it
big_cube = cube([20, 20, 20]);

// Reference that binding to create another object
translate([0, 0, big_cube.size.y])
cube([5, 5, 5]);
```

The 3D-printed macro pad, now with a thick base plate with a cutout for a USB port, and grey keycaps fitted.

A 3x3 grid of mechanical keyswitches on a black 3D-printed plastic plate, with a blank space above them

$let keys_future = async { loop { let selected = select6( f13_pin.wait_for_high(), f14_pin.wait_for_high(), f15_pin.wait_for_high(), f16_pin.wait_for_high(), f17_pin.wait_for_high(), f18_pin.wait_for_high(), ).await; let code = if selected.is_first() { KEY_F13 } else if selected.is_second() { KEY_F14 } else if selected.is_third() { KEY_F15 } else if selected.is_fourth() { KEY_F16 } else if selected.is_fifth() { KEY_F17 } else if selected.is_sixth() { KEY_F18 } else { panic!() }; info!("Pressing key: {}", code); writer.write_serialize(&KeyboardReport { keycodes: [code, 0, 0, 0, 0, 0], ..KeyboardReport::default() }).await.unwrap(); Timer::after_millis(50).await; writer.write_serialize(&KeyboardReport { keycodes: [0, 0, 0, 0, 0, 0], ..KeyboardReport::default() }).await.unwrap(); } };$

Six Gateron Brown key switches inserted into a black plastic plate, with jumper wires coming out the back

$A helpful error for Rustaceans, C#ers, and friends Gleam has a consistent syntax for constructors at the type and value level, using () for both. It does not use () for value constructors and <> for type constructors, as is common in some other languages. To help folks coming from other languages a set of helpful errors have been added for when they try to use this non-Gleam syntax in their Gleam code. error: Syntax error ┌─ /src/parse/error.gleam:2:12 │ 2 │ type Either<a, b> { │ ^ I was expecting `(` here. Type parameters use lowercase names and are surrounded by parentheses. type Either(a, b) { See: https://tour.gleam.run/data-types/generic-custom-types/ Notice how the error message includes the correct syntax for the specific code that the programmer has written. The programmer could copy/paste the correct version into their code, if they so desired. A link to the documentation is also provided, linking to whichever feature the syntax error is for. Thank you Aaron Christiansen!$

Windows 95 UI mockup.

"Add 3D Printer Wizard"
Windows can print physical objects by sending G-code
to a 3D printer.

This wizard will help you to install your 3D printer.

To begin, select how the printer is connected to your
computer.
The printer is connected using a serial cable.
The printer is connected using a parallel cable.
The printer is connected to another computer on my network.

A screenshot of Apple Photos on iOS showing “Magdalena Bay Concert” as a tag

A screenshot of Echo Point Nova. Looking from a height over a dense forest, surrounded by water, with snowy mountains in the distance. Checkpoint markers are visible as tall blue and orange streaks of light are visible, sprinkled across the world.

Apple Developer documentation for the method “replacingOccurrences(of:with:)”.

Returns a new string in which all occurrences of a target string in the receiver are replaced by another given string.

func replacingOccurrences(
of target: String,
with replacement: String
) -> String

import gleam/io

fn twice(f: fn() -> Nil) {
f()
f()
}

pub fn main() -> Nil {
use <- twice()
io.println("Hello!")
}

// Prints:
// Hello!
// Hello!

$import gleam/io pub fn defer(deferred: fn() -> Nil, body: fn() -> t) -> t { let return_value = body() deferred() return_value } pub fn main() -> Nil { use <- defer(fn() { io.println("All done!") }) io.println("Main function body") } // Prints: // Main function body // All done!$

$import gleam/int import gleam/result fn div(left: Int, right: Int) -> Result(Int, String) { case right { 0 -> Error("divide by zero") _ -> Ok(left / right) } } fn other() -> Result(String, String) { let left = 100 let right = 5 use result <- result.try(div(left, right)) Ok("Your result is: " <> int.to_string(result)) } pub fn main() -> Nil { let _ = other() Nil }$