Announced at WWDC 2026, the latest SwiftUI release brings a new Document protocol for efficient disk access and snapshot-based updates, along with improved APIs for reordering items in lists, grids, and sections. In addition, it expands presentation features, such as swipe actions on any view, better AsyncImage caching, and lazy state initialization for Observable types to boost performance. By Sergio De Simone

GitHub had 20,000+ secret scanning alerts across 15,000 repositories. Here's how we separated signal from noise, built remediation workflows, and reached inbox zero in nine months. The post How GitHub used secret scanning to reach inbox zero appeared first on The GitHub Blog .

submitted by /u/JohnTurturrosSandals [link] [留言]

Coding agents don't have long-term memory. But you do have months of full-fidelity agent transcripts stored on your machine. A simple solution that goes a long way: ingest those transcripts and logs into a structured SQLite database, then search them with ranked text match. Everything is fully local and doesn't require anything fancy like a graph database or hosted memory service. This is the idea behind ctx, a Rust CLI that handles the ingestion and searching. We give our agents a skill that te

Create your own Mac apps by chatting with AI Discussion | Link

You've probably written a CommandExecutor before. Everyone who's touched Bukkit has. Declare the command in plugin.yml , implement onCommand , cast args[0] to whatever you need, hope nobody fat-fingers the input. It compiles. It runs. It's confusing to debug. And it's the wrong way to do it in 2026. # plugin.yml commands : punish : description : Opens the punishment GUI usage : /punish <player> public class PunishCommand implements CommandExecutor { @Override public boolean onCommand ( CommandSender sender , Command command , String label , String [] args ) { if (!( sender instanceof Player staff )) return true ; if ( args . length < 1 ) return true ; Player target = Bukkit . getPlayer ( args [ 0 ]); if ( target == null ) { sender . sendMessage ( "Player not found." ); return true ; } // ... open the GUI return true ; } } Tie it together in onEnable() with getCommand("punish").setExecutor(new PunishCommand()) , add a separate TabCompleter implementation to handle suggestions, and you're done. Seems perfectly fine... totally not confusing at all... (if you understood any of that, you're doing better than I am :P) This implementation has many issues... like Bukkit.getPlayer(args[0]) only matching an exact, currently-online name. No selectors. No partial matching. You write all of that yourself or not at all. Tab completion lives in a second method you keep in sync with parsing by hand. Change one, forget the other, and tab completion starts "lying" to your players (a problem that has taken me HOURS to solve in the past... i'm getting flashbacks ;-;). And the tree itself is static, fixed in plugin.yml . Want /report to take a severity argument only when severities are configured? You can't say that in plugin.yml and you end up with a tangled mess that is almost never clean (either to you, or the players). Paper ships Mojang's Brigadier (the same framework vanilla Minecraft uses for everything) through a lifecycle hook: LifecycleEvents.COMMANDS . You register a tree of

Nearly half a century ago, the free software movement made a demand that was both technical and moral: Users should have the freedom to understand, run, modify, and share the software on which they depended. It was a demand born from practical life with machines. A printer that couldn't be fixed. A program that couldn't be studied. A system that asked its users to accept dependence as the price of progress. That belief shaped modern computing and gave us the tools and norms that made the internet, open infrastructure, and collaborative software development possible. Today, that belief faces its hardest test. The technology has changed, but the warning signs are familiar. In 1980, at the MIT AI Laboratory in Cambridge, Massachusetts, a new Xerox 9700 printer was installed. The previous printer had come with source code that could be modified, inspected, recompiled, and reinstalled. Richard Stallman had changed that software to message users when their print job was done or when there was a jam, a small but meaningful feature since the printer sat several floors away. The new printer arrived with software preloaded and installed, no source code available, no way to modify it. If you needed help or new features, you hoped and prayed Xerox would listen. That loss of agency, alongside other anti-consumer shifts in early software, helped push him toward GNU and the free software movement: the belief that software should be free as in freedom, free to inspect, run, study, modify, understand, and redistribute. AI and inference services today are not too dissimilar. Closed frontier intelligence can make entire companies, governments, developers, and communities dependent on systems they cannot inspect, reproduce, modify, or meaningfully contest. At the dawn of this AI moment, we were promised unfettered intelligence across our products, companies, and codebases. We were told we'd be free to build whatever we wanted. At first, with tab completions. Then whole function blocks.

Author: Tobie Morgan Hitchcock Today we're launching Scale, a new tier of SurrealDB Cloud built for the workloads you can't afford to have go down. Our first tier, Start, was designed for building and shipping fast. Scale is designed for what happens next: production traffic, uptime commitments, and the kind of resilience your users never notice because there are always available nodes. It's the tier for teams running SurrealDB as the scalable context layer behind real applications and AI agents in production. What you get with Scale Scale is about one thing: keeping your database available and consistent under real-world conditions. Highly-available, fault-tolerant clusters. Scale runs your database as a multi-node cluster designed to survive node and infrastructure failures without dropping writes or losing consistency. A single point of failure is no longer a single point of downtime. Multiple availability-zone deployment. Your cluster is distributed across multiple availability zones, so even the loss of an entire zone doesn't take your database with it. Traffic keeps flowing while the cluster recovers in the background. Horizontal scale. As demand grows, Scale grows with it. Add capacity by scaling out across nodes rather than being capped by the size of a single machine. Start with three nodes, and keep adding to scale your application or agent's needs. See more information about SurrealDB Cloud Scale architecture here . Built on SurrealDS Scale is powered by SurrealDS , SurrealDB's distributed storage engine and the foundation that makes all of this possible. SurrealDS is a new generation distributed storage architecture, rethought from first principles. Instead of coupling storage to compute on a single box or to a proprietary cloud tier, SurrealDS embeds consensus directly in SurrealDB nodes and separates the two layers cleanly. Here's what that architecture gives you. Architecture overview Compute and storage separation. Scale compute for QPS and storage f

by Peter Yang, Behind the Craft Today, I want to share 18 hot takes on where I think the AI market is headed. AI is in a weird place right now. The government is restricting access to frontier models, enterprises are becoming conscious of token costs, and everyone’s trying to rebuild their product for agents first instead of humans. I’ve interviewed dozens of AI leaders and spent far too much time following these topics on X/Twitter. Here are 18 hot takes on where I think AI is headed next: The frontier-only AI stack is collapsing The AI super app era is here Traditional software risks becoming a dumb pipe for agents Cloud agents and collaboration are the next wave The Frontier-Only AI Stack Is Collapsing Tokenmaxxing at frontier API prices makes no sense. Uber burned through its entire 2026 AI budget in 4 months, Microsoft moved engineers off Claude Code due to cost, and companies are realizing that running everything on frontier models can get expensive fast. Tokenmaxxing makes sense when you’re on a subsidized $200/month plan but is unsustainable at API rates. Companies will rely on a portfolio of models. Coinbase recently cut its AI spend nearly in half by switching engineers to Chinese open-source models like GLM and Kimi. Airbnb and Pinterest have done the same with Alibaba’s Qwen models. I believe that this will be the default path forward — using frontier for high-stakes work and cheaper models for everything else. China’s open-source strategy is working. Chinese models are taking market share from frontier models at US companies. China is also building the full AI stack — from energy (e.g., solar, nuclear) to data centers to domestic chips. The Chinese government is planning a $295B investment in AI data centers with at least 80% of the chips built domestically. Frontier labs are in a catch-22 situation. If they release great open-source models, they might undercut their own frontier API revenue. If they gate the best models behind a trusted list, companies

What happens when a machine no longer needs to be trained to see something new? That's the quiet question sitting underneath this week's news, buried next to a less invasive brain implant and a handful of robots getting tougher for the real world. Neuralink says it's completed its first "transdural" brain implant, a surgical approach built to reduce trauma during the procedure. As someone who spends a lot of time thinking about how you get sensors close to a human eye without hurting anyone, I find these less-invasive-implant strategies worth watching, because the surgical-risk problem is basically the same one we wrestle with in ophthalmic hardware. Vision is getting less invasive too, in its own way. Roboflow rolled out text-prompt object detection built on SAM3 (Meta's latest segmentation model): you type the class of object you want "forklift," "cracked tile," whatever, and it returns boxes and masks without you collecting a single training image first. That's a real shift. For most of computer vision's history, teaching a model to recognize something new meant labeling hundreds of examples before you could even start; this collapses that step into a sentence. The same week brought several applied builds using the same detect-then-orchestrate pattern: a drone system that patrols for intrusions, a pipeline that inspects transmission lines for damaged cables, and an airport tool that spots foreign debris on the tarmac. The Robot Report's roundup of June's biggest robotics stories leaned heavily on humanoid robots companies going public, new deployments, and production milestones stacking up faster than would have seemed plausible a few years ago. Apptronik unveiled its Apollo 2 humanoid alongside a dedicated data-collection facility built so the robot keeps learning after it's deployed, not just during initial training which quietly answers one of the harder questions in robotics: how do you keep a system improving once it's out of the lab? X Square Robot raised e

For a few days, it seemed like Universal decided that there would be no advanced screenings of Christopher Nolan's The Odyssey for influencers. But on Monday, influencers sat alongside traditional critics and journalists at special showings of The Odyssey specifically for the associated press junket. Despite what it may have looked like, Universal was not […]

This tutorial was written by Néstor Daza . This is the second article in a series about building Claudius , my own Claude-based chatbot ( Github ). The prologue made the case for building it, and for choosing MongoDB as its foundation. Open the conversations collection in Claudius’ database and you find the usual fields of a thread header but nothing else: a userId , a title , some timestamps , and so on, but no array of messages, no messages collection sitting beside it either! The text of every conversation lives somewhere else entirely, in the LangGraph checkpointer, which I wire up later in this series. This absence is a modeling decision, and how I came up with the database schema for my chatbot is the theme of this article. If you come from a relational background, you're used to modeling the data first when designing a database. For a project like this, you would start by finding the entities and normalizing them, and the final schema would come out of the data's structure: a conversations table and a messages table with a foreign key between them, because that is what the data looks like. Document modeling runs the other way. You start from how the application reads and writes, and the shape of the document follows the access patterns. Claudius never reads conversation messages without the agent's full working state wrapped around them, and that state is persisted using the LangGraph checkpointer. A separate messages table would add nothing, since the app would always have to join it back to that state on every read. The access pattern says the messages belong with the agent state, so that is where they go, and conversations are left as the lightweight header the list view actually needs. That inversion, modeling around use rather than around the data, runs through everything below. Schema-flexible is not schemaless This is the misconception lots of people often carry, and it is worth killing on the way in. A document database does not mean no schema; it mea

Communities love your brand - Our AI team finds them for you Discussion | Link

Zero-Knowledge Proofs (ZKPs) let an untrusted proved show that computation was executed correctly without revealing the inputs to the verifier. However to prove anything, the computation first has to be expressed as a circuit: a system of polynomial equations (constraints) over a finite field. Circuits are the assembly language of zk and every constraint costs prover (and sometimes verifier) time, so production circuits are aggressively hand-optimized. Over the last months, we have been experime

Frameworks like Lean Six Sigma and business process management (BPM) first gained traction because they promised clarity in the chaos—a structured way to bring order to messy, sprawling operations. Lean Six Sigma emphasized statistical rigor and quality control; BPM created end-to-end maps of how work should flow across departments. Both offered a repeatable way to…