What changed in Go, Rust and Solidity this week.

// This program demonstrates the new vet rule: it will fail vet
// if you try to format a pointer with %d. The code compiles
// and runs, but running `go vet` on it will produce an error.
package main

import "fmt"

func main() {
    x := 42
    p := &x
    // The following line would trigger the new vet error:
    // fmt.Printf("%d\n", p)
    // Instead we dereference the pointer to print the value.
    fmt.Printf("%d\n", *p)
}

// This program demonstrates that the RFC link now points to an archived copy.
// Since the change is only in documentation, we simply print the updated URL.
fn main() {
    let archived_url = "https://web.archive.org/web/20260802000000/https://github.com/rust-lang/rfcs/blob/master/text/0344-conventions-galore.md";
    println!("RFC 0344 link now points to: {}", archived_url);
}

// This program demonstrates that the 2026 All‑Hands retrospective
// did not introduce any new Rust language changes. It prints a
// clear message confirming that fact.
fn main() {
    println!("All‑Hands 2026 retrospective: no new Rust language changes.");
}

// This program demonstrates the announcement of cargo‑efmt.
// It simply prints the key fact about the crate.
// No external crates are used, so it compiles on Rust 1.98.1 (edition 2024).

fn main() {
    println!("cargo‑efmt is a drop‑in replacement for cargo fmt that supports .editorconfig files.");
}

// This program demonstrates that Rust 1.98.1 (edition 2024) can compile
// and run a simple binary. The tooling updates mentioned in the source
// (e.g., cargo‑efmt, afrim, SeaORM 2.0) are not part of the standard
// library and therefore do not affect this example.

fn main() {
    // Print a greeting to show the program executed successfully.
    println!("Hello, Rust 1.98.1 (edition 2024)!");
}

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