Loading…
Topic
Go
89 posts about Go. Every summary links to the original.
- 89 posts
- 15 companies
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Newest first
Posts
Python vs Go: A Practical Comparison for Developers
The post compares Python and Go across language design, performance, tooling, and developer profiles, drawing on quantitative data from the JetBrains Developer Ecosystem 2026 survey of 28,945 respondents and qualitative interviews with developers who migrated production workloads from Python to Go. Python favors expressive code and rapid iteration, while Go emphasizes explicit, standardized code that is easy to maintain across teams. Go excels in raw performance and concurrency and is widely used in cloud infrastructure, whereas Python remains stronger for machine learning, data science, and scientific computing. Survey data shows that Go developers are typically more infrastructure-focused and senior, and that Go is rarely a first language, while Python is beginner-friendly with 10% of its developers coding for less than a year. Most teams use both languages, with Go for services and infrastructure and Python for AI and data workloads, and moving to Go rarely means abandoning Python.
Avoid Sending SMS to Landlines with the Lookup v2 API and Go
Sending SMS to landlines causes failed deliveries and unnecessary charges, a problem that Twilio’s Lookup v2 API solves by identifying phone number types. The API’s line_type_intelligence field returns a classification such as “mobile” or “landline”, enabling applications to filter out non-mobile numbers before sending an SMS. This Go tutorial loads Twilio credentials from a .env file and uses Go 1.23’s iter package to create a custom iterator over a phone number list. Within the iterator, each number is validated by calling FetchPhoneNumber with the line_type_intelligence parameter, and if the type is not “mobile” or the call fails, the number is skipped. Only mobile numbers are then passed to the sendSMS function, which sends the message using the Twilio Go helper library’s CreateMessage, and the terminal finally logs each success or identifies a skipped landline.
How to Create and Send vCards with Go
Sharing contact details by copying text between apps is ineffective compared to sending a vCard, a structured data format supported by major operating systems and email clients. This tutorial demonstrates creating vCards in Go using the go-vcard package, which handles fields such as formatted name, structured name, street address, telephone number, email address, and URL. The code writes the vCard to a .vcf file with version 4.0 using the go-vcard encoder and constants from the package, exiting on failure. The vCard file is uploaded to Twilio Assets, a static file hosting service bundled with every Twilio account, to make it publicly accessible for the SMS. The Twilio Go SDK sends an SMS with a message body and the vCard URL as a media attachment via the Programmable Messaging API, allowing recipients to open it in their contacts app.
How to Handle Errors in Go
Go treats errors as values rather than moving error handling outside normal control flow: functions return an error alongside other results, and callers check it. The guide presents the built-in error interface, returning errors with errors.New, wrapping failures with fmt.Errorf and %w, and distinguishing nil success from non-nil failure. It also explains panic and recover for unexpected failures, including deferred recovery in services that must continue handling other requests, while warning that panics should not replace ordinary error handling. Its best practices emphasize adding context, choosing informative custom error types, inspecting wrapped errors with errors.Is, errors.As, and errors.AsType, and logging errors when they are handled or cannot be returned. The conclusion recommends balancing early crashes with recovery when restarting is costly or when independent goroutines can continue safely.
Google for Developers Blog - News about Web, Mobile, AI and Cloud
The page presents six featured Google developer articles spanning multi-agent systems, content credentials, TPU optimization, agent plugins, Go, and Genkit Go. One article identifies bidirectional MCP, async event buses, unified validation, and tiered routing as recurring patterns in successful AI Agents Challenge submissions. Another introduces Credentio, an open-source C++ library for local-first C2PA validation, while a HeyGen case study reports a 1.86x speedup for Avatar IV on Trillium TPUs using torchax, XLA, FSDP, Ulysses sequence parallelism, and custom kernel/compiler optimizations. The collection also covers Agent Plugins 1.0.0’s plugin.json directory specification and Genkit Go’s progressive-disclosure Agent Skills based on SKILL.md bundles. A final article argues that Go’s compiler, toolchain, readability, and backward compatibility provide guardrails for reviewing and maintaining AI-generated software.
How to Use Svelte and Go to Build a Video Chat App
The tutorial builds a video chat application with a Svelte single-page frontend and Go REST API, using Twilio Video for room-based calls. Users enter a room name, the backend validates it, mints a Twilio Access Token with a VideoGrant, and the frontend uses that token to connect and attach local and remote video tracks. The backend loads credentials from .env.local, assigns each participant a random crypto/rand identity, enables CORS, and serves requests on port 8000; room names shorter than six characters receive a 400 response. The frontend uses Vite, the Twilio Video JavaScript SDK, and iziToast, while testing involves running both servers and joining the same room in two browser tabs. The completed app handles video communication without custom permission, real-time communication, or data-streaming code.
How Much Code Do Developers Really Let Agents Write?
JetBrains surveyed over 15,000 professional developers globally in 2026 to measure how much production code is generated by AI agents versus manual authoring. On average, respondents report that agents fully write approximately 47% of their code, while 38% involves AI assistance and 27% is written manually. Adoption varies across ecosystems, with Go, JavaScript, and TypeScript developers reporting the highest agentic code generation at 54% to 55%, while C and C++ developers retain the highest manual share. Senior developers lead adoption over juniors, with about a quarter delegating more than 80% of code generation to agents. Cluster analysis categorizes the developer population into agentic coders (31%), AI-assisted coders (47%), and manual coders (23%).
OpenTelemetry Comes to IntelliJ IDEA, GoLand, PyCharm, and WebStorm
With the 2026.2 release, JetBrains expanded its OpenTelemetry plugin from Rider to IntelliJ IDEA, GoLand, PyCharm, and WebStorm. The tool captures logs, metrics, traces, and service maps locally without requiring an external observability backend. Developers can search structured log records, plot metric values over time, inspect distributed spans, and verify communication paths across databases and message queues during local runs. To ingest telemetry, the plugin automatically configures OpenTelemetry Protocol environment variables for supported run configurations and terminal sessions, or accepts forwarded data from existing collectors. Additionally, experimental Model Context Protocol support allows AI coding agents to query gathered logs, spans, and service topology.
Building a data plane from scratch: Stripe’s own high-performance distributed proxy
Stripe replaced Envoy in its service mesh after reliability, connection-cardinality, rollout-risk, and customization problems became increasingly difficult at its scale. Mesh-proxy, a Go proxy, implements HTTP/1.1 and HTTP/2, connects directly to Stripe’s service registry, and supports retries, hedging, rate limiting, and dynamic priority-based routing. Unlike Envoy’s worker-per-core model, it uses one read and one write goroutine per connection and multiplexes requests over a shared connection, reducing connection counts from one per worker to one per host. Load tests and deployment results showed about half the CPU under high load and roughly 50% lower latency, equivalent to around 3,000 days of cumulative inter-service latency saved daily. Direct registry integration also reduced unnecessary xDS updates, while custom Ruby balancing added 15–20% headroom before bursts overwhelm machines; Stripe is now pursuing anomaly detection and smart routing.
Help AI Coding Agents Write Up-To-Date Code With Modern Golang Skills
AI coding agents often generate outdated Go patterns because older syntax dominates training data and new features fall past model cutoffs. To address this gap, the GoLand team released Modern Go Guidelines, an open-source set of skills and CLI tools covering Go 1.0 through Go 1.27. The tool inspects a project's go.mod file or a specific version flag to supply only the language features and standard library additions compatible with that environment. Using a progressive disclosure approach, the CLI provides concise rule identifiers via a list command and expands into before-and-after examples through an explain command. This mechanism minimizes token consumption while helping agents produce up-to-date, compilable code without modifying project files.
Ready for Go 1.27 on Day One
GoLand 2026.2 introduces day-one support for Go 1.27 language features, tooling improvements, and profiling capabilities. The Go 1.27 release adds generic methods, promoted field names in struct composite literals, improved function type inference, and a dedicated profile for detecting goroutine leaks. To assist with code maintenance, GoLand integrates official go fix modernizers directly into editor inspections, the Problems tool window, and optional pre-commit checks. Developers can capture, visualize, and analyze goroutine leak profiles alongside existing CPU, memory, and mutex profiles within the IDE. Additionally, updated Modern Go Code Guidelines provide AI coding agents with Go 1.27 context and API changes aligned with the version specified in go.mod.
How to Build Passwordless Auth With Twilio Verify in Go
The tutorial builds a passwordless authentication flow in Go that uses Twilio Verify to send and validate one-time passwords (OTPs) by SMS, avoiding the need for users to manage passwords. It defines a small net/http API with GET and POST handlers for "/" and "/verify": the first collects a mobile number and starts verification, while the second accepts the received code and displays the result. The setup covers Go 1.23 or later, module dependencies, dotenv configuration for the Twilio Account SID, Auth Token, and Verify Service SID, plus session handling for the phone number. The verification check calls Twilio's CreateVerificationCheck() and renders success or failure using templates; running go run main.go starts the server on port 8080 for testing.
Why Go is an Ideal Language for AI-Assisted Software Engineering
AI-assisted software development shifts the human bottleneck from writing code to reviewing, verifying, and maintaining generated code, while people still define architecture, service boundaries, safety, and reliability. The post presents Go as a language designed for software engineering and argues that its end-to-end platform—built-in formatting, testing, dependency management, security tooling, and a comprehensive standard library—gives teams and AI agents a consistent foundation. Go’s readability, explicitness, standardized syntax through gofmt, static typing, and single-binary portability are described as guardrails that make generated code easier to inspect, validate, and operate. It also identifies gopls, the rebuilt go fix with modernizers, profiling, execution tracing, and profile-guided optimization as tools for maintaining and tuning systems over time. The conclusion is that Go’s consistency and production-oriented tooling can help humans absorb high-volume AI output without sacrificing reliability, maintainability, or system integrity.
Bringing serverless functions closer to the speed of wire
Modal’s legacy I/O plane routed all function inputs and outputs through us-east servers, adding up to ~200ms of network latency for calls from other regions. The new geographically distributed I/O plane, available in four or more regions, reduces end-to-end function call latencies by roughly 80ms at p50. The redesign involved moving non-critical work to background async processing, minimizing shared storage interactions on the hot path, and rewriting the server layer in Go for better concurrency. The team evaluated Valkey but chose Redis 7.1 because engine CPU usage spiked aggressively on Redis 7.2 onwards during input queue load testing. Users can further optimize by selecting the nearest routing_region, keeping input and output payloads under 2MiB to avoid blob storage uploads, and batching small inputs to reduce network hops.
Enable on-demand expertise with Agent Skills in Genkit Go
Agent Skills in Genkit Go address the prompt-context problem caused by loading every procedure, guide, and document into an agent’s persistent context. The tutorial defines skills as discoverable knowledge packs organized around a SKILL.md file, whose frontmatter is exposed first and whose instructions, references, assets, and scripts are loaded through progressive disclosure when needed. It integrates the Skills middleware with Genkit’s wrapper architecture, scans SkillPaths for metadata, matches descriptions, and invokes the use_skill tool before injecting the selected skill into active context; Go examples use ai.WithUse during Generate or GenerateText. Recipe and image-restoration examples show skills activating for matching requests, while the post notes that the restoration skill may require several attempts because model behavior is non-deterministic.
Treating Pricing Changes Like Code Deploys
Thumbtack manages marketplace pricing by updating hundreds of thousands of bid settings stored in DynamoDB across service offerings. Previously executed through individual custom Go scripts, these pricing rollouts lacked automated runtime state tracking, dynamic database throughput pacing, and durable records for reliable rollbacks. To eliminate manual operational risk, engineering introduced a shared deployment-like engine that accepts declarative target states and executes pure Go transformation functions without direct I/O. The engine enforces idempotency, conducts dry runs with validation reports to S3, coordinates atomic DynamoDB updates with audit logging, and dynamically manages write capacity. This platform standardizes pricing updates into reviewable, resumable, and reversible operations that safely skip already written rows and check for production drift during rollbacks.
Build agentic full-stack apps with Genkit
Genkit Agents is an open-source, full-stack foundation for conversational AI and agentic applications, supporting TypeScript, Go, Dart, and Python. The Agents API packages message history, tool loops, streaming, persistence, and frontend communication behind a shared interface: agents can run in process or behind HTTP, and clients use chat() through remoteAgent(). Developers can choose client-managed state or session-store-backed snapshots, resume by session ID, branch from snapshot ID, stream text, custom state, and artifacts, and pause tools for human approval. The framework also supports detached long-running work, specialist delegation, persistence choices including in-memory, file, Firestore, and custom stores, plus an Agent Runner in the Developer UI. The Agents API is in preview for TypeScript and Go, with breaking changes possible in minor releases.
Build reliable multi-agent applications with ADK Go 2.0. Discover our new graph-based workflow engine, built-in human-in-the-loop, and dynamic orchestration
ADK for Go 2.0 introduces a graph-based workflow engine for composing multi-agent applications whose execution can classify, branch, fan out, gather results, pause for human input, retry, and loop. Graphs consist of typed nodes and routed edges, with constructors for functions, emitting functions, agents, tools, joins, parallel workers, state-bound nodes, dynamic orchestration, and nested workflows; a scheduler handles concurrency, persistence, backpressure, cancellation, and resumption. Its built-in human-in-the-loop primitive validates responses, supports handoff or re-entry, and can resume durably after process restarts, while agent modes and a unified node runtime align single agents with full graphs. The release is highly additive for ADK 1.0 users, though context and event APIs require mechanical migrations, and it provides workflow examples for basic, routing, dynamic, HITL, and complex graphs.
NilAway: Practical Nil Panic Detection for Go
NilAway is Uber’s static analyzer for detecting potential nil pointer dereferences in Go before they reach production, where nil panics have caused incorrect behavior, outages, and denial-of-service risks. It models nilability flows as global typing constraints over struct fields, function parameters, and return values, builds an implication graph, and uses 2-SAT-style reasoning with forward nilness and backward nonnil propagation to identify contradictions. The analysis is interprocedural, requires no developer annotations, and reports detailed flows, while acknowledging false positives when runtime invariants are not captured. In one Uber service logging more than 3,000 nil panics daily, NilAway identified a receive-from-closed-channel path; adding a nilness check reduced the reported panics to zero, and the tool was released as open source with comprehensive and changed-code onboarding options.
Build Cross-Language Multi-Agent Team with Google’s Agent Development Kit and A2A
The post presents a contract-compliance pipeline in which a Python agent uses Gemini to extract contract terms and a Go service applies deterministic corporate-policy checks. It connects the services with the Agent2Agent (A2A) protocol and uses Google's Agent Development Kit (ADK), including RemoteA2aAgent, to expose the remote validator as a local sub-agent in a SequentialAgent. A2A supplies discovery through Agent Cards at /.well-known/agent.json, JSON-RPC 2.0 messaging through message/send, typed Message Parts, and task states such as submitted, working, completed, and failed. Pipeline state is shared through ADK's ToolContext.state, with failures transitioning to MANUAL_REVIEW for human legal review when the Go service is unavailable. The accompanying open-source application demonstrates live handoffs, policy verdicts, and simulated network faults, while the conclusion emphasizes language independence, decoupling, resilience, and deterministic auditing.
Related topics
All topics →Weekly digest
The best engineering reads, once a week.