Loading…
Browse by type
Tutorial reads
Tutorial posts on Yomu, summarised newest first.
- 615 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.
Tutorial posts
Orchestrate production RAG with OpenShift AI
This guide shows how to move a streaming retrieval-augmented generation (RAG) workflow from a monolithic Ray Data script to modular AI pipelines on OpenShift AI. It addresses failure recovery and run traceability by separating parsing and chunking, ingestion, model download, and deployment into five reusable components. Parsed and chunked JSONL is stored in S3-compatible storage so KFP can rerun ingestion without repeating document processing, and each run records parameters, timestamps, logs, and status. The data chain uses Docling’s HybridChunker and Ray map_batches with ActorPoolStrategy, while the model chain downloads a Hugging Face model and deploys it through vLLM and KServe in parallel. For embedding ingestion, the workflow supports local CPU processing with granite-embedding-125m-english or a dedicated GPU vLLM service for larger collections and offers notebooks for deployment and query validation.
Authenticating TeamCity Builds to External Services With OIDC
Static CI/CD credentials can leak through logs or artifacts, expose uncertainty over who copies them, and require rotation, so the article presents OIDC as an alternative for authenticating TeamCity builds. It explains the workload flow: an identity provider issues a signed JWT whose claims include validity, audience, and issuer, while the consuming service retrieves metadata and JWKS, verifies the signature, and checks those claims. The TeamCity OIDC JWT plugin makes the server an identity provider, supports RSA- or ECDSA-based signing, key rotation, configurable public issuer hosting, and extensions for HSMs or key-management services. After installation from JetBrains Marketplace, build configurations can issue tokens at startup or on demand, with default or fixed five-minute lifetimes, for direct presentation or token exchange with AWS, Google Cloud, and other OIDC services.
Developing LLM guardrail configs locally with NeMo Guardrails
The article presents a local workflow for developing and testing NeMo Guardrails configurations in a Jupyter notebook, avoiding repeated Kubernetes deployments and requiring no LLM, GPU, or cloud resources. It defines rails, configurations, and servers, then starts with a case-insensitive regex rail that blocks the exact phrase “ignore all previous instructions”; the test catches a direct attack but allows an accented “Ignóre” variant. A broader regex configuration is followed by a DeBERTa-based prompt-injection classifier and a manually assembled set of 13 prompts, producing 12 correct decisions out of 13, with one subtle attack allowed. The article recommends iterating locally, potentially layering targeted regexes before classifiers for fail-fast, defense-in-depth filtering, while noting that 13 prompts cannot meaningfully measure performance and pointing to standardized EvalHub evaluations as a next step.
Red Hat OpenShift autoscaling using MachineSet autoscaler with KEDA
The demonstration compares OpenShift MachineSet Autoscaler with KEDA against the previously used Cluster Autoscaler, using metrics to scale a MachineSet before pods remain pending. After installing Red Hat’s Custom Metrics Autoscaler operator (KEDA 2.19), granting permissions for MachineSet scaling and Thanos/Prometheus access, it creates a ScaledObject with a Prometheus trigger targeting demo-p4p95-worker-eastus3. Because a MachineSet has no pods, the HPA path cannot use metricType: Value, so AverageValue is paired with a PromQL query that multiplies CPU request utilization by the current node count. With nine one-CPU test pods, the MachineSet scaled from one to two to three nodes as the metric crossed 75%, and all pods reached Running; two additional Standard_D4s_v3 VMs were provisioned in zone 3.
How to disclose AI to customers without killing the conversation
Customer service teams may avoid disclosing AI because they fear customers will leave, but the post argues that unclear or delayed disclosure creates more frustration than honesty. It recommends a short first-turn greeting that says “AI,” explains what the agent can do, and offers an immediate route to a human, with renewed disclosure when a conversation moves to SMS or voice. Web chat, SMS, and voice examples show how to pair disclosure with an exit, while voice should disclose before the caller explains the issue and leave a pause. The post identifies burying the disclosure, using ambiguous labels, apologizing, over-explaining, and omitting escalation as failure modes. It proposes checking Twilio Conversation Intelligence transcripts alongside containment and escalation rates to assess wording changes, citing research on customer expectations and bypass behavior.
Complete guide to sending email to Google: Rules, signals & setup
Sending email to Google requires understanding differences between consumer Gmail and Google Workspace, plus the authentication and reputation signals used by Google’s filtering systems. The guide says SPF and DKIM are required for all senders, while DMARC is required for senders exceeding 5,000 messages per day to Google inboxes; it also gives a bounce example for missing alignment. It recommends keeping user-reported spam below 0.1%, never reaching 0.3%, and providing one-click unsubscribe handling. Google Postmaster Tools reports compliance, spam rate, authentication success, and delivery errors, while the Feedback-ID header enables aggregate complaint analysis by campaign or sender ID. Workspace administrators can apply additional filters, so successful delivery to Gmail does not guarantee placement in a corporate Workspace inbox.
Run NVIDIA BioNeMo NIM Microservices for Protein Structure Prediction in Claude Science
Claude Science is used with the NVIDIA BioNeMo Agent Toolkit and NVIDIA NIM microservices to investigate how the predicted Seh1 structure changes alone versus with proposed partner C1HCX1. The workflow retrieves UniProt sequences, generates unpaired and species-paired multiple-sequence alignments with MSA Search, and sends those inputs to OpenFold3 and Boltz-2 for independent monomer and heteromer predictions. Using MSA input, heteromer iPTM reached 0.85 for OpenFold3 and 0.82 for Boltz-2, versus 0.14 and 0.19 without it; five-sample runs had standard deviations no greater than 0.006. Both models placed partner β-strands at Seh1’s WD40 propeller closure, while core Cα-RMSD remained 0.68 Å and 0.65 Å, respectively, but the predicted interaction remains experimentally unverified.
Scale AV Perception Across Vehicle Platforms with NVIDIA Omniverse NuRec
Autonomous-driving perception changes when the same software moves across carlines because sensor placement, calibration, fields of view, occlusions, geometry, timing, and coverage change. The post presents NVIDIA Omniverse NuRec as a way to adapt a stack before a complete target-carline dataset exists, while retaining real-world data for grounding and validation. NuRec reconstructs recorded drives with 3D Gaussian splatting, renders novel views through a target rig with configurable camera models and calibration, and preserves trajectories, annotations, and map data for label adaptation. The workflow pairs a reconstructed scene with a rig, renders target views, refines frames with NVIDIA Harmonizer, and trains a perception model on the output. It also documents containerized rendering and auxiliary-data generation, including semantic masks, metric depth, and ego-vehicle masks, while noting that views outside observed coverage may be lower quality.
Fine-Tuning SOTA Object Detection Models on Real-World Datasets
This practical comparison examines how YOLO12, YOLO26, and RF-DETR behave when moved from COCO to specialized real-world object-detection datasets, and how fine-tuning changes the outcome. The authors first evaluate six pretrained checkpoints on COCO val2017, then use cable-damage, bone-fracture, and soda-bottles datasets from RF100-VL for zero-shot testing, fine-tuning, and accuracy/latency comparison. Because the model implementations require incompatible dependencies, the workflow uses one PyCharm project with three isolated uv environments and remote GPU execution; the reported latency stays in native frameworks rather than TensorRT. All models perform well on COCO, but direct performance on specialized data falls close to zero, while 10 fine-tuning epochs adapt the detectors well to cable damage and soda bottles. Bone-fracture remains difficult despite fine-tuning, with RF-DETR performing best, indicating that domain shift may require more data, longer training, or domain-specific pretraining.
AI-powered multicluster management: Querying fleet health with OpenShift Lightspeed and Red Hat Advanced Cluster Management
Managing modern large-scale Kubernetes fleets across distributed clusters can make troubleshooting slow because administrators must build manual search queries and sift scattered outputs. The post presents a Technology Preview MCP server for Red Hat Advanced Cluster Management that translates natural-language prompts into structured searches across managed clusters, deployed with Helm in the hub cluster. OpenShift Lightspeed is configured through its OLSConfig custom resource to call the MCP endpoint, use a Kubernetes service-account token for internal authorization, and optionally skip approval for read-only searches. The examples cover finding clusters below OpenShift 4.21, locating pods in a specified cluster and namespace, and identifying an unhealthy VM across the fleet; one result finds dev-vm in an ErrorUnschedulable condition and provides diagnostic guidance.
How to Approve Real Users and Block Fake Accounts at Sign Up with Lookup and Verify in PHP
The tutorial shows how to combine Twilio Lookup and Verify in a PHP sign-up flow that screens phone numbers before sending an OTP. It starts with Line Type Intelligence to accept mobile numbers, optionally checks reachability with Line Status, and uses Identity Match to compare submitted first and last names against authoritative sources without revealing underlying data. If those checks pass, the application sends a six-digit verification code and validates it through a Verify service. The provided implementation uses PHP 8.5, Slim, Twig, Monolog, and the Twilio REST client, with environment flags controlling optional checks and logs recorded in data/app.log. Testing covers mobile, toll-free, VoIP, and name-mismatch cases, while the pricing discussion recommends ordering cheaper checks before more expensive Identity Match and Verify calls.
How to Confirm Phone Number Ownership with Lookup Identity Match
The tutorial shows how to use Twilio Lookup Identity Match to confirm that a person is linked to a submitted phone number and reduce sign-up fraud. It describes a zero-knowledge match against authoritative sources such as mobile carrier records, with possible use during sign-up, login, account changes, or checkout. The implementation starts from an international telephone input project, collects first and last names alongside an E.164 phone number, and passes them to the Lookup API with the identity_match field; the response exposes per-field statuses and a summary score. The sample JavaScript treats the check as successful when the phone is valid and both names are exact or high partial matches, then displays the result, while the post also notes approval requirements outside the US, test parameters, and alternative Lookup packages.
Build a Video API with Twilio Programmable Video, Node.js, TypeScript, and Express
This tutorial builds an Express API for creating and managing Twilio Programmable Video rooms with Node.js and TypeScript. It sets up a project with Express, TypeScript 5, ts-node, node-dev, dotenv, and the Twilio Node.js helper library, while requiring Node.js 20 or 22 LTS. Twilio account credentials are stored in environment variables loaded from .env, which is excluded through .gitignore. The TypeScript configuration compiles strict CommonJS source from src into build and targets ES5; routes call the Rooms API to create rooms and complete them by changing status to completed, disconnecting connected participants. The result is a server-side room-management foundation, with access-token issuance identified as the next step for browser or mobile participants.
How to Approve Real Users and Block Fake Accounts at Sign Up with Lookup and Verify
Fake accounts and signup fraud can undermine onboarding, so the tutorial builds a Node.js flow that collects a user's name and phone number. It combines Twilio Lookup and Verify through four progressively intense checks: line type, line status, identity match, and SMS OTP possession. The implementation blocks landline, nonfixed VoIP, toll-free, and pager numbers, checks submitted first and last names against authoritative sources using exact_match or high_partial_match, and sends an OTP only after the lookup steps pass. Line status is optional in the example because access is in Private Beta, while the project uses Express, EJS, and environment variables for its Node.js setup. It also demonstrates expected outcomes for mobile, blocked, and mismatched inputs, then notes that pricing varies by country.
How to Confirm Phone Number Ownership with Lookup Identity Match in PHP
The post presents a PHP signup flow that uses Twilio Lookup Identity Match to confirm whether submitted identity details correspond to a phone number and to reduce signup fraud. Identity Match performs a zero-knowledge match against authoritative sources such as mobile carrier records, using supplied fields including names, addresses, national IDs, or dates of birth. The implementation builds on a Slim PHP project, adds Twig form handling and the Twilio REST client, then sends the phone number, first name, and last name through the Lookup API. Registration succeeds only when the number is valid and both names return exact_match or high_partial_match; otherwise, the form displays an instruction to provide information for a phone number the user owns.
Type-Safe Authentication in Rust with Auth0 and Axum
CLI applications cannot use a standard browser redirect OAuth login flow when no browser or redirect URL is available, so the tutorial uses OAuth 2.0 Device Authorization Flow. It builds an end-to-end Rust workspace containing a CLI, a shared auth-lib crate, and an Axum API configured with Auth0. The CLI requests a device code, displays a verification URL and user code, polls for an ID token and access token, then sends the access token as a Bearer credential. The API middleware fetches JWKS, selects the key matching the JWT’s kid, validates RS256 signatures plus issuer and audience claims, and deserializes strongly typed UserClaims. With valid claims, a protected route returns a message and subject; otherwise the extractor returns an unauthorized response.
Kentucky defensive driving course
Kentucky regulations require rideshare drivers to complete a two-hour driver safety training course each year, with collision prevention and safe driving habits as its focus. Starting June 25, 2019, drivers cannot receive trip requests in Kentucky through the Uber app until they upload a passing-course certificate to their account. The online course costs $15: drivers begin through the Online Training Center’s “New Partners” option, use the email address and phone number associated with their Uber account, and verify that the confirmation-page username matches the official name on their license. After training, drivers download the certificate or open the certificate page’s printable completion confirmation, then upload it to their Uber account; unfinished training can be resumed through the driver portal’s “My Courses” section.
Project Loom in IntelliJ IDEA: Virtual Threads, Scoped Values, and Structured Concurrency
Project Loom in IntelliJ IDEA introduces Java developers to three cohesive concurrency features: Virtual Threads (JEP 444, stable since Java 21), Scoped Values (JEP 506, stable since Java 25), and Structured Concurrency (JEP 533, seventh preview in Java 27). The post identifies pain points such as CompletableFuture ignoring interrupt flags, manual ExecutionException unwrapping chains, duplicated cancel() calls across catch blocks, mutable ThreadLocal pitfalls, and flat thread dumps lacking request hierarchy. A CustomerProfileService example is refactored from CompletableFuture.allOf to StructuredTaskScope.ShutdownOnFailure, where sibling tasks are cancelled automatically and a single timeout covers the whole scope. IntelliJ IDEA debugger support from version 2026.1 groups virtual threads forked within a StructuredTaskScope into containers representing their scopes, and the post walks through downloading JDK 27 (EA) and enabling the experimental language level.
How to Approve Real Users and Block Fake Accounts at Sign Up with Lookup and Verify in C#
Fake accounts and fraudulent sign-ups motivate a C# onboarding flow that screens phone numbers before sending an OTP. It combines Twilio Lookup line type intelligence, optional line status checks, and Identity Match with Twilio Verify phone verification. The pipeline rejects landline, nonfixed VoIP, toll-free, and pager types, requires first- and last-name results of exact_match or high_partial_match, and can reject lookup failures or mismatches. The post supplies a .NET 9 project setup, environment variables, MVC files, and service code for starting and checking verification. It reports example logs for a mobile number with active status and exact name matches, demonstrates blocked toll-free or VoIP testing, and notes that Lookup and Verify pricing varies by package and country.
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.
Top topics
- Architecture830
- Performance812
- LLMs648
- Machine Learning617
- Open Source561
- AI Agents542
- AI454
- Developer Experience446
Weekly digest
The best engineering reads, once a week.