What changed in Go, Rust and Solidity this week.

// This program demonstrates that in Go 1.27.1 the bubble created by
// crypto/subtle.WithDataIndependentTiming is not inherited by goroutines
// started inside the bubble. The outer function runs with data‑independent
// timing, but the goroutine started inside it does not inherit that
// property. The program prints messages to show the execution order.
package main

import (
	"fmt"
	"crypto/subtle"
)

func main() {
	// Run a function under a data‑independent timing bubble.
	subtle.WithDataIndependentTiming(func() {
		fmt.Println("outer: inside WithDataIndependentTiming")
		// Start a new goroutine. It will not inherit the bubble.
		go func() {
			fmt.Println("inner: started in a new goroutine")
		}()
		// Wait a moment to let the goroutine finish.
		// In a real program you would use sync.WaitGroup.
		// Here we just sleep for a short time.
		// time.Sleep(10 * time.Millisecond)
	})
	fmt.Println("main: finished")
}

// This program demonstrates that the GODEBUG flags gotypesalias and asynctimerchan
// are ignored in Go 1.27. It prints the value of the flags to show they have no effect.
package main

import (
	"fmt"
	"os"
)

func main() {
	// Read the GODEBUG environment variable.
	godebug := os.Getenv("GODEBUG")
	fmt.Println("GODEBUG:", godebug)

	// In Go 1.27, setting gotypesalias or asynctimerchan has no effect.
	// The program simply prints the flags; no debugging behavior occurs.
}

// This program demonstrates that Rust 1.98.1 (edition 2024) can spawn
// multiple threads that run concurrently.  It does not actually download
// anything, but it shows the idea behind rustup's concurrent download
// feature by printing messages from several threads at the same time.
use std::thread;
use std::time::Duration;

fn main() {
    // Spawn three threads that simulate downloading different components.
    let handles: Vec<_> = (1..=3)
        .map(|i| {
            thread::spawn(move || {
                // Simulate a download taking a random amount of time.
                let sleep_time = Duration::from_millis(500 * i);
                thread::sleep(sleep_time);
                println!("Component {} downloaded in {:?} ms", i, sleep_time.as_millis());
            })
        })
        .collect();

    // Wait for all threads to finish.
    for h in handles {
        h.join().unwrap();
    }

    println!("All components downloaded concurrently.");
}

// This program demonstrates that the November 2025 project goals update
// does not introduce any new language feature.  It simply prints a
// message confirming that the change is only a planning document.
fn main() {
    println!("The November 2025 project goals update is a planning document, not a language change.");
}

// This program demonstrates the new 2026 project goal proposal process.
// It simply prints a reminder that proposals can be submitted until
// the end of January 2026. No Rust language feature changes are involved.
fn main() {
    println!("Rust 2026 Project Goal Proposals are open until 2026-01-31.");
}

// This program simply prints a message; the RFC change does not affect Rust code.
// The change is about Markdown formatting in the RFC document, not the language itself.
fn main() {
    println!("RFC 3872 now uses level‑two Markdown headings for its sections.");
}

// main.sol
pragma solidity ^0.8.37;

// This contract demonstrates reading a constant variable via its getter.
// The compiler bug fixed in 0.8.33 is no longer triggered.
contract ConstantDemo {
    uint256 public constant ANSWER = 42;

    // The getter for ANSWER is automatically generated.
    // We can call it like a normal function.
    function getAnswer() external view returns (uint256) {
        return ANSWER;
    }
}

Tests

// test.sol
pragma solidity ^0.8.37;
import "./main.sol";

contract ConstantDemoTest {
    ConstantDemo demo;

    constructor() {
        demo = new ConstantDemo();
    }

    function test_getAnswerReturns42() external {
        require(demo.getAnswer() == 42, "Getter did not return 42");
    }

    function test_answerConstantIs42() external {
        require(demo.ANSWER() == 42, "Constant getter did not return 42");
    }
}