What changed in Go, Rust and Solidity this week.

// This program demonstrates the new `new` syntax and the Green Tea GC.
// It runs with Go 1.27.1, which already ships the Green Tea collector.
// The program allocates an int64 with an initial value and prints it.

package main

import "fmt"

func main() {
	// Allocate an int64 with value 300 using the new syntax.
	ptr := new(int64(300))
	fmt.Println(*ptr) // prints 300
}

// This program demonstrates how the new convenience accessors
// `ParentEdgeKind` and `ParentEdgeIndex` would be used once the
// change ships.  Since the real `golang.org/x/tools/go/ast/inspector`
// package is not available in the sandbox, we provide a minimal
// mock implementation that mimics the relevant API.

package main

import "fmt"

// --- Mock types to stand in for the real inspector package. ---

// edge.Kind is an enumeration of AST edge kinds.
type Kind int

const (
	CallExpr_Args Kind = iota
	SelectorExpr_Sel
)

// Cursor represents a position in an AST.  In the real package it
// contains many fields; here we only need the ParentEdge method.
type Cursor struct {
	kind  Kind
	index int
}

// ParentEdge returns the kind of edge from the cursor's parent to
// the cursor and the index of the cursor among its siblings.
func (c Cursor) ParentEdge() (Kind, int) {
	return c.kind, c.index
}

// ParentEdgeKind returns the first component of ParentEdge.
func (c Cursor) ParentEdgeKind() Kind {
	kind, _ := c.ParentEdge()
	return kind
}

// ParentEdgeIndex returns the second component of ParentEdge.
func (c Cursor) ParentEdgeIndex() int {
	_, idx := c.ParentEdge()
	return idx
}

// --- Example usage of the convenience accessors. ---

func main() {
	// Create a cursor that is the third argument to a function call.
	cur := Cursor{kind: CallExpr_Args, index: 2}

	// Using the new convenience methods.
	if cur.ParentEdgeKind() == CallExpr_Args {
		fmt.Println("Cursor is an argument to a call expression")
	}
	if cur.ParentEdgeIndex() == 2 {
		fmt.Println("Cursor is the third argument (index 2)")
	}
}

// This program demonstrates that the compiler and tooling work correctly
// after applying Rust 1.93.1. It simply prints a message and exits.
fn main() {
    // Print a greeting to show that the program runs.
    println!("Hello, Rust 1.93.1 is installed and working!");
}

// This program prints a message about subscribing to the RustSec advisory RSS feed.
// It runs on Rust 1.98.1 (edition 2024) and produces the expected output.
fn main() {
    println!("Subscribe to https://rustsec.org/advisories.rss for updates on malicious crates.");
}

// This program demonstrates that the change is purely informational and has no
// effect on Rust code. It simply prints a message acknowledging the new
// Leadership Council representatives.
fn main() {
    println!("Leadership Council representatives announced – no code change.");
}

// This program demonstrates that the Rust language itself has not changed
// in response to the January 2026 program‑management update. It simply
// prints a message confirming that the update is about project organization,
// not language features.
fn main() {
    println!("Rust program‑management update: no language change.");
}

// This program demonstrates that the January 2026 Project Director Update
// is purely informational and does not affect the Rust language or standard
// library. It simply prints the key points from the update.

fn main() {
    // Strategic goals approved for 2026‑2028
    println!("Strategic goals approved for 2026‑2028.");
    // Crates.io CloudFront usage cost issue
    println!("Crates.io CloudFront usage exceeds expectations.");
    // New features in progress
    println!("GitLab Trusted Publishing beta launched.");
    println!("Capslock capability analyzer prototype ready.");
    println!("Vulnerability scanning RFC in final comment period.");
    // Training accreditation program
    println!("Foundation accreditation program for Rust training providers approved.");
}

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

// This contract is a placeholder to demonstrate that the Solidity compiler
// accepts the code as is. No new language feature is used here.
contract SurveyPlaceholder {
    // No state or functions needed for this example.
}

Tests

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

import "./main.sol";

contract SurveyPlaceholderTest {
    SurveyPlaceholder public survey;

    constructor() {
        survey = new SurveyPlaceholder();
    }

    function test_deployment() public {
        require(address(survey) != address(0), "Contract not deployed");
    }
}