What changed in Go, Rust and Solidity this week.

// This program demonstrates the new structtag analyzer behavior.
// It defines a struct with a JSON tag that is a single dash ("-").
// When run with `go vet`, the analyzer will report an error for this tag.
// The program itself compiles and runs fine; the error is only in static analysis.

package main

import (
	"encoding/json"
	"fmt"
)

type Example struct {
	Secret string `json:"-"`
}

func main() {
	e := Example{Secret: "hidden"}
	b, _ := json.Marshal(e)
	fmt.Println(string(b)) // prints {}
}

// This program demonstrates the current GOMAXPROCS value.
// The new container‑aware behavior is not yet available in Go 1.27.1,
// so we simply print the value returned by runtime.GOMAXPROCS(0).
package main

import (
	"fmt"
	"runtime"
)

func main() {
	// runtime.GOMAXPROCS(0) returns the current maximum number of CPUs
	// that can execute simultaneously. In a container this is the
	// container's CPU quota if the feature is enabled.
	max := runtime.GOMAXPROCS(0)
	fmt.Printf("GOMAXPROCS: %d\n", max)
}

// This program demonstrates that the `_` placeholder for const generic
// arguments is not available in Rust 1.98.1 (edition 2024).  The compiler
// will reject the use of `_` in a const generic parameter, so we fall back
// to specifying the value explicitly.  The output shows the array that
// would have been produced if the feature were available.

fn all_false<const LEN: usize>() -> [bool; LEN] {
    // In Rust 1.89.0 this could be written as `[false; _]`,
    // but that syntax is not yet supported in 1.98.1.
    [false; LEN]
}

fn main() {
    let a = all_false::<10>();
    let b = all_false::<4>();
    println!("a: {:?}, b: {:?}", a, b);
}

// This program simply prints the announcement of the new Leadership Council representatives.
// The change does not affect Rust code, so we demonstrate the information instead.
fn main() {
    println!("Leadership Council Representative Selections announced for September 2025.");
}

// This program simply prints the names of the tooling updates announced this week.
// It demonstrates that the updates exist, but it does not use any of the new APIs
// because they are not part of the standard library or the Rust compiler.
fn main() {
    println!("Tooling updates:");
    println!("- TangleGuard");
    println!("- redb v3.0.0");
    println!("- wrkflw v0.7.0");
    println!("- serde‑ply");
    println!("- warp v0.4");
}

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