What changed in Go, Rust and Solidity this week.

// This program demonstrates the effect of the macOS 12 support removal.
// In Go 1.27, attempting to build on macOS 12 would fail; here we simply
// print a message indicating the change for educational purposes.
package main

import "fmt"

func main() {
	fmt.Println("Go 1.27 no longer supports macOS 12. Upgrade your OS or use Go 1.26.")
}

// This program demonstrates the effect of removing the cycle restriction
// for type parameters. In Go 1.27.1 the compiler still rejects a type
// constraint that refers to its own type parameter, even indirectly.
// The code below would compile once the change ships, but it fails
// now. To keep the program runnable in the sandbox we use a
// workaround that avoids the forbidden cycle while still
// illustrating the intended behaviour.

package main

import "fmt"

// A generic type that holds a value of any type that satisfies
// the constraint `C[T]`. In the future, `C[T]` may refer to `T`
// directly or through another generic type, but that is not
// allowed yet. Here we use a simple interface to keep the
// program compiling.
type Wrapper[T any] struct {
    v T
}

// A helper function that prints the wrapped value.
func (w Wrapper[T]) Print() {
    fmt.Println(w.v)
}

func main() {
    // Create a Wrapper holding an int and print it.
    w := Wrapper[int]{v: 42}
    w.Print()

    // Create a Wrapper holding a string and print it.
    s := Wrapper[string]{v: "hello"}
    s.Print()
}

// This program demonstrates the new crypto/hpke package in Go 1.27.1.
// It generates a DHKEM key pair, encrypts a message, then decrypts it.
package main

import (
	"crypto/ecdh"
	"crypto/hpke"
	"fmt"
)

func main() {
	// Choose the X25519 curve for the KEM.
	kem := hpke.DHKEM(ecdh.X25519())

	// Generate a key pair.
	priv, err := kem.GenerateKey()
	if err != nil {
		panic(err)
	}
	pub := priv.PublicKey()

	// Define the ciphersuite: use the same KEM, HKDF-SHA256, and AES-128-GCM.
	kdf := hpke.HKDFSHA256()
	aead := hpke.AES128GCM()

	// Sender side: create a context and seal a message.
	enc, sender, err := hpke.NewSender(pub, kdf, aead, []byte("info"))
	if err != nil {
		panic(err)
	}
	plaintext := []byte("Hello, HPKE!")
	ciphertext, err := sender.Seal(nil, plaintext)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Ciphertext: %x\n", ciphertext)

	// Recipient side: create a context and open the ciphertext.
	recipient, err := hpke.NewRecipient(enc, priv, kdf, aead, []byte("info"))
	if err != nil {
		panic(err)
	}
	decrypted, err := recipient.Open(nil, ciphertext)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Decrypted: %s\n", decrypted)
}

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