What changed in Go and Rust in week 41, 2026.

package main

import (
	"fmt"
	"os/exec"
)

func main() {
	// Demonstrate the current way to run an external command.
	// The execabs wrapper has been deprecated, so we use os/exec directly.
	cmd := exec.Command("echo", "execabs deprecated")
	output, err := cmd.CombinedOutput()
	if err != nil {
		fmt.Printf("command failed: %v\n", err)
		return
	}
	fmt.Printf("output: %s", output)
}

package main

import (
	"fmt"
)

// The golang.org/x/crypto/openpgp package has been removed from the x/crypto
// repository. Attempting to import it now results in a compilation error.
// Existing code must either pin to an older x/crypto version that still
// contains the package or switch to a maintained alternative.

func main() {
	fmt.Println("openpgp package is no longer available in golang.org/x/crypto")
}

package main

import (
	"fmt"
	"net"
)

// This program demonstrates that DNSConfigError still exists but is unused.
// In Go 1.27.1 the type is present for compatibility; no function returns it.
func main() {
	// Create a value of the deprecated type manually.
	// This compiles, but real net code will never produce such an error.
	var err net.DNSConfigError
	fmt.Printf("Deprecated type value: %#v\n", err)

	// Show that typical net functions do not return DNSConfigError.
	_, lookupErr := net.LookupHost("example.com")
	if lookupErr != nil {
		// The error is of type *net.DNSError, not DNSConfigError.
		fmt.Printf("Lookup error type: %T\n", lookupErr)
	}
}

package main

import (
	"fmt"
	"go/build"
)

func main() {
	// ArchChar requires an architecture name argument.
	// Since Go 1.5 it always returns an error, demonstrating the deprecation.
	ch, err := build.ArchChar("amd64")
	if err != nil {
		fmt.Println("ArchChar error:", err)
		return
	}
	fmt.Printf("ArchChar returned: %c\n", ch)
}

package main

import (
	"encoding/json"
	"fmt"
	"os/exec"
)

type ListInfo struct {
	Export string `json:"Export"`
}

func main() {
	// Run `go list -json -export` on the standard library package fmt.
	// This demonstrates the current Export field, which points to a compiler‑produced .a file.
	cmd := exec.Command("go", "list", "-json", "-export", "fmt")
	out, err := cmd.Output()
	if err != nil {
		panic(err)
	}
	var info ListInfo
	if err := json.Unmarshal(out, &info); err != nil {
		panic(err)
	}
	fmt.Println("Export file path (current behavior):")
	fmt.Println(info.Export)
}

// The `f16b` type is not yet available in Rust 1.99.0 (edition 2024).
// We demonstrate the problem it solves by using a `u16` as a stand‑in
// for a 16‑bit floating‑point value and converting to `f32` for math.

fn main() {
    // Imagine this `u16` holds the raw bits of an `f16b` value.
    let raw: u16 = 0b0011_1100_0000_0000; // example bit pattern

    // Convert the raw bits to `f32` using a manual conversion.
    // In real code this would be `f32::from(f16b::from_bits(raw))`.
    let f: f32 = f32::from_bits((raw as u32) << 16);

    // Perform some arithmetic on the `f32`.
    let result = f * 2.0 + 1.0;

    // Convert back to the 16‑bit representation (truncating the mantissa).
    let raw_result = (result.to_bits() >> 16) as u16;

    println!("Original bits: {:#06x}", raw);
    println!("As f32: {}", f);
    println!("Result as f32: {}", result);
    println!("Result bits (as f16b placeholder): {:#06x}", raw_result);
}

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