Loading…
Latest reads
Every post, summarised
Grounded summaries of engineering blogs, newest first. Each links to the original.
- 4,668 posts
- 20 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.
Latest posts
Avoid Sending SMS to Landlines in PHP with Twilio's Lookup v2 API
SMS has a 98% open rate and works without internet, but sending to landlines wastes money on failed deliveries. This tutorial demonstrates filtering landlines in PHP using Twilio’s Lookup v2 API, which provides line type intelligence via the “line_type_intelligence” field. The core class extends PHP’s FilterIterator and overrides the accept() method to fetch each number’s line type, returning true only for “mobile” types and catching TwilioException on failure. The application uses Composer dependencies including monolog, twilio/sdk, and phpdotenv, loads credentials from a .env file, iterates over an ArrayIterator of phone numbers, logs each with Monolog to stdout, and sends an SMS only to mobile numbers. This approach avoids unnecessary charges and is straightforward using Twilio’s PHP helper library and SPL iterators.
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.
Supercharge your development with the Google Developer Knowledge API ecosystem
The Developer Knowledge API is Google’s official, programmatic source for developer documentation across Google Cloud, Firebase, and Android. It replaces web-scraping with a structured API serving fresh Markdown-formatted documentation, offering semantic and keyword search, intelligent document chunking, and grounded Q&A. The ecosystem includes a gcloud CLI surface that integrates search and grounded Q&A into terminal environments without extra plugins. An agent skill uses the standard MCP integration to connect AI assistants such as Claude Code, Cursor, and GitHub Copilot to up-to-date documentation. Multi-language client libraries enable programmatic access with features like BatchGetDocuments for retrieving up to 20 documents in one call.
The lakehouse is a better data warehouse: 2026 benchmarks and proof
The data warehouse served structured SQL workloads for two decades, but the lakehouse now supports BI, data engineering, ML, streaming, and AI agents from a single governed platform. Databricks reports a 77% improvement in its production SQL workload mix since 2022, with customer migrations showing 90% faster queries (Lumen) and 80-90% faster analytics (Trek Bicycle). Lakehouse//RT delivers sub-second analytical queries at high concurrency directly on governed lakehouse tables, with Databricks reporting sub-100-ms latency at 12,000 queries per second, collapsing the traditional architecture of separate serving databases. The lakehouse eliminates data copying between systems, handles unstructured data, and runs on open formats like Delta Lake and Apache Iceberg, governed by Unity Catalog. Customer cost reductions range from 25% to 75%, with AXA Japan reducing warehouse costs by 60% and ETL costs by 70%, driven by eliminating redundant systems and data copies.
Building Git infrastructure for agent-scale development
GitHub is rebuilding its Git infrastructure to handle agentic development, where agents push millions of commits daily and total activity doubled to 473.3 billion events per month. The current Spokes architecture couples durability with scale by storing full repository copies on local disks and using a quorum for writes, making writes slower as read replicas are added. Key challenges include commit turnaround latency per agent, write throughput up 4.9x year over year, merges contending on a single reference, and CI fan-out multiplying each push into thousands of reads. The new design separates storage from compute, using Azure Blob Storage for durability and lightweight workers for reads, shrinks the critical path by coordinating only reference updates, and moves maintenance off the serving path. Internal benchmarks show up to 35 times higher write throughput with independently scaling read capacity, while preserving existing workflows, branch protections, and audit controls.
Scale Bitwise-Deterministic Pretraining with NVIDIA Megatron Core
Bitwise determinism ensures independent and checkpoint-resumed training runs follow the same numerical trajectory, providing four key benefits: replaying failures, preserving checkpoint continuity, detecting unexpected differences, and comparing changes without run-to-run variation. At trillion-parameter scale across thousands of GPUs, nondeterminism complicates failure reproduction and fix validation. NVIDIA Megatron Core targets two guarantees: independent reproducibility and bitwise checkpoint resume. The post describes a validation procedure using full-precision metrics and a progressive tracing workflow that uses torch.hash_tensor for GPU-resident fingerprints to narrow divergence from end-to-end metrics to the responsible kernel. A Nemotron case study demonstrates that kernel optimizations, such as separating grouped-GEMM writers and applying a fixed reduction order, can reduce the determinism performance overhead to approximately 2% steady-state determinism tax at scale.
Expanding the Cyber Verification Program
Anthropic is expanding its Cyber Verification Program (CVP) to make advanced AI models with reduced safeguards available to qualifying security professionals. The program now offers three access tiers—Defense Access, Red Team Access, and Specialized Access—each with different verification requirements and security controls. Defense Access allows defensive work like incident response and vulnerability analysis, while Red Team Access adds authorized penetration testing. Specialized Access, with the fewest cyber blocks, is reserved for organizations testing high-risk safety systems and is reviewed in collaboration with the US government. Evaluations on CyScenarioBench showed that the Red Team Access tier did not block any tasks and achieved a 68% success rate, equivalent to no safeguards, while the Defense Access tier blocked 46 of 50 tasks.
How DOCA GPUNetIO Unifies GPU-Initiated Networking Across the NVIDIA Software Stack
NVIDIA DOCA GPUNetIO is a GPU-centric networking SDK that enables CUDA kernels to drive Ethernet, RDMA, Verbs, and DMA operations with the CPU removed from the application critical path. It unifies previously fragmented GDA-KI-style RDMA implementations from libraries such as NCCL, NVSHMEM, UCX, and the Aerial 5G SDK into a single shared foundation. The framework provides both a full DOCA SDK version and a lighter open-source Verbs-focused implementation; the open-source version can optionally dlopen the SDK at runtime. On the data path, CUDA kernels directly post Work Queue Entries, ring the NIC doorbell, and poll for completions without CPU intervention. Benchmarks using NVSHMEM show that the GPU-initiated path avoids the CPU proxy bottleneck, achieving higher bandwidth for small message sizes compared to CPU-mediated communication.
The keys to the Internet change on October 11. Are you ready?
On October 11, 2026, the DNS root will replace its DNSSEC key-signing key (KSK) for only the second time, moving from KSK-2017 to KSK-2024. The rollover changes the trust anchor that validating resolvers use to verify the root’s DNSKEY records. Cloudflare has published KSK-2024 in the root’s DNSKEY set since January 11, 2025, and added it to its own resolver’s built-in trust anchors in July 2024. To help operators check readiness, Cloudflare uses RFC 8509 root key trust anchor sentinels, which let a resolver report whether it trusts a given key. Most website operators need no action, but DNSSEC-validating resolvers should confirm they trust KSK-2024 before the switch.
AICR v1.0: Open, stable, and verifiable GPU cluster configuration
GPU-accelerated Kubernetes clusters depend on compatible versions across host kernels, GPU drivers, container runtimes, networking, storage, operators, and workload frameworks, each on its own release cycle. A configuration that works for one service, GPU generation, and Kubernetes release may silently fail for another, and tracing version conflicts after deployment is slow. NVIDIA AI Cluster Runtime (AICR) v1.0 addresses this with version-locked, validated recipes that pin component combinations, render deployment artifacts for Helm, Argo CD, Flux, or Helmfile, and carry signed validation evidence from tested hardware. The release establishes a stable compatibility contract across its CLI, REST API, Go SDK, bundle layout, and artifact schemas, with merge-blocking checks on public interfaces. AICR now has over 100 contributors, with almost half from outside NVIDIA, and integrations from Pulumi Labs and Mirantis demonstrate consuming the same configuration through different tools.
NTS: Authenticated Time at Meta
Meta launched NTS (RFC 8915) authentication for its public time service at nts.meta.com, enabling clients to verify the origin and integrity of time packets. The service separates key establishment over TLS 1.3 from authenticated NTP, with cookie keys derived daily from a shared secret so servers hold no per-client state. Shortening TLS certificate lifetimes to 100 days in 2027 and 47 days in 2029 makes automated certificate renewal increasingly essential, creating a dangerous circular dependency on an authenticated clock. Meta open-sourced its NTS implementation and encourages mobile OS vendors to add client support, as Android and iOS currently sync time over unauthenticated UDP. The protocol does not prevent delay attacks, and device bootstrapping remains circular since NTS-KE requires TLS validation that itself demands a correct clock.
Meta’s ads MCP server comes to Databricks: Put your customer intelligence to work in advertising campaigns
Meta’s ads MCP server, now in Databricks Marketplace, connects Meta Ads Manager tools with enterprise data through Genie for natural language campaign management. The server uses the open MCP standard to expose over 25 tools across the campaign lifecycle including creating campaigns, adjusting budgets, defining audiences, and pulling performance data. Marketers can prompt Genie One to use business data like churn scores and gross margins, for example identifying high-value customers at risk of leaving and launching a retention campaign with an $8,000 daily budget. Governance is enforced server-side: Databricks administrators control access via Unity Catalog while Meta advertisers set rules in Business Settings that block actions like budget increases over 20%, with every tool call checked before execution. The integration builds on the Meta Conversions API partnership, letting agents combine signal diagnostics with Databricks models to put customer intelligence directly into campaign operations and execution.
Control How Your GPU Shares Work with Green Contexts
Green contexts, available in the CUDA Driver API since 12.4 and the Runtime API since 13.1, let applications explicitly partition GPU execution resources such as SMs and workqueues. They are lightweight to create and destroy, do not implicitly synchronize unrelated work, and allow provisioning workqueues to reduce false dependencies. Streams are created from a green context rather than relying on implicit device state, making targeting explicit. Benchmarks on a Blackwell GPU show a critical kernel completing in 0.007 ms with green context partitioning, compared to 0.140 ms with high-priority streams and 3.727 ms with equal priority. The tradeoff is fewer SMs for the bulk workload, but green contexts are opt-in and can be adopted incrementally alongside existing CUDA code.
The results of the 2026 Developer Survey are here!
The 2026 Developer Survey gathered responses from over 30,000 developers over seven weeks, covering work patterns, technology usage, and AI adoption. Only 18% of developers work in an office daily, and the share of solo developers rose from 4% to 10%, possibly reflecting AI-enabled solopreneurship. In technology rankings, SQL surpassed HTML/CSS for the second spot, while Rust climbed to 12th most used language, potentially influenced by memory safety advocacy. AI usage is widespread: 73% of AI tool users employ them daily, with Claude Code (66%) and GitHub Copilot (59%) as leading agents, primarily for code generation (67%) and debugging (61%). Developers prioritize quality over cost (75% vs 38%) when using AI, and organizations implement cost controls like usage limits (38%) and model routing (27%), though 21% report increased spending.
Declarative clusters: GitOps deployment of hosted control planes on Red Hat OpenShift Virtualization
Hosted control planes for Red Hat OpenShift, based on the HyperShift project, decouple the cluster control plane from worker nodes by running control-plane components as pods inside a central management cluster. On bare-metal infrastructure, OpenShift Virtualization provisions worker nodes as virtual machines, enabling live migration and reducing hardware requirements. The article presents a declarative GitOps workflow using Helm templates and an Argo CD ApplicationSet that dynamically generates deployments from tenant-specific YAML configuration files in Git. Prerequisites include a bare-metal management cluster with OpenShift Virtualization, Red Hat Advanced Cluster Management, and OpenShift GitOps, plus networking configured with NMState, Multus CNI, and MetalLB. The approach achieves a “Cluster-as-a-Service” model where provisioning a production-grade cluster requires only a Git push.
Rossoctl for agent discoverability, security, and observability on Kubernetes
Agent sprawl arises when many AI agents on Red Hat OpenShift become redundant, insecure, and untraceable, using static API keys over HTTP and lacking visibility into reasoning failures. Rossoctl, a Kubernetes-native controller, automates discovery by declaring AgentRuntime resources that fetch metadata to create AgentCard custom resources, and uses a two-phase Helm deployment to resolve the URL dependency between routes and AgentCards. It adopts the A2A protocol, which standardizes agent interaction through a machine-readable AgentCard at /.well-known/agent-card.json and a JSON-RPC interface for consistent payloads. Security follows a six-layer zero-trust model: SPIRE issues short-lived certificates, Istio enforces mTLS, AgentCards are signed with JWS, and AuthBridge provides scoped OAuth2 tokens. Observability uses opt-in MLflow tracing that captures orchestration flow, tool calls, and model latency, enabling diagnosis of semantic failures such as hallucinations or data leaks that standard metrics miss.
Why Databricks can’t match ClickHouse Cloud for real-time analytics
The CostBench benchmark streamed 113.2 billion stock-market quotes at one million rows per second while running aggregate and drill-down queries to compare ClickHouse Cloud and Databricks for real-time analytics under continuous ingestion. ClickHouse Cloud delivered 752× better end-to-end performance per dollar than the Databricks stack using Serverless SQL, Zerobus Ingest, liquid clustering, and incremental materialized views. ClickHouse Cloud led in all three components: preparation cost ($28.69 versus 695.60), normalized query cost ( 0.05 versus $2.65), and accumulated query runtime (56.39 seconds versus 29.10 minutes). The gap stems from ClickHouse preparing ordered raw data and current summaries on the insert path, while Databricks requires separate clustering and refresh services that cost more and can leave queries with unfinished layout work. Databricks’ new Lakehouse//RT, still in beta, was not included in this comparison.
Our Framework for Reviewing AI-Generated Code
JetBrains Research, in collaboration with Lund University, studied how to review AI-generated code as AI agents produce thousands of lines across multiple files quickly. The core problem identified is trust calibration: developers cannot gauge an LLM’s confidence per line, making line-by-line review unscalable. The study proposes a three-level conceptual framework: overview for high-level hypotheses, file-level risk stratification, and code snippet-level chunk decomposition with chain-of-thought linkage. This framework was developed through participatory design with 17 practitioners and a follow-up survey of 43 professionals, and will be presented at ESEIW 2026. The paper argues that current diff viewers are inadequate for AI-generated code and that tools must surface risk and confidence signals at the granularity where developers allocate attention.
Scaling and Operating a Large dbt Project on Databricks: IFCO's Data Team on Performance, Visibility, and Debugging
IFCO’s data platform team, with Databricks Forward Deployed Engineering, optimized a large dbt project on Databricks to handle billions of daily tracking events for reusable packaging assets. The pipeline faces scale, unpredictable late-arriving data, and the need to reconcile history when late events change previously reported asset timelines. The team tuned incremental model settings to match Delta Lake write behaviors, including liquid clustering, deliberate merge vs. delete+insert strategies, and bounding writes to recent ingestion windows. Diagnosing performance from actual query plans rather than compiled SQL revealed that the consolidation model was scanning far more rows than necessary. These changes cut the core semantic layer job’s daily runtime by over 60 percent, retired a costly nightly full refresh, and reduced daily compute cost by 58 percent.
Java and Kotlin by IntelliJ IDEA: The LSP-Based Extension Reaches Release Candidate
JetBrains announced that Java and Kotlin by IntelliJ IDEA, an LSP-based extension, has reached Release Candidate stage. The extension brings IntelliJ IDEA’s Java and Kotlin language intelligence to third-party editors like VS Code and Cursor. Since the preview, it has been downloaded over 20,000 times and includes features such as smart code completion, navigation, inspections, quick-fixes, project-wide refactorings, DAP-based debugging, Maven, Gradle, and Bazel project support, built-in test running, and Spring tooling interoperability. The RC is the final EAP build and will be available for 30 days without a license; after the stable release, a 30-day free trial will be offered, then an IntelliJ IDEA Ultimate subscription is required. The extension also makes its intelligence available to coding agents in Cursor, enabling semantic code search and analysis.
Top topics
- Architecture834
- Performance815
- LLMs659
- Machine Learning621
- Open Source563
- AI Agents553
- AI469
- Developer Experience448
Weekly digest
The best engineering reads, once a week.