What changed in Go, Rust and Solidity this week.

package main

import (
	"fmt"
	"strconv"
)

// Compiles on Go 1.27.1. string(i) with an int is the form the new rule
// removes from language version 1.28: it gives the character whose Unicode
// code point is i, never the digits of i.
func main() {
	for _, i := range []int{65, 0x1F600, -1} {
		fmt.Printf("i = %d\n", i)
		fmt.Printf("  string(i)        = %q\n", string(i))       // the form Go 1.28 removes
		fmt.Printf("  string(rune(i))  = %q\n", string(rune(i))) // the same character, said explicitly
		fmt.Printf("  strconv.Itoa(i)  = %q\n", strconv.Itoa(i)) // the digits, if that was meant
	}
}

package main

import (
	"context"
	"fmt"
	"runtime/pprof"
)

// Goroutine labels already exist: pprof.Do sets them, and CPU profiles record
// every sample with the labels of the goroutine that took it. The accepted
// proposal has the testing package set two of them for you, test.name and
// test.iter. This sets the same two by hand and reads them back.
func main() {
	labels := pprof.Labels("test.name", "TestParse", "test.iter", "0")
	pprof.Do(context.Background(), labels, func(ctx context.Context) {
		// Everything run here, and every goroutine started from here,
		// carries the labels in a profile.
		pprof.ForLabels(ctx, func(key, value string) bool {
			fmt.Printf("%s=%s\n", key, value)
			return true
		})
	})
}

package main

import "fmt"

// The Go blog's example for the experimental simd package is an inner
// product. This is the plain loop it vectorizes: one multiply and one add per
// element. With GOEXPERIMENT=simd on Go 1.27, simd.Float32s loads several
// elements at once and MulAdd handles all of them in one step; this sandbox
// builds without that experiment, so it runs the scalar version.
func innerProduct(x, y []float32) float32 {
	var sum float32
	for i := range x {
		sum += x[i] * y[i]
	}
	return sum
}

func main() {
	x := []float32{1, 2, 3, 4, 5, 6, 7, 8}
	y := []float32{8, 7, 6, 5, 4, 3, 2, 1}
	fmt.Println("inner product:", innerProduct(x, y))
}

// The fix in the Rust security advisory: Miri used to write every environment
// variable it saw to target/, where a cached target/ could hand it to a pull
// request. It now keeps only CARGO_* variables (except CARGO_*_TOKEN) and
// OUT_DIR. This applies both rules to the environment of a typical CI step.
fn kept_after_fix(name: &str) -> bool {
    (name.starts_with("CARGO_") && !name.ends_with("_TOKEN")) || name == "OUT_DIR"
}

fn main() {
    let step_env = [
        "CARGO_PKG_NAME",
        "CARGO_TERM_COLOR",
        "CARGO_REGISTRY_TOKEN",
        "OUT_DIR",
        "GITHUB_TOKEN",
        "AWS_SECRET_ACCESS_KEY",
        "PATH",
    ];
    println!("{:<24} {:<18} {}", "variable", "before the fix", "after the fix");
    for name in step_env {
        let after = if kept_after_fix(name) { "written" } else { "not written" };
        println!("{name:<24} {:<18} {after}", "written");
    }
}

// Alejandra González's first Clippy lint warns when ^ is used as if it meant
// "to the power of". In Rust, as in C and Go, ^ is exclusive or (XOR).
fn main() {
    let xor = 2 ^ 3; // 0b10 XOR 0b11 = 0b01
    let power = 2_i32.pow(3); // 2 to the power of 3
    println!("2 ^ 3        = {xor}  (exclusive or: {:#04b} ^ {:#04b} = {:#04b})", 2, 3, xor);
    println!("2_i32.pow(3) = {power}  (the power you meant)");
    println!("10_f64.powi(2) = {}  (floats have powi and powf)", 10_f64.powi(2));
}

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