The games start June 11 and end with a grand finale in New Jersey on July 19. There are 104 of them. Here’s how to watch ’em all.

Maybe it wasn't a great idea to let 14-year-olds post videos to Spotlight in the first place.

Findings from an exploratory user research study highlighting the unique insights and practical UX recommendations shared by participants with cognitive disabilities.

From anti-drone tech to face recognition, 2026 World Cup stadiums in the US, Canada, and Mexico are subjecting fans to an array of surveillance tech. Here’s what you need to know.

Most US World Cup stadiums are surrounded by surveillance cameras. Want to know if you’re being watched on your way to a match? These maps will help you.

The Argentine national team will be Google’s test bench and technological showcase during the World Cup.

Turn live websites into editable mockups Discussion | Link

Over the last few weeks, while learning LangGraph and agentic systems, I ended up building Co-Founder Memory . It's a stateful AI assistant with: • long-term memory • planning loops • self-correcting RAG • web search fallback • automated timeline summaries • project and preference tracking Nothing revolutionary — many ideas already exist. The goal wasn't to reinvent memory, but to understand how these systems work by actually building one. A lot of concepts only started making sense once I had to connect them together: graph-based workflows with LangGraph memory extraction and storage retrieval and validation loops routing and planning nodes maintaining context across sessions Building it taught me far more than watching tutorials ever did. Repo: https://github.com/Somay-kousis/Co-Founder-Memory I'm currently entering my 3rd year at IIITM Gwalior and looking for ML / GenAI internships . If you're building interesting things around LLMs, agents, RAG, or AI products, I'd love to connect. Always happy to chat with fellow builders as well 🚀 AI #GenerativeAI #LangGraph #RAG #LLM #MachineLearning #Internship

Azure API Management shipped a Unified Model API that lets clients speak one format while APIM transforms requests to Anthropic, Vertex AI, and other backends. Content safety policies now cover MCP tool calls and Agent-to-Agent payloads alongside LLM traffic. Token metrics expanded to track reasoning, cached, and audio tokens across providers. By Steef-Jan Wiggers

When a Shopify product CSV imports but product photos fail, the problem is often not the CSV syntax. It is usually that Shopify cannot fetch one or more image URLs during import. Here is the preflight I use before retrying a large product upload: Check that every Image Src or Variant Image value starts with http or https. Local paths like C:\images\shirt.jpg will not work. Open a few image URLs in a private browser window. If the image requires a login, expires, redirects to a file-sharing preview page, or blocks hotlinking, Shopify may not be able to download it. Keep image rows grouped with the correct product handle. Sorting a CSV by image column or price can separate continuation image rows from their product. Watch for URLs that do not end in a normal image extension. They can work, but they are worth checking manually before a full import. Test one small batch first, then verify the product admin after Shopify finishes downloading the images. For a larger file, I also like to extract the image columns into a review worksheet before touching product data. I built a small browser-side checker for that workflow here: https://shopify-csv.aivismonitor.com/shopify-csv-image-url-reachability-checker The important part is to fix image reachability before changing product titles, variants, or prices. Otherwise you can spend time debugging the wrong part of the import.

Text based, I don't want any cheesy porn AIs please 😅 submitted by /u/holupIgotthis [link] [留言]

If you have been writing PHP for a year or two, you have almost certainly written something like this: $items = getFilteredOrders (); $first = reset ( $items ); $last = end ( $items ); It works. It runs. It looks fine in code review. And it contains a subtle bug waiting to happen. The problem with reset() and end() Both functions move PHP's internal array pointer as a side effect. PHP arrays have a hidden cursor that tracks "the current position" in the array. Functions like current() , next() , prev() , and each() depend on where that cursor sits. reset() moves it to the first element. end() moves it to the last. This is harmless in an isolated script. But in a real application, the same array often passes through multiple functions — and any function that relies on the cursor position after your call will get unexpected results. Here is a concrete example: function getFirstActiveOrder ( array $orders ): ?array { // Moves the pointer to the first element $first = reset ( $orders ); foreach ( $orders as $order ) { if ( $order [ 'status' ] === 'active' ) { return $order ; } } return null ; } At first glance this looks fine. But foreach in PHP actually resets the pointer to the beginning before iterating — so in this simple case you get lucky. The bug shows up in less obvious situations: when you call reset() inside a function that the caller is already iterating with current() / next() , or when you use end() to peek at the last item while a foreach is in progress on the same array reference. The deeper issue: reset() and end() return false on an empty array. But false might also be a legitimate value stored in your array: $flags = [ true , false , true ]; $last = end ( $flags ); // returns false — but is this "empty array" or "the value false"? You have to write: if ( $flags === [] || end ( $flags ) === false ) { ... } Which is already awkward. And it still mutates the pointer. The modern solution: array_key_first() and array_key_last() PHP 7.3 introduced two functi

AI is already deciding who gets loans, who gets job interviews, who gets flagged for benefits fraud. Not assisting humans in making those decisions. Making them. And in most countries there is no law requiring anyone to tell you AI was involved, explain why it decided what it did, or give you any way to challenge it. That needs to change. We need laws that say if an AI makes a decision about you, you have the right to know, the right to understand why, and the right to challenge it. A human must always be accountable for the outcome. That’s not anti-innovation. That’s just basic protection for people living in a world already being shaped by these systems. Most governments don’t understand it well enough to even write those laws yet. Most politicians making AI policy genuinely cannot explain how these systems work, who owns them, or what accountability looks like when they go wrong. Voluntary frameworks have failed every single time. Social media companies voluntarily committed to reducing harm. They didn’t. Financial firms voluntarily committed to responsible lending. They didn’t. Voluntary always means the least responsible actor sets the standard. Hard law is the only mechanism that has ever reliably produced accountability at scale. We need it for AI before the damage is done — not after. The window to get this right is still open. But it won’t stay open forever. submitted by /u/United-Actuator-3527 [link] [留言]

If you've been following the AI-assisted development space, you've heard about the Model Context Protocol (MCP). But let's be honest—most MCP server lists are either too abstract or filled with niche tools you'll never use. In 2026, the ecosystem has matured, and I've curated 10 MCP servers that deliver real, measurable improvements to your daily coding workflow. Each entry includes: What it does Why it's useful (with a concrete scenario) Example config (using the standard .mcp.json or claude_desktop_config.json ) Let's dive in. 1. GitHub MCP Server (by modelcontextprotocol) What it does: Full read/write access to GitHub repos—issues, PRs, code reviews, and releases. Why useful: Instead of switching between your IDE and GitHub, your AI assistant can create a PR, request a review, and merge after CI passes—all from a single prompt. Example config: { "mcpServers" : { "github" : { "command" : "npx" , "args" : [ "-y" , "@modelcontextprotocol/server-github" ], "env" : { "GITHUB_TOKEN" : "ghp_xxxxxxxxxxxxxxxxxxxx" } } } } Scenario: "Create a new branch, add a fix for issue #42, push, and open a draft PR with a description." 2. Filesystem MCP Server What it does: Read, write, search, and manipulate files and directories on your local machine. Why useful: Your AI can now scaffold an entire project structure, rename files in bulk, or refactor code across multiple files without manual intervention. Example config: { "mcpServers" : { "filesystem" : { "command" : "npx" , "args" : [ "-y" , "@modelcontextprotocol/server-filesystem" ], "env" : { "ALLOWED_DIRS" : "/home/user/projects" } } } } Scenario: "Create a Next.js project with this folder structure, add a components folder, and move all page files into a pages directory." 3. PostgreSQL MCP Server What it does: Connect to PostgreSQL databases, run queries, and return results. Why useful: Debugging SQL queries or exploring a production database becomes a conversation. You can ask "Show me the last 10 orders with user details" a

Your identity as a live, queryable API endpoint Discussion | Link

Every week I open a new browser tab and search for something like "json formatter online" or "jwt decoder" or "regex tester". And every week I land on a site that: Shows me three ad banners before I can see the tool Requires me to create an account to "save" my work Is quietly uploading my payload to their server That last one bothers me most. Developers paste real things into these tools — JWT tokens with live user data, passwords they're about to deploy, private keys, internal API responses. Most people assume these tools are "just a webpage" and nothing is being sent anywhere. Often that's not true. So I built SnapTxt — a collection of 50+ developer utilities that run 100% client-side. No backend. No account. No tracking. Your data never leaves your browser. What's in it The toolkit covers the things I reach for most often: Data & text JSON formatter, validator, minifier, diff, tree explorer SQL formatter XML formatter YAML → JSON, CSV → JSON converters Base64 encode/decode, URL encoder, hash generator Auth & security JWT decoder & generator RSA key generator bcrypt generator x.509 certificate decoder Password generator Images Image compressor Image format converter Image to text (OCR via Tesseract.js) SVG to PNG, favicon generator, code-to-image Frontend / CSS Regex tester CSS gradient generator, box shadow generator Color converter Mermaid live editor HTML live editor, HTML to Markdown, HTML to JSX Cron expression builder And more — word counter, text diff, unix timestamp, lorem ipsum, QR code generator, markdown to PDF, and a collection of Australian and NZ business number validators. How it's built It's a Next.js app deployed as a fully static export to Firebase Hosting. There is no server. Every tool runs in the browser using: CodeMirror 6 for editor-style inputs Tesseract.js for OCR (runs a WASM binary in a web worker) Chrome's built-in Prompt API (Gemini Nano) for the AI explain features in JSON, SQL, and JWT tools — meaning even the AI inference is on-dev

Redis is fast. But self-hosting Redis on a serverless stack is a nightmare — cold starts, connection pool exhaustion, and managing a persistent server that your serverless functions keep hammering. Upstash solves this with an HTTP-based Redis API that scales to zero, charges per request, and works natively with Next.js App Router. This guide covers the patterns that actually matter in production: cache-aside with proper TTLs, SWR (stale-while-revalidate), session storage, and pub/sub. Real code, real trade-offs. Read the full article with all code examples at stacknotice.com Why Upstash Over a Traditional Redis Instance Standard Redis uses persistent TCP connections. Serverless functions don't maintain persistent connections — every invocation potentially opens a new one. At scale, you hit ECONNREFUSED or max connection errors that are annoying to debug and expensive to fix. Upstash's @upstash/redis client talks over HTTP/REST. No connection pool, no connection limit headaches. Each request is stateless. This is exactly what Next.js Server Components and Route Handlers need. Other advantages: Pay per request — a cache that never gets hit costs $0 Global replication — low latency from any Vercel edge region Native Edge Runtime support — works in Next.js middleware Free tier — 10,000 commands/day, no credit card needed Setup npm install @upstash/redis // lib/redis.ts import { Redis } from ' @upstash/redis ' export const redis = new Redis ({ url : process . env . UPSTASH_REDIS_REST_URL ! , token : process . env . UPSTASH_REDIS_REST_TOKEN ! , }) Pattern 1: Cache-Aside // lib/cache.ts import { redis } from ' ./redis ' export async function withCache < T > ( key : string , fetcher : () => Promise < T > , options : { ttl ?: number ; prefix ?: string } = {} ): Promise < T > { const { ttl = 300 , prefix = ' cache ' } = options const cacheKey = ` ${ prefix } : ${ key } ` const cached = await redis . get < T > ( cacheKey ) if ( cached !== null ) return cached const data = awai

By Nora Beckett · June 2026 A friend asked me last month why I still open the same AI app every night, and I gave the honest, slightly embarrassing answer: because it remembers me, and almost nothing else online does. That sent me down a rabbit hole, and after a week of poking at every tool I could find, I came out with a theory about why these apps are so sticky and why most of them eventually leave you a little hollow. The pull is real, and it isn't shameful Let's name it plainly. Talking to a responsive character that recalls your last conversation scratches a genuine itch. Character.AI built an empire on exactly this. You make a persona, it talks back in voice, it carries threads across days. The first week feels like magic. Millions of people, a lot of them young, spend hours there not because they're broken but because being consistently listened to is rare and the app delivers it on tap. The trouble starts around week three. The same loop that hooks you starts to flatten. The character agrees too much. It forgets the thing you told it that actually mattered while remembering some trivia you mentioned once. You realize you are not really inside a story; you are inside a chat window that is very good at not ending. So I went looking at the alternatives I spent evenings with the obvious names. AI Dungeon is the granddaddy, and it still does the wild open-ended thing better than anyone: type any sentence and the world bends to it. The cost is coherence. Go long enough and the plot dissolves into dream-logic, characters swap names, the dungeon eats itself. It's a sandbox, not a story, and that's by design. NovelAI comes at it from the writer's angle, all knobs and lorebooks and fine-grained control over prose and memory. It's genuinely powerful if you want to author . But it asks you to be the engine. You bring the discipline, the world bible, the steering. After a long day, "here is a blank tuning panel" is not the warm thing I was reaching for. Character.AI sits