What changed in Go, Rust and Solidity this week.

// This program demonstrates how to collect a goroutine leak profile
// using the experimental flag.  It does not compile in Go 1.27.1
// because the flag is not yet implemented.  Run it with
// GOEXPERIMENT=goroutineleakprofile ./prog to see the effect.

package main

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

func main() {
	// Create a file to store the leak profile.
	f, err := os.Create("goroutineleak.pprof")
	if err != nil {
		fmt.Println("error creating file:", err)
		return
	}
	defer f.Close()

	// Lookup the leak profile by name.
	prof := pprof.Lookup("goroutineleak")
	if prof == nil {
		fmt.Println("goroutineleak profile not available")
		return
	}

	// Write the profile data to the file.
	if err := prof.WriteTo(f, 1); err != nil {
		fmt.Println("error writing profile:", err)
		return
	}

	fmt.Println("goroutine leak profile written to goroutineleak.pprof")
}

// This program demonstrates the new HelloRetryRequest field in
// crypto/tls.ConnectionState and crypto/tls.ClientHelloInfo.
// The field is available in Go 1.27.1, so we can create a dummy
// ConnectionState value and inspect it. No network activity is
// performed, keeping the program fast and self‑contained.

package main

import (
	"crypto/tls"
	"fmt"
)

func main() {
	// Construct a ConnectionState with HelloRetryRequest set to true.
	// In a real TLS handshake this value would be set by the
	// crypto/tls package to indicate that an HRR was performed.
	cs := tls.ConnectionState{
		HelloRetryRequest: true,
	}

	// Construct a ClientHelloInfo with HelloRetryRequest set to true.
	// This would be set when the client sends a ClientHello in
	// response to a server's Hello Retry Request.
	ch := tls.ClientHelloInfo{
		HelloRetryRequest: true,
	}

	// Print the values to show that the fields exist and can be read.
	fmt.Printf("ConnectionState.HelloRetryRequest: %v\n", cs.HelloRetryRequest)
	fmt.Printf("ClientHelloInfo.HelloRetryRequest: %v\n", ch.HelloRetryRequest)
}

// This program demonstrates the runner version requirement for actions/checkout v5.
// It simply prints a message; the real change is in the GitHub Actions runner,
// not in Rust code, so we just illustrate the concept here.

fn main() {
    println!("If you run GitHub Actions with actions/[email protected], ensure your runner is at least v2.327.1.");
}

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