What changed in Go, Rust and Solidity this week.

// This program demonstrates that the GODEBUG flags `gotypesalias` and
// `asynctimerchan` are no longer available in Go 1.27.1. The debug package
// no longer exposes SetDebugFlags or Flags for these flags, so we simply
// print a message confirming their absence.

package main

import "fmt"

func main() {
	fmt.Println("The GODEBUG flags `gotypesalias` and `asynctimerchan` have been removed in Go 1.27.1.")
}

// This program runs on Go 1.27.1.  
// It demonstrates that generic methods are not yet supported: attempting to
// declare a method with type parameters would produce a compile‑time error.
// Instead we simply print a message explaining the current limitation.

package main

import "fmt"

func main() {
	// In Go 1.27.1 a declaration like
	//   func (s S) m[T any](x T) {}
	// would fail to compile with "generic methods are not allowed".
	// Since the feature is not yet shipped, we show the current state.
	fmt.Println("Generic methods are not supported in Go 1.27.1")
}

// This program demonstrates the problem that the new crates.io username concept
// solves: two users with the same GitHub name cannot both use that name on crates.io.
// Since the change is not yet in the current Rust release, we simply illustrate
// the issue with a mock example.

fn main() {
    // Two users with the same GitHub username "alice"
    let github_user_a = "alice";
    let github_user_b = "alice";

    // On crates.io before the change, both would collide
    if github_user_a == github_user_b {
        println!("Collision: both users would have the same crates.io name.");
    } else {
        println!("No collision.");
    }

    // After the change, each can choose a distinct crates.io username
    let crates_io_username_a = "alice_dev";
    let crates_io_username_b = "alice_prod";

    if crates_io_username_a != crates_io_username_b {
        println!("No collision after username decoupling: {} vs {}", crates_io_username_a, crates_io_username_b);
    }
}

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