What changed in Go, Rust and Solidity this week.

// This program demonstrates that html/template renders a string safely.
// The security fixes in Go 1.26.1 are already in effect in Go 1.27.1.
package main

import (
	"html/template"
	"os"
)

func main() {
	// A simple template that includes user data.
	tmpl, err := template.New("demo").Parse(`Hello, {{.Name}}!`)
	if err != nil {
		panic(err)
	}
	// Render the template with a sample data structure.
	if err := tmpl.Execute(os.Stdout, map[string]string{"Name": "Alice"}); err != nil {
		panic(err)
	}
}

// This program demonstrates that html/template still renders a template
// and that the security fixes are in place.  It does not rely on any
// new API introduced in 1.25.8; the changes are internal to the package.
package main

import (
	"html/template"
	"os"
)

func main() {
	// A simple template that prints a user‑supplied value.
	tmpl, err := template.New("demo").Parse("Hello, {{.Name}}!")
	if err != nil {
		panic(err)
	}

	// Render the template with a sample data structure.
	err = tmpl.Execute(os.Stdout, map[string]string{"Name": "World"})
	if err != nil {
		panic(err)
	}
}

// This program demonstrates the new `array_windows` method introduced in Rust 1.94.0.
// It searches a string for the ABBA pattern described in the release notes.

fn has_abba(s: &str) -> bool {
    // Convert the string to bytes and iterate over 4‑element windows.
    // The compiler infers the window size from the pattern `[a1, b1, b2, a2]`.
    s.as_bytes()
        .array_windows()
        .any(|[a1, b1, b2, a2]| (a1 != b1) && (a1 == a2) && (b1 == b2))
}

fn main() {
    let examples = ["xyyx", "abba", "abcd", "xyyxz"];
    for ex in &examples {
        println!("{} -> {}", ex, has_abba(ex));
    }
}

// This program simply prints the headline of the 2025 State of Rust Survey results.
// The change is a blog post, not a language feature, so we just demonstrate the
// information that was published.

fn main() {
    println!("2025 State of Rust Survey Results – published March 2 2026");
}

// This program demonstrates the office2pdf crate of the week.
// It simply prints a message; the crate itself is not used here.
fn main() {
    // The crate is available on crates.io, but we are not importing it
    // because the change is only an announcement, not a language update.
    println!("office2pdf crate of the week");
}

// This program demonstrates that eBPF support is not yet available in Rust 1.98.1 (edition 2024).
fn main() {
    println!("eBPF support is not yet available in this Rust version.");
}

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