What changed in Go, Rust and Solidity this week.

// This program demonstrates the new inference in Go 1.27.
// It assigns a generic function to a variable without explicit type arguments.
package main

import "fmt"

func g[T any](x T) {
	fmt.Println("g called with", x)
}

func main() {
	// The compiler infers that g is of type func(int) because the variable expects that.
	var f func(int)
	f = g // no explicit [int] needed

	f(42) // prints: g called with 42
}

// This program demonstrates a helper method on a syscall data structure
// that returns a slice view of an internal array. The method uses
// unsafe.Slice to create the slice. It works on Go 1.27.1 without
// requiring any special proposal or change to the standard library.

package main

import (
	"fmt"
	"unsafe"
)

type MibIfRow2 struct {
	Index uint32
	Name  string
}

type MibIfTable2 struct {
	NumEntries uint32
	Table      [1]MibIfRow2 // the array is sized 1 to satisfy the compiler
}

// Rows returns a slice over the Table array, limited to NumEntries.
// It uses unsafe.Slice to avoid allocating a new slice header.
func (t *MibIfTable2) Rows() []MibIfRow2 {
	// If NumEntries is 0, unsafe.Slice will create an empty slice.
	return unsafe.Slice(&t.Table[0], t.NumEntries)
}

func main() {
	// Create a table with zero entries to avoid out‑of‑bounds errors.
	t := &MibIfTable2{
		NumEntries: 0,
	}

	rows := t.Rows()
	fmt.Printf("Number of rows: %d\n", len(rows))

	// Add a row to demonstrate the helper method works when entries exist.
	t.NumEntries = 1
	t.Table[0] = MibIfRow2{Index: 42, Name: "eth0"}
	rows = t.Rows()
	fmt.Printf("Number of rows after adding one: %d\n", len(rows))
	if len(rows) > 0 {
		fmt.Printf("First row: %+v\n", rows[0])
	}
}

// This program demonstrates that the Go repository has locked commit discussions.
// The change is not part of Go 1.27.1, so the program simply prints a message.
package main

import "fmt"

func main() {
	// In the Go repository, commit pages are now locked.
	// Comments cannot be added, reducing spam and nuisance emails.
	fmt.Println("Commit discussions are locked in the Go repository.")
}

// This program demonstrates nothing about the crates.io frontend change,
// because the change is purely a web‑frontend migration and has no effect
// on Rust code. It simply prints a message confirming that the Rust
// environment is ready for use.

fn main() {
    println!("Rust 1.98.1 (edition 2024) is running. No code changes are required for the crates.io frontend migration.");
}

// This program demonstrates the problem that axum-harness solves:  
// starting an Axum backend without writing boilerplate.  
// Since axum-harness is not yet in the standard library, we simply
// print a message explaining the intended use.

fn main() {
    println!("axum-harness provides a scaffold for Axum backends.");
    println!("It generates routing, state, and agent wiring automatically.");
}

// This program demonstrates a minimal semantic version parser and comparator.
// It does not use any external crates because Rust 1.98.1 (edition 2024) has no
// built‑in semver support. The logic is intentionally simple: it parses
// "major.minor.patch" where each part is a non‑negative integer.

fn parse_semver(s: &str) -> Option<(usize, usize, usize)> {
    let parts: Vec<&str> = s.split('.').collect();
    if parts.len() != 3 {
        return None;
    }
    let major = parts[0].parse::<usize>().ok()?;
    let minor = parts[1].parse::<usize>().ok()?;
    let patch = parts[2].parse::<usize>().ok()?;
    Some((major, minor, patch))
}

fn bump_major(v: (usize, usize, usize)) -> (usize, usize, usize) {
    (v.0 + 1, 0, 0)
}

fn bump_minor(v: (usize, usize, usize)) -> (usize, usize, usize) {
    (v.0, v.1 + 1, 0)
}

fn bump_patch(v: (usize, usize, usize)) -> (usize, usize, usize) {
    (v.0, v.1, v.2 + 1)
}

fn main() {
    let version_str = "1.4.2";
    let version = parse_semver(version_str).expect("invalid semver");
    println!("Parsed: {:?}", version);

    let major_bumped = bump_major(version);
    let minor_bumped = bump_minor(version);
    let patch_bumped = bump_patch(version);

    println!("Major bumped: {:?}", major_bumped);
    println!("Minor bumped: {:?}", minor_bumped);
    println!("Patch bumped: {:?}", patch_bumped);
}

// This program demonstrates how to add the Oxanus crate to a project.
// It does not compile until Oxanus 1.0 is available on crates.io.
// For now, it simply prints a message explaining the situation.

fn main() {
    println!("Oxanus v1.0 is a job processing library announced in this week's Rust news.");
    println!("To use it, add `oxanus = \"1.0\"` to your Cargo.toml and refer to the documentation.");
}

// This program demonstrates that the `flodl` crate is not available in Rust 1.98.1 (edition 2024).
// It simply prints a message explaining the missing dependency.
fn main() {
    println!("The `flodl` crate is not available in this Rust version.");
}

// This program demonstrates that tinyboot 0.4.0 is available.
// It simply prints a message; the tinyboot crate is not used
// because the change is only a release announcement.
fn main() {
    println!("tinyboot 0.4.0 is now stable.");
}

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