What changed in Go, Rust and Solidity this week.

package main

import (
	"fmt"
	"time"
)

// This program demonstrates a simple time‑based operation that works
// in Go 1.27.1. It prints the current time, waits one second, and
// then prints the elapsed time.
func main() {
	start := time.Now()
	fmt.Println("Start time:", start)

	// Pause for one second.
	time.Sleep(1 * time.Second)

	elapsed := time.Since(start)
	fmt.Println("Elapsed time:", elapsed)
}

// This program demonstrates the current error handling style in Go.
// It parses two strings as integers, prints their sum, and returns an error if parsing fails.
package main

import (
	"fmt"
	"strconv"
)

func printSum(a, b string) error {
	x, err := strconv.Atoi(a)
	if err != nil {
		return err
	}
	y, err := strconv.Atoi(b)
	if err != nil {
		return err
	}
	fmt.Println("result:", x+y)
	return nil
}

func main() {
	if err := printSum("10", "20"); err != nil {
		fmt.Println("error:", err)
	}
}

// This program demonstrates the bootstrap change.
// It simply prints a message; the change itself affects the build system,
// not runtime behavior, so we just show a placeholder.
fn main() {
    println!("Bootstrap redesign is now in effect.");
}

// This program simply prints a message about the new Compiler Ops team.
// The change is organizational, not a language feature, so the code is
// unchanged from any previous Rust version.

fn main() {
    println!("The Rust Compiler Team now has an Operations group to keep things running smoothly.");
}

// This program demonstrates that the mdbook dependency update is not part of the Rust
// standard library.  It simply prints a message indicating the updated version.
// The mdbook crate is not available in the sandbox, so we cannot import it here.

fn main() {
    // In a real project, you would update Cargo.toml to use mdbook = "0.4.51"
    // and then run `mdbook serve` to see the fixed S‑key behavior.
    println!("mdbook has been updated to 0.4.51, fixing the S search hotkey regression.");
}

// This program demonstrates how you might add structured context to logs
// using only the standard library, since the `context_logger` crate is not
// available in Rust 1.98.1 (edition 2024). It prints a simple log line
// with key/value pairs to illustrate the idea.

fn main() {
    // Define some context data
    let user = "alice";
    let action = "login";

    // Build a log message with structured context
    let log = format!("INFO: user={} action={}", user, action);

    // Output the log
    println!("{}", log);
}

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