What changed in Go, Rust and Solidity this week.

// This program demonstrates that the os/exec package works as expected
// after the 1.24.7 release. It runs the "echo" command and prints its output.
package main

import (
	"fmt"
	"os/exec"
)

func main() {
	// Create a command that prints "Hello, world!".
	cmd := exec.Command("echo", "Hello, world!")
	// Run the command and capture its combined output.
	out, err := cmd.CombinedOutput()
	if err != nil {
		fmt.Println("Command failed:", err)
		return
	}
	// Print the output to standard output.
	fmt.Print(string(out))
}

// This program demonstrates that the `-C linker-features=-lld` flag is
// accepted by the compiler.  In Rust 1.90.0 stable on Linux the default
// linker will be `rust‑lld`, but that is not yet the case in Rust 1.98.1
// (edition 2024).  The flag can be used to revert to the system linker
// if needed.  Running this program prints a confirmation message.

fn main() {
    println!("Linker feature flag `-C linker-features=-lld` is accepted.");
}

// This program demonstrates applying a bsdiff patch with the aehobak crate.
// The crate is not part of the standard library, so we use a minimal
// implementation that mimics the patch application logic.
// Since the real crate is not available in this sandbox, we show a
// placeholder that prints the intended behavior.

fn main() {
    // Normally you would load a patch file and an original file.
    // Here we just illustrate the call sequence.
    println!("Applying bsdiff patch using aehobak (placeholder).");
    // In real code:
    // let patch = aehobak::Patch::from_file("update.patch").unwrap();
    // let original = std::fs::read("original.bin").unwrap();
    // let updated = patch.apply(&original).unwrap();
    // std::fs::write("updated.bin", updated).unwrap();
}

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