Loading…
Latest reads
Every post, summarised
Grounded summaries of engineering blogs, newest first. Each links to the original.
- 4,671 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
Modernizing SQL ETL in Lakehouse with Declarative Patterns
Databricks is extending declarative ETL patterns into the Lakehouse SQL Editor so SQL practitioners can define recurring transformations without a dedicated pipelines-oriented environment. The initial operations cover append-only updates, change data capture through AUTO CDC, and targeted batch overwrites through REPLACE WHERE; flows can be scheduled, triggered by upstream updates, run on demand, or orchestrated through SQL tasks in Jobs. APPEND tracks processed source data, AUTO CDC handles keys, sequencing, deletes, and SCD Type 1 or Type 2 results, while Enzyme can incrementally process changed data for REPLACE WHERE. In Lakehouse benchmark testing, Enzyme-powered REPLACE WHERE ran 3.4x faster and 2.5x cheaper than traditional REPLACE WHERE, while users can retain procedural SQL and later move to the Lakeflow Pipelines Editor for multi-file development, dependencies, validation, and deployment.
CUDA Python 1.0: Stable APIs, One Foundation, Full Platform Access
CUDA Python 1.0, released with CUDA 13.3, presents Python as a supported way to access the full NVIDIA CUDA platform. It addresses a fragmented ecosystem in which libraries used separate binding layers, complicating shared GPU memory, streams, and resource ownership, and forcing developers toward either CUDA C++ extensions or higher-level libraries. The release combines independently versioned components, including cuda.core, cuda.compute, cuda.bindings, cuda-pathfinder, and nvmath-python, with semantic-versioning and deprecation commitments. cuda.core supplies common Python objects for devices, streams, and buffers, allowing NVIDIA and external libraries to compose on shared resources, while cuda.bindings offers 1:1 CUDA C API coverage. The stack spans runtime services, tuned CUDA libraries, communication tools, and kernel-authoring systems, although some newer kernel languages remain experimental and outside the 1.0 guarantees.
Read your writes: WAIT FOR in PostgreSQL 19
PostgreSQL 19 introduces the top-level SQL command WAIT FOR, addressing stale reads that can occur when an application writes to a primary and immediately reads from an asynchronously replicated standby. After the write, the client or pooler obtains an LSN with pg_current_wal_insert_lsn() and sends it to the reading session, where WAIT FOR blocks until the requested WAL position reaches the selected stage. The default standby_replay mode makes the change visible, while standby_write, standby_flush, primary_flush, TIMEOUT, and NO_THROW provide other durability and error-handling choices. The command waits without holding a snapshot, avoiding a replay self-deadlock, and exposes related wait events in pg_stat_activity. The feature preserves asynchronous writes by making only reads that require read-your-writes consistency wait, though timeline changes after promotion require caution.
ClickGap: Autonomous QA for ClickHouse
ClickGap addresses defects that survive ClickHouse’s extensive CI, human review, and in-house automated review, including untested behavior, silent resource waste, and performance regressions. The autonomous QA daemon examines eligible merged pull requests against verified builds, uses separate bug and coverage analysts, and requires hypotheses to become executed tests. An adversarial reviewer and ten evidence gates check consequences, source citations, complete-file review, reproducibility, and other conditions before a report can be filed. Five months after launch, ClickGap had filed roughly 500 issues and opened around 200 coverage or fix pull requests; more than half of the issues were closed, with over 200 linked to a fix PR. The system’s central design goal is to make reports trustworthy rather than merely prolific.
Quantization-Aware Healing: a compressed, 4-bit model that outperforms its full-precision original
Structural compression and 4-bit quantization can reduce an LLM’s reasoning, mathematical, and coding capabilities, while conventional healing methods either require costly quantization-aware training or distill from an already degraded checkpoint. Quantization-Aware Healing (QAH) instead distills the original, full-size, full-precision model into a structurally compressed student running in MXFP4, using KL divergence over teacher logits. A chunked KL loss allows healing on documents up to 32k tokens within a fixed GPU memory budget. Applied to GPT-OSS 120B compressed to 60B parameters, QAH’s 4-bit model outperformed its 60B bfloat16 counterpart on 7 of 9 benchmarks, including gains of 7.4 points on AA-LCR and 5.6 on AIME 2025. In a separate comparison, QAH reached its peak about seven times faster than QAT and avoided QAT’s later 19-point collapse.
Ideas Worth a Longer Conversation: The JetBrains Research Podcast
The JetBrains Research Podcast investigates foundational software development and computer science questions through discussions with industry researchers. In team psychology, Cat Hicks demonstrates that collaborative culture and organizational belonging reduce developer anxiety around automated tooling while curbing the risks of overproduction pressure. Historical analysis by Tomáš Petříček shows that programming spans five competing cultures rather than pure specification implementation, explaining why automated code generation historically encounters limits. Regarding artificial intelligence evaluation, Ibragim Badertdinov details how SWE-rebench isolates model capability through dataset decontamination, leveraging the strict verifiability of software test execution for training feedback. Additionally, conversations with Alexander Kulikov and Anna Kogan examine how foundational mathematical understanding aids AI oversight and address adoption hurdles for open-source computer vision infrastructure.
Inside LinkedIn's cognitive memory agent for agentic personalization
LinkedIn built a cognitive memory agent to deliver personalized experiences across its recruiter workflows and hiring assistants. Interactions between recruiters and agents often reveal recurring preferences, such as candidate criteria, role adjustments, and task habits. To preserve and manage this state throughout the entire lifecycle, the system organizes user data into a multi-tiered memory architecture. This structure comprises conversational, semantic, episodic, and procedural memory tiers that track everything from ongoing sessions to cross-session behaviors and workflow methods. LinkedIn continues to research memory abstractions, dynamic session compaction, virtual file system storage layers, and robust evaluation approaches for attribution across complex multi-source application agents.
Open Table Formats Explained: Iceberg vs. Delta vs. Hudi
Open table formats add metadata layers over Parquet or ORC files in object storage, enabling ACID transactions, schema evolution, time travel, and database-like consistency for data lakes. Apache Iceberg uses manifests and manifest lists in a metadata tree, supports partition evolution without rewriting existing files, and creates immutable snapshots for auditing, rollback, and reproducible queries. Delta records atomic writes in an ordered transaction log with checkpoints and is closely associated with Spark, while Hudi uses record-level indexes for frequent updates, change-data-capture, and near-real-time ingestion. All three share core capabilities but differ in partition evolution, update and delete strategies, and multi-engine support; Parquet and ORC remain file formats rather than table formats. The overview recommends scheduled compaction, metadata maintenance, health monitoring, and a production-volume proof of concept when selecting a format.
Supercharge Auth with Signals and the New Okta Angular SDK
The updated Okta Angular SDK introduces fully standalone architecture, eliminating NgModules and wrapper functions in favor of standalone providers and functional guards. In an Angular v22 sample project, authentication is configured with the provideOktaAuth function without requiring a custom backend. Route security utilizes functional guards, while user and group data fetch flows are handled using rxResource alongside signal inputs. To support dynamic environments without requiring rebuilds or redeployments, the setup implements runtime configuration loading via provideAppInitializer and OktaAuthConfigService. Security is further bolstered by binding access tokens to browser key pairs using Demonstrating Proof of Possession alongside OAuth 2.1 and OpenID Connect protocols.
Red Hat OpenShift autoscaling with Cluster Autoscaler
Red Hat OpenShift supports compute scaling using Cluster Autoscaler integrated with the OpenShift machine API. The mechanism relies on paired ClusterAutoscaler and MachineAutoscaler custom resources to manage cluster-wide limits and per-MachineSet replica boundaries. Scaling decisions evaluate pending pods against node allocatable capacity and hypothetical node capacity annotations while respecting expander strategies like Random, LeastWaste, or Priority. Cluster Autoscaler checks for unnecessary nodes every 10 seconds, scaling down when utilization falls below configured thresholds and workloads can safely migrate. To mitigate provisioning delays, clusters can adopt overprovisioning via low-priority pause containers or use APIs like ProvisioningRequest and CapacityBuffer for predictive scaling.
Agent Observability: Monitoring Decisions, Not Requests
Agent observability captures the sequence of decisions an agent makes between model calls, not just request-level metrics, and is distinct from monitoring (health) and evaluation (quality). Unlike deterministic database systems, an agent can succeed at every step yet fail overall—for example, looping forever on a failed fix while spans report success. The primary artifact is a trace, a parent-child tree of spans covering agent invocations, model calls, tool executions, and memory reads and writes. OpenTelemetry GenAI conventions define span types like create_agent and execute_tool, but the standards are still in development and change frequently; vendor support includes Datadog, Honeycomb, and frameworks like LangChain and CrewAI. A reasoning trace layer on top of operational telemetry explains why an agent chose that path; in multi-agent systems the trace must span the full coordination chain, not one agent’s output.
The Email Verification API
The proposed Email Verification API lets a browser verify that a submitted email address belongs to the user without sending them away from the current form to retrieve an OTP or magic link. Its flow involves the user, browser, mailbox provider (issuer), and application server (verifier): after mailbox registration, the browser and issuer create a token that is submitted with the address and checked server-side. Implementation requires an email input, a hidden email-verification-token input with a session-bound random nonce, and token verification using the site origin as audience; a JavaScript package handles parsing, lookups, and signature checks. The proposal is currently limited to Chrome’s origin trial and Gmail mailbox verification, so the source recommends progressive enhancement and other verification APIs where unavailable.
Get in and out of the airport faster—and back to earning—with pickup codes
The post introduces pickup codes, a new airport process intended to reduce eligible drivers’ waiting time, simplify rider matching, and help them return to the road sooner. Instead of a standard airport trip request or the usual queue, an eligible driver may receive a Driver app alert, choose a dedicated pickup-code line, and meet the next rider there. The rider provides a unique 6-digit code, distinct from the 4-digit PIN used for some non-airport pickups; the driver enters it in the app before the rider and luggage enter the vehicle, confirming the match. Trip details appear after confirmation, while fare information is available after completion, although the fare and destination can be viewed beforehand through the Waybill link in Trip Guide. Availability and eligibility vary by airport and product type, and drivers can instead remain in the waiting lot for a Trip Radar request without affecting their acceptance rate.
Build a Serverless Video Chat Application with JavaScript and Twilio Programmable Video
This tutorial builds a basic browser-based video conferencing application with JavaScript, HTML, and CSS using Twilio Programmable Video. It targets desktop and mobile web browsers, requiring no installed client, and uses the Twilio Serverless platform to provide hosting and a public URL. The setup creates a Twilio Serverless project, configures ACCOUNT_SID, API_KEY_SID, and API_KEY_SECRET in .env, runs npm start locally, and deploys with twilio serverless:deploy; the client manages joining, participant video streams, disconnection, and participant counts. After deployment, users can open the generated index.html URL on separate devices or share it with others to see participants appear dynamically, while the conclusion notes additional Twilio Video capabilities such as recording, custom data tracks, screen sharing, and virtual backgrounds.
Wire It, Run It, Deploy It: AI Workflows in Gradio
AI applications are presented as pipelines that chain image, text, audio, and dataset operations, with intermediate values otherwise investigated through print-debugging. gr.Workflow turns these pipelines into graphs of typed nodes, served as a drag-and-drop canvas where each node runs independently and its result remains visible. Operators can be Python functions, Hugging Face Inference Providers models, Gradio Spaces, Hub dataset rows, or GPU-backed functions using ZeroGPU, while fan-out connections run multiple analyses or generations in parallel. The same workflow also exposes labeled outputs as REST endpoints callable through the Gradio client or curl, and can be deployed to Hugging Face Spaces with one command.
Whatever You Are Building, Auth0 Has a Plan
Authentication and identity requirements vary substantially as software organizations scale from solo builders to multi-brand enterprises. Building and maintaining authentication in-house frequently consumes valuable engineering cycles and incurs ongoing costs associated with security patching and edge cases. To address these distinct development stages, Auth0 structures its platform across Free, Essentials, Professional, and Enterprise tiers with differentiated B2C and B2B pricing. Early-stage and growing teams gain access to enterprise connections, SCIM user synchronization, and multi-tenant routing through Auth0 Organizations. Larger customer deployments utilize features like multi-app Single Sign-On and passwordless logins, which have driven reported outcomes such as a 20% conversion lift and a 66% reduction in identity management time.
Auth0, Made for Whatever You Are Building
Rapid application development with AI coding tools often produces unreviewed custom authentication logic that handles sensitive Personally Identifiable Information and regulatory requirements like HIPAA. Autonomous AI agents compound these security challenges by significantly widening an application's overall attack surface. Standardizing on Auth0 provides an established identity layer that integrates into agentic workflows via Claude plugins, an Auth0 MCP server, and standardized agent skill packages. This setup exposes Auth0 Management APIs and official documentation directly to AI agents, achieving integration times of three to four minutes according to Agent Experience metrics. Incorporating these pre-built patterns maintains security baselines while supporting scaling requirements across B2B plans for initial user bases up to 1,000 monthly active users.
STARFlow2: Bridging Language Models and Normalizing Flows for Unified Multimodal Generation
Existing multimodal models struggle with structural fragmentation, often sacrificing visual fidelity via discrete tokenization or breaking structural symmetry by pairing causal text generation with diffusion-based denoising. STARFlow2 addresses these limitations by leveraging autoregressive normalizing flows, which share the causal mask, key-value cache mechanism, and left-to-right structure of large language models. Built upon the Pretzel architecture, the system vertically interleaves a frozen pretrained vision-language model stream with a TARFlow stream through residual skip connections under a single causal mask. A deep-shallow flow design combined with a unified FAE latent space allows both text and continuous visual outputs to enter the key-value cache directly without re-encoding. Benchmark experiments validate strong performance across multimodal understanding and continuous image generation tasks.
From Prediction to Action: How to Turn AI Outputs Into Decisions
Salesforce addressed an operational challenge where sellers faced roughly 12,000 dashboards and over 20 applications outputting machine learning predictions without clear next steps. The engineering team reframed machine learning outputs as raw signals rather than standalone answers. To bridge the gap between assessment and action, they built a Next Best Action layer that combines model signals, business logic, and contextual institutional knowledge into actionable recommendations. They integrated this layer with an AI agent using Model Context Protocol (MCP) tool contracts, enabling dynamic discovery and explicit handling of missing data. Finally, rather than introducing a separate dashboard destination, the agent serves on-demand recommendations directly inside Slack where sellers already collaborate.
Your alt text passes automated checks. That doesn’t mean it’s any good.
Automated accessibility checkers reliably flag missing alt text attributes but frequently miss unhelpful descriptions like raw filenames or repetitive labels. To evaluate image description quality without generating excessive false positives, GitHub built an alt text plugin for the GitHub Accessibility Scanner. The tool combines five deterministic, zero-credential rules that evaluate strings and visual layout spacing with an opt-in vision model check for subjective context. Page context including headings and surrounding prose is extracted alongside images to guide the model using structured outputs and explicit anti-nitpick instructions. While deterministic checks catch unwritten text, the model-driven rule serves as an opt-in prompt for human review rather than an absolute verdict.
Top topics
- Architecture834
- Performance816
- LLMs660
- Machine Learning622
- Open Source563
- AI Agents553
- AI470
- Developer Experience448
Weekly digest
The best engineering reads, once a week.