What changed in Go, Rust and Solidity this week.

// This program demonstrates that the `-tag` flag for `go mod verify` is not
// available in Go 1.27.1. It simply prints a message confirming the absence
// of the feature.
package main

import "fmt"

func main() {
	fmt.Println("go mod verify -tag is not available in Go 1.27.1")
}

// This program demonstrates that the removal of core types in Go 1.25
// does not affect ordinary generic code. It uses a type constraint that
// only requires the underlying type to be []byte or string, without
// any method requirements. The function `at` indexes into the
// generic operand and returns the byte at the given position.
// The program prints the result of indexing a []byte slice and a string.
package main

import "fmt"

// Constraint allows any type whose underlying type is []byte or string.
type Constraint interface {
	~[]byte | ~string
}

// at returns the byte at index i of a value that satisfies Constraint.
func at[T Constraint](s T, i int) byte {
	return s[i]
}

func main() {
	b := []byte{10, 20, 30}
	s := "abc"

	fmt.Printf("b[1] = %d\n", at(b, 1)) // 20
	fmt.Printf("s[2] = %c\n", at(s, 2)) // 'c'
}

// This program demonstrates how Rust’s standard library handles dates and times.
// It prints the current system time in seconds since the UNIX epoch.
// The crate of the week, `jiff`, would provide a richer API, but it is not part of the standard library.
use std::time::{SystemTime, UNIX_EPOCH};

fn main() {
    // Get the current system time
    let now = SystemTime::now();
    // Convert to seconds since UNIX_EPOCH
    let duration_since_epoch = now.duration_since(UNIX_EPOCH)
        .expect("Time went backwards");
    println!("Seconds since epoch: {}", duration_since_epoch.as_secs());
}

// This program demonstrates that Cot v0.2 is a crate release, not a Rust language change.
// It simply prints a message confirming the release announcement.
fn main() {
    println!("Cot v0.2 has been released as a new version of the Rust web framework.");
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;

// EOF is not yet supported in Solidity 0.8.37.
// This contract demonstrates the current state: a simple
// contract that can be deployed and interacted with.
contract Main {
    uint256 public value;

    constructor(uint256 _value) {
        value = _value;
    }

    function increment() external {
        value += 1;
    }
}

Tests

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.37;
import "./main.sol";

contract MainTest {
    Main main;

    constructor() {
        main = new Main(42);
    }

    function test_initialValue() external {
        require(main.value() == 42, "initial value wrong");
    }

    function test_increment() external {
        main.increment();
        require(main.value() == 43, "increment failed");
    }
}