What changed in Go, Rust and Solidity this week.

// This program demonstrates that the new Auxv API is not available in Go 1.27.1.
// It simply prints a message explaining the situation.
package main

import "fmt"

func main() {
	// In Go 1.27.1 the golang.org/x/sys/unix package does not provide an Auxv function.
	// The proposal to add Auxv() is still pending and will not compile until the change ships.
	fmt.Println("Auxv() is not available in Go 1.27.1; the proposal is pending.")
}

// This program demonstrates the sync.WaitGroup misuse that the vet tool
// now flags. The pattern is:
//   go func() { wg.Add(1); defer wg.Done() }()
// The Add happens after the goroutine starts, which can race with wg.Wait
// and may cause the program to exit before the goroutine finishes.
package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup
	// Defer Wait so the main goroutine waits for all workers.
	defer wg.Wait()

	// Start a goroutine that adds to the WaitGroup after it has begun.
	go func() {
		// Add is called after the goroutine has already started.
		wg.Add(1)
		defer wg.Done()
		// Simulate work.
		time.Sleep(100 * time.Millisecond)
		fmt.Println("Worker finished")
	}()

	// Sleep briefly to allow the goroutine to start before main exits.
	time.Sleep(10 * time.Millisecond)
	fmt.Println("Main exiting")
}

// This program demonstrates that the crate of the week is `resvg`.
// It does not compile because `resvg` is not part of the standard library
// and would require adding an external dependency in Cargo.toml.
// The code below is a placeholder to illustrate the concept.

fn main() {
    println!("This Week in Rust 583: Crate of the week is `resvg`, an SVG rendering library.");
}

// This program demonstrates that the `musi lili` crate has a new release
// (0.2) available.  The crate is not part of the standard library, so we
// simply print a message.  In a real project you would add it to Cargo.toml
// and use its public API.

fn main() {
    println!("musi lili 0.2 is now released.");
}

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