What changed in Go, Rust and Solidity this week.

// This program demonstrates how test artifacts are stored today.
// Since the proposed ArtifactDir method is not yet available in Go 1.27.1,
// tests use a temporary directory created with os.MkdirTemp, which is
// automatically removed when the test finishes.  The program simply
// creates such a directory, prints its path, and deletes it.
package main

import (
	"fmt"
	"os"
)

func main() {
	// Create a temporary directory for test artifacts.
	dir, err := os.MkdirTemp("", "test-artifacts-")
	if err != nil {
		fmt.Println("error creating temp dir:", err)
		return
	}
	// Ensure the directory is removed after use.
	defer os.RemoveAll(dir)

	// Print the directory path so a user can inspect it.
	fmt.Println("Test artifact directory:", dir)
}

// This program demonstrates the new sync.WaitGroup.Go method.
// It prints the numbers 1 through 5 in parallel, each on its own line.
package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	for i := 1; i <= 5; i++ {
		// Capture loop variable to avoid the classic loopvar bug.
		i := i
		// Start a goroutine that prints the number and signals completion.
		wg.Go(func() {
			fmt.Println(i)
		})
	}
	// Wait for all goroutines to finish.
	wg.Wait()
}

// This program demonstrates how to redact a cookie value before sending it to an error
// monitoring service. The crates.io incident showed that sending the raw cookie was a
// security risk. In real life, you would replace the `send_to_sentry` call with the
// actual Sentry SDK integration.

fn main() {
    // Simulated cookie value that would normally be sent to Sentry.
    let cookie = "signed_cookie_value";

    // Redact the cookie before logging the error.
    let redacted_cookie = redact_cookie(cookie);

    // Simulate sending the error event to Sentry.
    send_to_sentry(redacted_cookie);
}

fn redact_cookie(cookie: &str) -> String {
    // Replace the cookie value with a placeholder to avoid leaking user data.
    format!("REDACTED_COOKIE: {}", cookie)
}

fn send_to_sentry(_payload: String) {
    // In a real application, this would send the payload to Sentry.
    // Here we just print it to show the redaction.
    println!("Error event sent to Sentry with payload: {}", _payload);
}

// This program prints the expected greeting on Rust 1.98.1 (edition 2024).
fn main() {
    println!("Hello, Rust 1.86.0!");
}

// This program demonstrates that the March 2025 Project Director update
// has no effect on Rust code. It simply prints a message confirming
// that no new language feature was introduced.

fn main() {
    println!("March 2025 Project Director update: no code impact.");
}

// This program demonstrates that the change is only a community call,
// not a code change. It simply prints a message encouraging participation.
fn main() {
    println!("Rust community, help us shape the future by visiting the vision survey!");
}

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