What changed in Go, Rust and Solidity this week.

// This program demonstrates adding a String method to an existing type.
// The change is already in Go 1.27.1, so it compiles and runs as is.
package main

import (
	"fmt"
)

type Thing struct {
	Name string
	Age  int
}

// String returns a human‑readable representation of Thing suitable for debugging.
func (t Thing) String() string {
	return fmt.Sprintf("Thing{Name:%q, Age:%d}", t.Name, t.Age)
}

func main() {
	t := Thing{Name: "Gopher", Age: 3}
	// fmt.Println uses the String method automatically.
	fmt.Println(t)
}

// This program demonstrates how to iterate over all command‑line flags
// using the current Go 1.27.1 flag package. The proposed All() iterator
// and Flag.IsSet field are not yet available, so we use VisitAll instead.
package main

import (
	"flag"
	"fmt"
)

func main() {
	// Define a couple of flags for demonstration.
	var name string
	var age int
	flag.StringVar(&name, "name", "world", "your name")
	flag.IntVar(&age, "age", 0, "your age")

	// Parse the command line arguments.
	flag.Parse()

	// VisitAll walks over all defined flags, regardless of whether they
	// were set on the command line. The callback receives a *flag.Flag.
	flag.VisitAll(func(f *flag.Flag) {
		fmt.Printf("flag: --%s, value: %s, default: %s\n",
			f.Name, f.Value.String(), f.DefValue)
	})
}

// This program demonstrates the drag‑and‑drop feature that will be available
// once the winit change ships.  Since the current Rust 1.98.1 release does not
// include the new API, the program simply prints a message explaining the
// intended usage.

fn main() {
    println!("winit now exposes comprehensive drag‑and‑drop support across platforms.");
    println!("Once the change is available, you can create a window and register a drop handler like this:");
    println!("    let window = WindowBuilder::new().build(&event_loop).unwrap();");
    println!("    window.set_drag_and_drop(true);");
    println!("    // Handle DropEvent in the event loop.");
}

// This program demonstrates the problem that Topcoat aims to solve: building
// full‑stack reactive web apps in Rust. Since Topcoat is not yet available
// in Rust 1.98.1, we simply print a message explaining that the framework
// is announced but not yet usable.

fn main() {
    println!("Topcoat is a new framework for full‑stack reactive web apps in Rust, announced in This Week in Rust 661, but it is not yet part of the stable Rust distribution.");
}

// This program demonstrates the idea of readiness gates and cert recycling
// in the kobe crate.  The kobe crate is not part of the standard library,
// so this code will compile only once kobe 0.35.0 is available in the
// dependency graph.  Until then, it simply prints a placeholder message.

fn main() {
    println!("Readiness gates and cert recycling are features of kobe 0.35.0.");
}

// This program demonstrates the problem that Comhad solves: navigating S3 in a terminal.
// It does not compile until the Comhad crate is available, so we show a placeholder.

fn main() {
    // In a real program you would call comhad::run("my-bucket")?;
    println!("Comhad 0.1.0 provides a ranger‑style TUI for S3, but the crate is not yet in the standard library.");
}

// This program simply announces the release of RustRover 2026.2.
// It runs on Rust 1.98.1 (edition 2024) and prints the expected message.
fn main() {
    println!("RustRover 2026.2 has been announced.");
}

// This program demonstrates the announcement of the Xan crate of the week.
// Xan is a TUI toolkit for CSV files, but the crate is not available in Rust 1.98.1,
// so we simply print a message to show the change.

fn main() {
    println!("Xan: a TUI toolkit to work with CSV files");
}

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