What changed in Go, Rust and Solidity this week.

package main

import "fmt"

// This program demonstrates how you would add two float32 slices
// without the experimental archsimd package, which is not available
// in Go 1.27.1.  It uses a plain loop as a fallback.

func addFloat32(a, b []float32) []float32 {
	if len(a) != len(b) {
		panic("slice length mismatch")
	}
	out := make([]float32, len(a))
	for i := range a {
		out[i] = a[i] + b[i]
	}
	return out
}

func main() {
	x := []float32{1.0, 2.0, 3.0, 4.0}
	y := []float32{5.0, 6.0, 7.0, 8.0}
	z := addFloat32(x, y)
	fmt.Println("result:", z) // prints [6 8 10 12]
}

package main

import (
	"debug/pe"
	"fmt"
)

func main() {
	// In Go 1.27.1 the type `pe.ImportDirectory` still exists but is marked deprecated.
	// This program creates a zero value of that type and prints it to show the API is usable.
	var dir pe.ImportDirectory
	fmt.Printf("zero ImportDirectory value: %+v\n", dir)
}

package main

import (
	"fmt"
	"os"
)

func main() {
	// In Go 1.27.1 the cgobindings GOEXPERIMENT does not exist.
	// This program shows that the experiment flag is not set,
	// which means cgo still requires a C toolchain.
	if exp := os.Getenv("GOEXPERIMENT"); exp == "" {
		fmt.Println("GOEXPERIMENT is empty – cgobindings is not available")
	} else {
		fmt.Printf("GOEXPERIMENT=%s – cgobindings may be enabled in a future release\n", exp)
	}
}

// This program demonstrates a simple retry loop that mimics the
// robustness added to Cargo's HTTP client in Rust 1.96.1.
// It attempts to fetch a URL, retrying up to 3 times on failure.
// The output shows the number of attempts and whether it succeeded.

use std::time::Duration;
use std::thread::sleep;
use std::io::ErrorKind;

fn main() {
    let url = "https://example.com";
    let max_attempts = 3;
    let mut attempt = 0;

    loop {
        attempt += 1;
        println!("Attempt {}: fetching {}", attempt, url);

        // Simulate a network request that fails the first two times.
        let result: Result<(), std::io::Error> = if attempt < 3 {
            Err(std::io::Error::new(ErrorKind::TimedOut, "simulated timeout"))
        } else {
            Ok(())
        };

        match result {
            Ok(_) => {
                println!("Success on attempt {}", attempt);
                break;
            }
            Err(e) => {
                println!("Error: {}", e);
                if attempt >= max_attempts {
                    println!("Reached maximum attempts, giving up.");
                    break;
                } else {
                    println!("Retrying after delay...");
                    sleep(Duration::from_millis(500));
                }
            }
        }
    }
}

// This program demonstrates the new implicit‑install behavior of rustup
// in the 1.30 release cycle.  It does not interact with rustup itself,
// but prints the expected error message that a user would see if
// a toolchain is missing and implicit install is disabled.

fn main() {
    // In a real scenario, running `rustup +beta target remove ...`
    // when the beta toolchain is not installed would produce:
    println!("error: toolchain 'beta-aarch64-unknown-linux-musl' is not installed");
}

// This program demonstrates that Slint 1.17 is a GUI toolkit crate.
// It does not compile because Slint is not part of the standard library
// and the sandbox has no external dependencies.  The code below
// simply prints a message explaining the purpose of Slint.

fn main() {
    println!("Slint 1.17 is a GUI toolkit for Rust.  It lets you build desktop UIs by describing them in .slint files and binding them to Rust code.");
}

// This program is unrelated to the GitHub Actions change.
// It simply demonstrates that the Rust compiler is functioning.
fn main() {
    println!("Rust 1.98.1 (edition 2024) is running.");
}

// This program demonstrates the issue that the v6.0.3 update fixes.
// In a real CI workflow, the actions/checkout action would initialize
// a repository that uses the SHA‑256 hash algorithm.  The old
// implementation would fail to set up the repository correctly.
// Here we simply print a message to illustrate the problem that
// the update resolves.

fn main() {
    println!("If you run actions/checkout v6.0.2 on a SHA‑256 repo, it may fail to init.");
    println!("Upgrading to v6.0.3 fixes that initialization bug and expands merge‑commit SHA matching.");
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates that delete on a memory bytes array element
// clears only the targeted byte, not the whole 32‑byte word.
contract Main {
    function clearByte(uint index) external pure returns (bytes memory) {
        bytes memory data = new bytes(5);
        // set all bytes to 0xFF for visibility
        for (uint i = 0; i < data.length; i++) {
            data[i] = 0xFF;
        }
        // delete the element at `index`
        delete data[index];
        return data;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

import "./main.sol";

contract MainTest {
    Main main;

    constructor() {
        main = new Main();
    }

    function test_singleByteCleared() public {
        bytes memory result = main.clearByte(2);
        // bytes[2] should be 0x00, others remain 0xFF
        require(result[2] == 0x00, "byte not cleared");
        require(result[0] == 0xFF, "other byte altered");
        require(result[1] == 0xFF, "other byte altered");
        require(result[3] == 0xFF, "other byte altered");
        require(result[4] == 0xFF, "other byte altered");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// This contract demonstrates the 0.8.37 delete‑byte‑array‑element fix.
// It creates a memory bytes array, sets each element to 0x01,
// deletes the middle element, and returns the array.
contract Demo {
    function deleteMiddle() external pure returns (bytes memory) {
        bytes memory b = new bytes(3);
        b[0] = 0x01;
        b[1] = 0x01;
        b[2] = 0x01;
        delete b[1]; // only b[1] should become 0x00
        return b;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;
import "./main.sol";

contract DemoTest {
    Demo demo;

    constructor() {
        demo = new Demo();
    }

    function test_deleteLeavesOtherBytes() external {
        bytes memory result = demo.deleteMiddle();
        require(result.length == 3, "wrong length");
        require(result[0] == 0x01, "b[0] altered");
        require(result[1] == 0x00, "b[1] not zeroed");
        require(result[2] == 0x01, "b[2] altered");
    }
}