What changed in Go, Rust and Solidity this week.

// This program demonstrates that the standard library still works after the
// security and bug fixes in Go 1.24.8. It uses net/http to fetch a small
// resource from a local server and prints the response body. The code
// compiles and runs on Go 1.27.1, which already includes the 1.24.8 fixes.
package main

import (
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
)

func main() {
	// Set up a simple test server that returns a fixed response.
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, world!")
	}))
	defer ts.Close()

	// Make a GET request to the test server.
	resp, err := http.Get(ts.URL)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	// Read and print the response body.
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Print(string(body))
}

// This program demonstrates that Go 1.25.2 does not introduce new APIs.
// It simply prints a message confirming the absence of changes to the language.
package main

import "fmt"

func main() {
	fmt.Println("go1.25.2 has no new API to showcase.")
}

// This program demonstrates that a 32‑bit Windows target can still be used for the standard library.
// On Rust 1.98.1 (edition 2024) the i686‑pc‑windows‑msvc toolchain is not available, so we cannot
// actually compile for that target here. Instead we show the current behavior on a supported host.

fn main() {
    // The standard library works the same regardless of target.
    println!("Hello from Rust on a supported host!");
    // If you were on a 64‑bit Windows host you could run:
    // `cargo build --target i686-pc-windows-msvc`
    // and the resulting binary would link against the std‑only library for i686.
}

// GCA is not yet in Rust 1.98.1, so we cannot use gca!.
// This example shows the current limitation: we cannot form an array size from a generic parameter inside a const expression.
struct Foo<const N: usize>;

fn make_array<const N: usize>() -> [u8; N] {
    // Works because the const generic is a plain parameter.
    [0; N]
}

// Trying to write something like [u8; T::SIZE] would fail today.
// The following would be a compile error if uncommented:
//
// fn make_from_trait<T: Trait>() -> [u8; T::SIZE] {
//     [0; T::SIZE]
// }
//
// The error would be: generic parameters may not be used in const arguments.
fn main() {
    // Demonstrate the working case.
    let _ = make_array::<5>();
    println!("Array of length 5 created successfully.");
}

fn main() {
    // Demonstrate the current default branch name for the RFC repo.
    // The repository now defaults to `main`. We simply print that fact.
    println!("The Rust RFC repository default branch is now `main`.");
}

// Demonstrates how to run a command with a custom environment variable in Rust 1.98.1.
// This shows the same effect as the pre‑release testing instructions, but using std::process.

use std::process::Command;

fn main() {
    // Build the command: rustup update stable
    let mut cmd = Command::new("rustup");
    cmd.arg("update")
        .arg("stable")
        // Set the custom distribution server for this invocation only.
        .env("RUSTUP_DIST_SERVER", "https://dev-static.rust-lang.org");

    // Execute and capture the output.
    let output = cmd.output().expect("failed to execute rustup");

    // Print whether the command succeeded and its stdout/stderr.
    println!("status: {}", output.status);
    println!("stdout:\n{}", String::from_utf8_lossy(&output.stdout));
    println!("stderr:\n{}", String::from_utf8_lossy(&output.stderr));
}

// 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");
    }
}