What changed in Go, Rust and Solidity this week.

// This program demonstrates the new struct literal syntax that allows
// direct reference to embedded fields. It runs on Go 1.27.1.
package main

import "fmt"

type E struct{ A int }
type T struct{ E }

func main() {
	// Using the new syntax: we can set A directly in the literal.
	v := T{A: 42}
	fmt.Println(v.A) // prints 42
}

package main

import "fmt"

func main() {
	// The 2025 Go Developer Survey was conducted in September 2025.
	// This program simply prints a summary of the survey results.
	fmt.Println("2025 Go Developer Survey Summary:")
	fmt.Println("- 5,379 developers responded.")
	fmt.Println("- 91% are satisfied with Go.")
	fmt.Println("- Main use cases: CLIs and API services.")
	fmt.Println("- Top challenges: idiomatic Go practices, missing features, module trust.")
}

// This program demonstrates the new ability to apply cfg attributes to individual
// statements inside an asm! block.  The feature is available in Rust 1.93.0, but
// the current sandbox uses Rust 1.98.1 (edition 2024), so we import the asm
// macro explicitly.  The program prints a message that shows whether the
// target supports the "sse2" feature; the asm block will only emit the
// second "nop" if that feature is enabled.

use std::arch::asm;

fn main() {
    // Detect if the target CPU supports SSE2.  This is a compile‑time
    // configuration flag that the compiler sets automatically.
    #[cfg(target_feature = "sse2")]
    let sse2_supported = true;
    #[cfg(not(target_feature = "sse2"))]
    let sse2_supported = false;

    // The asm! block contains two "nop" instructions.  The second one is
    // guarded by #[cfg(target_feature = "sse2")], so it will only be
    // assembled when the target has SSE2 support.  The first "nop" is
    // unconditional.
    unsafe {
        asm!(
            "nop",                     // always emitted
            #[cfg(target_feature = "sse2")]
            "nop",                     // emitted only if SSE2 is available
        );
    }

    println!(
        "SSE2 support detected at compile time: {}",
        sse2_supported
    );
}

// This program demonstrates that Rust can be used in safety‑critical contexts.
// It simply prints a message confirming that Rust is already deployed in such systems.
// The code compiles and runs on Rust 1.98.1 (edition 2024).

fn main() {
    println!("Rust is already shipping in safety‑critical systems.");
}

// This program shows how the new #[export_visibility] attribute would be used
// if it were available in Rust 1.98.1. Since it is not yet shipped, the code
// does not compile. The attribute is commented out to keep the example
// runnable with the current compiler.

fn main() {
    // The following function would normally be exported because of #[no_mangle].
    // With the new attribute, we could hide it:
    //
    // #[no_mangle]
    // #[export_visibility = "hidden"]
    // fn secret() {
    //     println!("You should not see this symbol in the binary");
    // }

    println!("Run `nm <binary>` to inspect exported symbols.");
}

// This program demonstrates a simple throttled logging mechanism.
// It prints a message only once every 5 calls to `log_throttled!`.
// The `throttled-tracing` crate is not available in this sandbox,
// so we implement the core idea manually using a static counter.

use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::{Duration, Instant};

static CALL_COUNT: AtomicUsize = AtomicUsize::new(0);
static LAST_LOG: AtomicUsize = AtomicUsize::new(0);

/// Log a message only if at least `interval` calls have occurred
/// since the last log. This mimics the behaviour of the
/// `throttled_info!` macro from `throttled-tracing`.
macro_rules! log_throttled {
    ($interval:expr, $msg:expr) => {{
        let count = CALL_COUNT.fetch_add(1, Ordering::SeqCst) + 1;
        let last = LAST_LOG.load(Ordering::SeqCst);
        if count - last >= $interval {
            println!("[throttled] {}", $msg);
            LAST_LOG.store(count, Ordering::SeqCst);
        }
    }};
}

fn main() {
    // Simulate many log calls
    for i in 1..=20 {
        log_throttled!(5, format!("Iteration {}", i));
    }
}

// This program simply prints the list of newly released tooling versions.
// It demonstrates that the change is a release announcement, not a language feature.
fn main() {
    let releases = [
        "Creusot 0.9.0",
        "diesel-guard 0.5.0",
        "skim 1.0.0",
        "d-engine",
        "govctl",
        "Burn 0.20.0",
        "git-cliff 2.12.0",
    ];
    for release in releases.iter() {
        println!("{}", release);
    }
}

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