标签：#go

Here’s a problem you probably didn’t solve in school: You’re an ambitious young plumber from Brooklyn in a world inhabited by violent human-size mushrooms called Goombas. The love of your life has been kidnapped, so you embark on a quest to rescue her, venturing through stretches of pipe-filled and monster-­ridden terrain where your only means…

The Argentina v. France final of the 2022 Men’s World Cup in Qatar was shaping up to be one of the most epic games in soccer history. With just 12 minutes remaining in the extra time added to the game to break a tie, the referee had a critical decision to make—and fast. Lionel Messi,…

We can usually rely on Google to put together a compelling package in its Pixel A-series devices. The Pixel 10A was kind of a letdown, though. It added only a handful of updates, like satellite messaging and updated Gorilla Glass on the screen — but it still costs $499, like the Pixel 9A. Kind of […]

This post is my submission for DEV Education Track: Build Apps with Google AI Studio . What I Built I set out to build the same app as the one mentioned in the Tutorial. Please create an app that generates a unique new Magic the Gathering card, using Imagen for the visuals, and Gemini to create the text descriptions and stats for the card. Apply the "Sophisticated Dark" design theme to the app. Spammed Fix Errors Non-Stop After this other than the Manual Entry option. Demo My Experience You can't trust Gemini Flash even for the Task provided in the Tutorial Standalone at least and well I spammed Fix Errors and they removed the Auto-Fixing of Errors because of idk an infinite loop or something but well the Error Fixing Experience was quite Meh considering I haven't delved into Vue and React in that level yet so I just 'Vibe Coded' and I found out with this experience that Vibe-Coding is UnCool. I think I would do the other course after properly understanding concepts behind it unlike the way I jumped in this One.

This cheat sheet is based on Go 1.26. Table of Contents Program structure Variables, constants, and types Control flow Functions Arrays, slices, and maps Structs, methods, and tags Interfaces Errors Goroutines, channels, and synchronization Context Generics Iterators Testing Standard-library quick reference Tips and common mistakes Modules and packages Further reading Program structure package main // Every executable must be in package main. import ( "fmt" "os" ) func main () { fmt . Println ( "Hello, Go 1.26" ) os . Exit ( 0 ) } Every Go source file starts with a package declaration. An executable program uses package main and a main function. Group standard-library and third-party imports separately. Variables, constants, and types Variable declarations and inference // var can infer the type from an initializer. var name = "Gopher" // string var age int // No initializer: specify a type. Zero value: 0. var id int64 = 42 // Use an explicit type when int is not what you want. // Short declaration: inside functions only. city := "Tokyo" // Declare multiple variables in a block. var ( x , y int = 1 , 2 msg string ) Use var name = "Gopher" when an initializer makes the type clear. Without an initializer, write the type explicitly. A := declaration is only valid inside a function, and at least one name on its left side must be new. Types and zero values Category Types Zero value Numbers integers, floats, complex numbers 0 ( 0 + 0i for complex) Strings string "" Booleans bool false Arrays [N]T every element is T 's zero value Structs struct every field has its zero value Reference-containing types pointers, slices, maps, channels, functions, interfaces nil Defined types e.g. type UserID int the underlying type's zero value Category Types Notes Boolean bool true or false String string immutable sequence of bytes (usually UTF-8, but invalid UTF-8 is allowed) Signed integers int , int8 , int16 , int32 , int64 int is platform-sized (32 or 64 bit) Unsigned integers uint , u

Fable 5 is the supposed safe version of Anthropic’s Mythos Preview, with guardrails to ensure that it can’t be used to create cyberattacks. Well, that restriction was bypassed within days.

“I deleted it as a test and it came immediately back,” says one government employee.

Hello Dev Community! 👋 It is officially Day 71 of my unbroken 100-day full-stack engineering run! After mastering polymorphic multi-part storage configurations yesterday, today I successfully crossed into core transactional operations: Engineering a High-Fidelity "Confirm and Pay" Checkout View and Wiring Database Inbound Array Modifications! In real-world booking platforms, processing a successful transaction requires more than updating an absolute view; you have to link documents relationally across collections. Today, I wired that entire execution pipeline together! 🧠 What I Handled on Day 71 (Checkout Engineering & Target Mutations) As displayed across my latest system files in "Screenshot (164).png" and "Screenshot (165).jpg" , handling payments runs through structured backend steps: 1. High-Fidelity Checkout Component ( /reserve ) I built out the detailed split-pane verification interface visible in "Screenshot (164).png" . The layout captures target trip date selections, total guests parameter caps, card input structures, and computes subtotal ledgers dynamically: Base Compute: $9000 x 5 nights = $45000 . Transactional Upgrades: Appending structured service charges ( $85 ) and local tax calculations ( $42 ) to update the final sum directly to $45127 . 2. Live Document Array Mutators (MongoDB User List Insertion) The most crucial logic happens when the user clicks the primary validation trigger labeled Confirm and pay : The inbound route controller extracts the targeted property identity token ( home._id ) via an embedded hidden input container. Instead of running isolation updates, it issues an atomized update operation straight into our MongoDB user records array (e.g., using Mongoose operators like $push or tracking active profiles inside our custom data state loops). This appends the exact property listing target ID directly into the user's booking history array database matrix! 🛠️ View Markup Code Integration View As showcased in my VS Code script structu

I had a long Google AI Studio (Gemini) session that I wanted to keep. I selected the conversation in the browser, copied it, and pasted it into a text file. File size: a few hundred KB. "OK, that's safe." Later, I exported the same session as JSON. File size: a few MB. More than half of the data had silently disappeared. What was missing I checked what the manual copy had dropped. The system prompt The instruction I had originally given the model — the system prompt — was completely gone. Manual copy captures only the user/assistant turns visible in the conversation pane. The instruction context that shaped the entire session does not get copied. The tail of long responses When a Gemini response is long, the browser shows a "Show more" button. If you copy without expanding it, the response gets cut mid-sentence. Out of 8 sessions I checked, 3 had responses truncated this way. Newlines inside code blocks Newlines inside code blocks got mangled in several places. Responses containing JSON or YAML had indentation that no longer parsed. The reasoning trace For some models, the model's reasoning trace is stored separately from the visible response. Manual copy doesn't capture it at all. How to export as JSON Google AI Studio has a session export feature. In the session view, click the ... menu at the top right Select "Export" Choose JSON format and download The JSON contains the full data, including the system prompt. Measured: manual copy vs. JSON export I compared 8 sessions. Session Manual copy JSON Loss rate A tens of KB ~150 KB ~70% B ~90 KB ~200 KB 50-60% C ~30 KB ~100 KB 60-70% D ~50 KB ~180 KB ~70% E ~60 KB ~240 KB ~70% F ~20 KB ~70 KB ~60% G ~20 KB ~50 KB 50-60% H ~10 KB ~30 KB ~60% Total a few hundred KB ~1 MB 60-70% Average loss rate, 60-70%. The manual copy was, on every session, missing most of what was in the actual session state. Why I didn't notice If you open the manually-copied file, the conversation reads fine. As long as the start and end connect, a m

This story originally appeared in The Algorithm, our weekly newsletter on AI. To get stories like this in your inbox first, sign up here. For those of you enjoying your summer unaware of Anthropic’s latest feud with the US government, here’s a recap: In April the company said it had built an AI model called Mythos…

Google's DeepMind AI lab is teaming up with A24 to develop new movie production technologies that aim to help future filmmakers "expand their storytelling possibilities." As part of this new research and development collaboration, The Wall Street Journal reports that Google is investing "around $75 million" into A24, marking the first time the search giant […]

The Problem: Feature Velocity Was Creating Structural Debt The system originally started as a simple feature delivery backend: A Django API powering agricultural insights Celery workers handling asynchronous processing Independent endpoints for each new capability A growing set of Earth Observation computations (NDVI, NDWI, etc.) At first, it worked. But as more features were added, a pattern emerged: Each feature introduced its own pipeline logic Observability was inconsistent across services API contracts drifted between frontend and backend Debugging required tracing multiple disconnected systems We weren’t scaling functionality. We were scaling fragmentation. The Turning Point: Features vs Platforms The key realization was simple: Features solve user problems. Platforms solve system problems. We were repeatedly rebuilding: Authentication flows Data ingestion logic Processing pipelines API validation layers Monitoring hooks Each feature was solving its own version of these concerns. That is where platform engineering became necessary. The Shift: Introducing a Platform Layer We introduced a platform layer between feature delivery and infrastructure. Instead of building isolated pipelines, we standardized: 1. Unified API Surface All Earth Observation workflows (NDVI, NDWI, and future indices) were normalized into a consistent API contract. Shared request/response structure Versioned endpoints Schema validation through serializers Central routing logic This eliminated endpoint fragmentation. 2. Standardized Processing Pipeline Celery tasks were refactored into a reusable pipeline pattern: Ingestion Validation Computation Storage Publishing Instead of feature-specific workers, we moved toward composable tasks. This allowed new indices or processing logic to plug into the same execution flow. 3. Observability as a First-Class Layer One of the biggest failures in the original system was visibility. We introduced: Structured logging across all services Traceable job IDs

I haven’t thought about the privacy issues surrounding professional athletes and wearables. Wearables present serious privacy issues for “Average Joe” consumers, who are entrusting tech companies to safely store and protect their biometric data. Imagine the stakes for a professional athlete, whose entire livelihood could be affected by a single biometric data point. To give one of many realistic hypotheticals: a basketball player has a terrible game, and the coach wonders if they showed up to the gym hungover. The coach has access to the player’s wearable data, and checks to see when they went to sleep, as well as what their heart rate looked like during the night. Should the player have been out partying before a game? No. Should the coach be able to surveil them? Definitely not...

A consumer nav app tells the driver where to turn. It will not tell the dispatcher where the 11-hour driving clock runs out — and, more importantly, whether there is legal parking when it does. That second question is the one that strands a truck at 11 PM on the shoulder of an off-ramp with every nearby lot already full. Road511’s routing endpoint now answers it. Send the driver’s Hours-of-Service clock along with the route, and the response carries an hos[] array: every point on the corridor where the driver must take a break or stop driving under the selected regime, the projected time they reach it, the legal deadline, and — the part that matters operationally — the truck parking and rest areas actually reachable before that deadline. How It Works It rides the same call as everything else routing does: POST /api/v1/routing/route . You already send an origin, a destination, and a truck profile. To get the HOS projection, add an hos block inside the truck object describing the driver’s clock at departure. curl -X POST "https://api.road511.com/api/v1/routing/route" \ -H "X-API-Key: your_key" \ -H "Content-Type: application/json" \ -d '{ "origin": { "lat": 41.8781, "lng": -87.6298 }, "destination": { "lat": 39.7392, "lng": -104.9903 }, "departure_time": "2026-06-08T06:00:00Z", "truck": { "profile": "tractor", "weight_t": 36.0, "height_m": 4.2, "axles": 5, "hos": { "ruleset": "us", "drive_remaining_s": 39600, "duty_remaining_s": 50400, "since_break_s": 0 } }, "enrichment": { "include_features": ["truck_parking", "rest_areas"] } }' That’s a Chicago→Denver run for a fresh driver on US rules: 11 hours of driving left ( 39600 s), a 14-hour duty window ( 50400 s), and zero driving time since the last break. Every counter is “seconds remaining” against the named ruleset’s limit. The HOS Clock The hos object is the driver’s state, not a fixed policy. Store only the ruleset on a reusable truck profile — the per-trip counters are supplied inline on each request and merge on to

June 24, 2026. That is the shutdown date for every Imagen model on Firebase AI Logic — imagen-3.0-generate-002 , imagen-4.0-generate-001 , imagen-4.0-ultra-generate-001 , imagen-4.0-fast-generate-001 . All of them. If you have been putting off this migration, you have run out of runway. The replacement is Google's Gemini Image models — internally called "Nano Banana," publicly named gemini-2.5-flash-image . The migration is mostly a one-function rename and a response structure update, around 90 minutes of work for most codebases. The catch: one Imagen capability, mask-based editing, has no replacement at all. That separate deadline hits June 30. What Goes Dark and When Firebase AI Logic's migration documentation confirms these shutdown dates: imagen-3.0-generate-002 — June 24, 2026 imagen-4.0-generate-001 — June 24, 2026 imagen-4.0-ultra-generate-001 — June 24, 2026 imagen-4.0-fast-generate-001 — June 24, 2026 imagen-3.0-capability-001 (mask editing: inpainting, outpainting, object removal) — June 30, 2026 Vertex AI runs on a slightly different clock — Google recommends migrating before June 30, with a hard shutdown date of August 17 for Vertex AI users on legacy Imagen endpoints. Firebase AI Logic is the shorter deadline. Don't assume extra time if your app uses the Firebase SDK. The Core Migration: Python Three things change simultaneously: the method name, the model identifier, and the response structure. All three break if you miss any one of them. Before (Imagen): import google.generativeai as genai client = genai . Client ( api_key = " YOUR_KEY " ) response = client . models . generate_images ( model = " imagen-4.0-generate-001 " , prompt = " A red fox running through snow " , config = { " number_of_images " : 1 , " output_mime_type " : " image/jpeg " } ) image_bytes = response . generated_images [ 0 ]. image . image_bytes After (Gemini Image): import google.generativeai as genai client = genai . Client ( api_key = " YOUR_KEY " ) response = client . models . g

У большинства self-hosted VPN-панелей одна и та же боль: Docker-стек, внешняя БД, реверс-прокси и куча конфигов, которые надо связать между собой, прежде чем хоть что-то заработает. Мне хотелось наоборот — что-то, что можно закинуть на свежий VPS и поднять меньше чем за минуту. Так появилась РосПанель : self-hosted панель для администрирования личного VPN-сервера на Xray-core , который поставляется одним статическим бинарником . React-фронтенд вшит через go:embed , база — встроенный SQLite, отдельного веб-сервера нет. Поставил, открыл, добавил юзера. Главная идея: один бинарник, ничего лишнего Цель, которая определила всё остальное, — радикальная простота. В отличие от Marzban и 3x-ui, у РосПанели нет Docker-обвязки, нет внешней БД и нет отдельного веб-сервера, который надо настраивать. Всё живёт в одном исполняемом файле: Веб-интерфейс собирается в web/dist и вшивается в Go-бинарник на этапе сборки. Состояние хранится в SQLite (чистый Go-драйвер modernc , то есть без CGO ). Конфиг Xray всегда генерируется из базы и применяется супервизором — SQLite это единственный источник правды, а не JSON, который правят руками. В итоге деплой — это просто положить бинарник и systemd-юнит. Никакой оркестрации, ничего не надо держать в синхроне. Что она на самом деле делает РосПанель — это панель управления (control plane), а не VPN-клиент. Она настраивает и обслуживает ваш собственный сервер: генерирует конфиг Xray, выдаёт ссылки на подписки и показывает статистику. Протоколы из коробки — один конфиг Xray, один набор учёток: VLESS-Vision (TCP/443 + uTLS-fingerprint) Trojan-WS (через fallback на 443) Hysteria2 (UDP с port-hopping) VLESS-gRPC-REALITY (отдельный порт, маскировка под чужой TLS) Маскировка — панель спрятана за секретным путём. Любой другой путь отдаёт сайт-заглушку (11 готовых шаблонов), так что сервер неотличим от обычного хостинга. Без знания /<secret>/ форму логина не найти. TLS, который просто работает — ACME через Let's Encrypt или ZeroSSL, авто-продление и self

Anthropic recently reported that Claude now handles around 95% of its internal analytics requests, letting employees query business data independently instead of relying on data teams. The company attributes this result less to advances in models and more to data governance, semantic definitions, and operational discipline. By Renato Losio

On the new episode of Equity, we discussed what actually prompted the administration's latest moves against Anthropic, and what this might mean for the AI ecosystem.

Why Bohmian Mechanics, Go Programs, AI, and EBP 2.1 Could Help Reopen the Deepest Questions in Physics There is a quiet crisis in theoretical physics, and it has nothing to do with the equations. The equations are fine. Quantum mechanics predicts with staggering accuracy. General relativity bends light exactly as calculated. The Standard Model matches experiment after experiment. The mathematics is not the problem. The problem is what happens between the equations and the claims. A researcher writes a beautiful paper. The math is correct. The toy model works. A suggestive ratio appears. An analogy crystallizes. And then, in the discussion section, a modest result becomes a bold narrative: classical cosmology is recovered , the problem of time is resolved , spacetime emerges from the quantum . This is not fraud. It is not even intentional. It is the natural gravity of theoretical work — ideas fall toward overclaiming the way matter falls toward mass. Two small codebases, written in Go and governed by an epistemic protocol called Elephant Bridge Protocol v2.1 , are trying to build a tool against that gravity. They are not trying to solve quantum gravity. They are trying to make it harder to pretend you have solved quantum gravity when you haven't. One is called Bell–MIPT . It builds toy models connecting Bohmian mechanics to measurement-induced phase transitions in many-body quantum systems. The other is called BMC — Bohmian Minisuperspace Cosmology. It builds toy models of quantum cosmology using Bohmian guidance in Wheeler–DeWitt minisuperspace. They share the same philosophy. They share the same protocol. And they share the same radical commitment: no claim may be promoted until its debts are paid . What Is BMC? BMC stands for Bohmian Minisuperspace Cosmology . The name is deliberately modest. It is not "Bohmian Quantum Gravity." It is not "The Theory of Everything in Go." It is a cosmology toy model — a wind tunnel, not an airplane. The physics idea behind it is o

Error Handling — Learning to Love if err != nil In part 3 I covered goroutines and channels, and how Go's concurrency model sidesteps a lot of the ceremony I was used to from the JVM. This time I'm tackling the thing I complained about in part 1 of this series before I'd even really tried it: error handling. I called if err != nil repetitive back then. A few weeks and a lot of real code later, I owe Go a partial apology. No Exceptions, On Purpose Coming from Java, the absence of try / catch is the first thing that feels like a missing feature. It isn't — it's a deliberate design choice. In Go, errors are just values. A function that can fail returns an error as its last return value, and the caller decides what to do with it, right there, inline: func divide ( a , b float64 ) ( float64 , error ) { if b == 0 { return 0 , errors . New ( "division by zero" ) } return a / b , nil } func main () { result , err := divide ( 10 , 0 ) if err != nil { fmt . Println ( "error:" , err ) return } fmt . Println ( "result:" , result ) } That's the pattern you'll write hundreds of times in Go: call a function, check err , handle it or bail out, move on. No hidden control flow jumping up the call stack to whichever catch block happens to match. No checked-exception signatures cluttering method declarations. No RuntimeException quietly skipping past five layers of code that had no idea it could happen. Whatever can fail is sitting right there in the function signature, and you're forced to look at it. Why the Repetition Is the Point My part 1 complaint was that if err != nil everywhere feels manual. It is manual — and that's exactly the trade Go is making. In Java, an exception thrown deep in a call stack can silently propagate through layers of code that never declared they might fail, and you only find out where things actually break by reading a stack trace after the fact. In Go, every single point where something can go wrong is visible in the source, in order, as you read top to