What changed in Go, Rust and Solidity this week.

// This program demonstrates how to get a random number in [0, n) using the
// current standard library.  The new generic Rand.N method is not yet
// available in Go 1.27.1, so we use rand.Intn and cast the result.
package main

import (
	"fmt"
	"math/rand"
)

func main() {
	const n = 10
	// Seed the default source for reproducibility in this example.
	rand.Seed(42)

	// rand.Intn returns an int in [0, n).  We cast to int32 to show type flexibility.
	x := int32(rand.Intn(n))

	fmt.Printf("Random number in [0, %d): %d\n", n, x)
}

// This program demonstrates that pkix.Name can hold non‑string attribute values.
// It constructs a pkix.Name with an INTEGER attribute and prints the result.
// The code compiles and runs on Go 1.27.1.

package main

import (
	"crypto/x509/pkix"
	"encoding/asn1"
	"fmt"
)

func main() {
	// Create a pkix.Name with an INTEGER attribute (value 123).
	name := pkix.Name{
		CommonName: "example.com",
		ExtraNames: []pkix.AttributeTypeAndValue{
			{
				Type:  asn1.ObjectIdentifier{2, 5, 4, 3}, // OID for commonName
				Value: int64(123),                       // INTEGER value
			},
		},
	}

	// Print the constructed name and the type of the attribute value.
	fmt.Printf("Name: %s\n", name.String())
	fmt.Printf("Attribute value type: %T\n", name.ExtraNames[0].Value)
}

// This program demonstrates a simple PII masking routine.
// The real `cloakrs` crate is not available in this sandbox,
// so we implement a minimal example that masks email addresses
// by replacing the local part with asterisks.

fn mask_email(email: &str) -> String {
    // Split at the first '@' character.
    if let Some(pos) = email.find('@') {
        let (local, domain) = email.split_at(pos);
        // Replace the local part with asterisks of the same length.
        let masked_local = "*".repeat(local.len());
        format!("{}{}", masked_local, domain)
    } else {
        // Not an email, return unchanged.
        email.to_string()
    }
}

fn main() {
    let examples = [
        "[email protected]",
        "[email protected]",
        "no-at-symbol",
    ];

    for e in &examples {
        println!("{} -> {}", e, mask_email(e));
    }
}

// This program demonstrates the concept of a portable Rust runtime for distributed apps.
// The actual `numax` crate is not yet available in Rust 1.98.1 (edition 2024),
// so we simply print a placeholder message.

fn main() {
    println!("Numax is a portable Rust runtime for distributed apps");
}

// This program demonstrates that Entroly 0.18.0 is a crate that exists in the
// Rust ecosystem, but it is not part of the standard library and therefore
// cannot be used directly in this sandbox.  The code below simply prints a
// message indicating the crate's presence in the registry.

fn main() {
    println!("Entroly 0.18.0 is available as a crate, but this sandbox cannot fetch it.");
}

// This program simply prints the dates of RustWeek and the All‑Hands
// as announced in the April 2026 program‑management update.
fn main() {
    println!("RustWeek starts on 18 May 2026");
    println!("All‑Hands follows immediately after");
}

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