What changed in Go, Rust and Solidity this week.

// This program demonstrates that the standard library's `context` package
// is the correct import to use.  The deprecated `golang.org/x/net/context`
// package is no longer imported, so no deprecation warning is emitted.
// The program prints the concrete type of the background context value.
package main

import (
	"context"
	"fmt"
)

func main() {
	// Obtain the background context from the standard library.
	c := context.Background()
	// Print the concrete type of the context value.
	fmt.Printf("Context type: %T\n", c)
}

// This program demonstrates the current state of the experimental JSON API.
// The encoding/json/v2 package is not yet available in Go 1.27.1, so we
// fall back to the standard encoding/json package.  The output shows a
// simple marshaling and unmarshaling cycle using the stable API.
package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

func main() {
	// Create a value to marshal.
	p := Person{Name: "Alice", Age: 30}

	// Marshal the value to JSON.
	data, err := json.Marshal(p)
	if err != nil {
		panic(err)
	}
	fmt.Println("Marshaled JSON:", string(data))

	// Unmarshal back into a Person.
	var p2 Person
	if err := json.Unmarshal(data, &p2); err != nil {
		panic(err)
	}
	fmt.Printf("Unmarshaled struct: %+v\n", p2)
}

// This program demonstrates the new Rust SDK for Google Cloud.
// It does not compile until the SDK crate is published.
// For now, it shows how you would use the crate once available.

fn main() {
    // In a real project you would add the SDK to Cargo.toml:
    // google_cloud_sdk = "0.1"
    //
    // Then you could do something like:
    // let client = google_cloud_sdk::Client::new("path/to/key.json");
    // let buckets = client.storage().list_buckets("my-project").await?;
    // println!("Buckets: {:?}", buckets);
    //
    // Since the crate is not yet available, this code is only illustrative.
    println!("The Rust SDK for Google Cloud is now available for use.");
}

// This program demonstrates that the 2025H2 goals proposal does not
// introduce any new language features. It simply prints a message
// confirming that the current stable release (1.98.1, edition 2024)
// contains no changes related to the proposal.

fn main() {
    println!("No new Rust features in 2025H2 goals proposal.");
}

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