标签：#an

A group made up of dozens of cybersecurity experts urged the White House to remove export control restrictions on Anthropic’s models Fable and Mythos, arguing that the order is going to limit the ability of cybersecurity defenders to secure their software and products.

Casey Harrell has had a set of electrodes embedded in his brain for almost three years. Harrell, who has amyotrophic lateral sclerosis (ALS) and is paralyzed, first used his brain-computer interface (BCI) to “speak” sentences with the help of a research team in 2023. Since then, Harrell has clocked thousands of hours of use. He…

AWS Hero Vadym Kazulkin explains how to overcome Java’s enterprise hurdle on AWS Lambda: cold starts and memory footprints. He shares a technical deep dive into performance tuning, comparing fully managed AWS SnapStart (with pre-snapshot priming hooks) against GraalVM ahead-of-time compilation, while addressing the latest architectural implications of Project Leyden and Java 25. By Vadym Kazulkin

A proposed FCC rule would kill burner phones: phones whose accounts are not attached to a particular person. The FCC plans to do this by legally forcing the country’s telecoms to store a wealth of personal information about essentially all phone customers, including a government issued identification number and their physical address, alarming privacy advocates and civil rights activists who compare the measures to those from authoritarian countries where it can be difficult to buy a mobile phone plan without giving up your identity. The proposed change would drastically shake up how people obtain phone plans in the U.S., and have all sorts of privacy and cybersecurity knock-on effects. The FCC is proposing the data collection partly as a way to combat scammers, with telecoms being required to collect other information on business and foreign customers like the intended use case of their bulk phone plan purchase and their IP address. But the changes would mean telecoms collect data on all new and renewing customers, and the FCC provides a long list of other things that the collected data could help authorities with...

In this article, the author outlines a practical approach to AI governance in the cloud, covering discovery of shadow AI, data classification at creation, IAM-based enforcement, policy-as-code, and operational controls. The article shows how organizations can embed governance into delivery pipelines, balancing security, compliance, and developer productivity without relying on manual processes. By Dave Ward

Even the aging iPhone 11 will feel a little more responsive soon, thanks to improvements in an unsung iOS feature.

After three years of record-­breaking heat, this one is set to be yet another scorcher. Air-conditioning? Not going anywhere. The International Energy Agency projects that the number of AC units will triple by 2050. That’s good for health—one Lancet study estimated that AC prevented nearly 200,000 premature deaths in 2019 alone—but bad for the planet.…

Three days into November, a disapproval cascade pulled 40% of active SKUs from Shopping and Performance Max simultaneously — on day one of a promotional window we'd spent six weeks building. No feed changes on our side triggered it. Here's the part most guides miss: Google's automated review threshold for certain policy categories (health claims, price accuracy, before/after imagery) tightens as platform ad volume increases heading into Q4. I've watched this happen across accounts running ₩50M–₩120M/month in combined Google spend, three years in a row, with zero feed-side changes preceding it. Same feed that sailed through August catches 15–20% disapprovals on recheck in September. The products didn't change. The enforcement did. When it hits during a live window, fix order matters more than fix speed. Price mismatches go first — not because they're the most dramatic, but because they cascade silently. One bestseller disapproved during a flash sale means Performance Max quietly reallocates budget to lower-performing products. By the time ROAS visibly drops, you've lost 48 hours of peak traffic. The specific failure mode I've seen twice on Cafe24 with direct API feeds: a site-wide price update propagates to the feed before the landing page CDN cache clears. Google crawls the feed, sees the new price, crawls the landing page, sees the old cached price. Mismatch. Disapproval. Fixing it is one line — force a manual fetch and verify sale_price_effective_date formatting — but finding it at 2am during a live sale is a different problem. Prohibited content disapprovals are deprioritized by most teams because they're rare. That's exactly wrong. A single escalation during Black Friday week can trigger account-level review, not just product suspension. Pull the SKU yourself within the hour if you can't fix the content immediately. Suspending your own SKU is recoverable. A suspended account during peak is not. GTIN and identifier issues — despite getting the most attention in s

On June 9, 2026, Anthropic launched Claude Fable 5, a model designed for long-horizon tasks, but it was taken offline shortly after due to a U.S. government export directive. It shares architecture with Claude Mythos 5, supporting extensive token usage. The model includes mandatory data retention requirements, which have affected its deployment with partners like Microsoft. By Andrew Hoblitzell

When to choose ansible roles over playbooks depends on the need for reusable structure, clear separation of concerns, and scalable maintenance across many environments. In a deployment that touches 1,200 servers, the early design decision determines whether the codebase remains maintainable or devolves into ad‑hoc tasks that require weeks of debugging. 📑 Table of Contents 📦 Modularity — Why Structure Matters 🧩 Reusability — When Scaling Demands Roles 🔧 Example: Deploying a Database Across Multiple Environments ⚙️ Dependency Management — How Requirements Influence Choice 🔗 Role Dependency Example 📁 File Layout — Organizing Artifacts for Maintenance 📊 Performance & Execution — Impact on Runtime 🔍 Comparison – Roles vs. Playbooks 🟩 Final Thoughts ❓ Frequently Asked Questions When should I still use a flat playbook? Can I mix roles and tasks in the same playbook? How do I test a role without affecting production? 📚 References & Further Reading 📦 Modularity — Why Structure Matters Roles enforce a predictable directory hierarchy that isolates tasks, variables, handlers, and files. What this does: # roles/webserver/tasks/main.yml - name: Install Nginx apt: name: nginx state: present - name: Deploy configuration template: src: nginx.conf.j2 dest: /etc/nginx/nginx.conf mode: '0644' notify: Restart Nginx # roles/webserver/handlers/main.yml - name: Restart Nginx service: name: nginx state: restarted tasks/main.yml: defines the ordered steps the role performs. handlers/main.yml: runs only when notified, preventing unnecessary restarts. The directory roles/webserver groups all related artifacts, making the role portable. Because the role encapsulates its logic, a playbook can invoke webserver without repeating internal steps. This eliminates duplication and aligns with the DRY principle. Key point: Enforced structure turns a loose collection of tasks into a self‑contained unit that can be shared across multiple playbooks. 🧩 Reusability — When Scaling Demands Roles Roles enable r

JPMorgan can't be pleased by any of this.

After failing 3 coding interviews, I realized the problem wasn't practice it was how I was practicing. I spent 6 months grinding LeetCode before my first FAANG interview. 400+ problems solved. Every "Blind 75" problem is memorized. I felt ready. Then the interviewer asked a sliding window variation I hadn't seen before. I froze. Drew a blank. Bombed the interview. The problem wasn't that I hadn't practiced enough. The problem was that I had practiced incorrectly. I memorized solutions instead of understanding patterns. I can recite code, but I struggle to adapt when problems change slightly. So I built something different. Introducing AlgoPatterns A pattern-first DSA learning platform with visualizations that actually show you how algorithms work. algopatterns.in What Makes It Different 1. Pattern-First, Not Problem-First Most platforms throw 2000+ problems at you and say, "Good Luck." AlgoPatterns organizes everything around 17 core patterns: Two Pointers Sliding Window Binary Search BFS/DFS Dynamic Programming Backtracking And 11 more... Master the patterns, and you can solve any variation. 2. Visualizations That Actually Help We have 50+ interactive visualizers that show algorithms step-by-step: Watch two pointers converge in real-time See the DP table fill cell by cell Trace BFS spreading level by level Visualize the call stack during recursion Reading code is one thing. Seeing it executed is completely different. 3. Curated, Not Overwhelming 315 hand-picked problems organized by pattern. Each problem includes: Company tags (Google, Amazon, Meta, etc.) Frequency indicators Pattern classification Difficulty rating No more random grinding. Practice the right problems in the right order. 4. Real Code Templates Every pattern comes with: Java templates (copy-paste ready) "When to use" indicators Common mistakes to avoid Key insights from each pattern Who It's For Interview preppers who want to learn patterns, not memorize solutions CS students who find textbook expla

MVCC, WAL, vacuum, and replication slots under sustained delete load - and how to delete billions of rows without your database noticing Most "how to delete a lot of rows" articles stop at "batch it and delete children before parents." That advice is correct, it's table stakes, and everyone already knows it. This article is about everything after that - the parts that actually decide whether your cleanup runs quietly in the background for a week or pages you at 3 a.m. with a full disk and a replica that's six hours behind. The thesis: at scale, your DELETE statement is the easy part. The adversaries are the subsystems a delete feeds - MVCC tuple versioning, the write-ahead log, autovacuum, and the replication machinery. Bulk deletion is really an exercise in flow control across those subsystems . Get the SQL right and the systems wrong, and you'll still take production down. We'll assume PostgreSQL (the internals are PG-specific), a live OLTP primary with at least one physical replica and one or more logical/CDC consumers, and a target of hundreds of millions to billions of rows across many related tables. The one paragraph of "basics," so we can move on: delete in dependency order (referencing rows before referenced rows); collect parent keys once; never rely on ON DELETE CASCADE for huge deletes because you can't throttle a cascade. Done. Now the real material. 1. What a DELETE actually costs A delete is not "remove a row." Under MVCC it's "mark a row version dead and write that fact everywhere." For each deleted tuple, PostgreSQL: Sets xmax on the heap tuple to your transaction id. The row is still physically present; it becomes a dead tuple once your transaction commits and no snapshot can still see it. Writes a WAL record for the heap change. If this is the first modification of that page since the last checkpoint, it also writes a full-page image (FPI) - potentially 8 KB of WAL for a single-row change. Touches every index. Index entries aren't removed at delet

According to a new report from Semafor, the White House's decision to impose export restrictions on Anthropic's Mythos was driven in part by fears that it had been accessed by a group linked to China. If the Chinese government actually had access to Mythos 5 or Fable 5, it would present a serious national security […]

Word scrambling is a deceptively simple mechanic. Rearrange the letters of a word, ask someone to restore the original — that's the entire game loop. But underneath that simplicity is a cognitive process that language researchers find genuinely interesting, and that developers building educational tools keep returning to. The Cognitive Mechanics of Unscrambling When a learner attempts to unscramble a word, they're engaging several parallel cognitive processes: pattern recognition (matching letter combinations to phonemes they know), memory retrieval (searching their lexical database), and hypothesis testing (trying a mental arrangement before committing). It's a lightweight version of the same cognitive work that makes retrieval practice so effective in spaced repetition systems. For language learners specifically, this is high-value low-stakes practice. The scrambled form gives enough context to confirm the answer upon success — no ambiguity like a multiple-choice distractor — while requiring genuine active recall. Implementation Considerations for Developers If you're building a word scramble feature into an educational app, a few things matter: Avoiding anagram collisions: "SILENT" → "LISTEN" is a classic example. Your scrambling algorithm needs to detect valid English words in the output and regenerate if it creates a different real word. A dictionary API lookup on the scrambled result handles this. Difficulty calibration: Longer words and words with repeated letters (like "BALLOON") are objectively harder to unscramble. A good difficulty curve starts with 4–5 letter words and increases length progressively. First/last letter anchoring: Keeping the first and last letters in position is a widely used technique to reduce cognitive load. It's psychologically effective — people anchor on word edges more than the interior. Using Existing Tools vs. Building Your Own For most educational content creators and teachers (non-developers), building their own tool isn't feas

Startups are trying to "ride that SpaceX IPO wave."

Welcome back to TechCrunch Mobility, your hub for the future of transportation and now, more than ever, how AI is playing a part.

So you built your stack on a hosted frontier model. Good throughput, clean API, your foreign-national engineers hit the same endpoint as everyone else. Then on June 12 the US government pulled Claude Fable 5 and Mythos 5 offline for the entire planet, three days after launch, and the reason is a compliance gap baked into how these things actually serve traffic. Here's the thing worth understanding as an engineer: the bug was narrow. The takedown wasn't. The gap between those two facts is where every team running a hosted model should be paying attention. What actually triggered it Commerce hit Anthropic with an order barring access to both models by any foreign national, anywhere, inside or outside the US, including Anthropic's own foreign-national staff. The stated trigger was a jailbreak: point the model at a codebase, ask it to find flaws. That's it. Anthropic reviewed the demo and watched it surface a handful of already-known minor vulns, the kind GPT-5.5 and other public models hand you with no bypass at all. So the capability wasn't exotic. It was automated code review on a Tuesday. The reason it went nuclear is the legal layer sitting on top, not the finding itself. The architecture problem: you can't gate on a passport you can't see Walk it through like any other access-control question. The restriction names a class of users: foreign nationals. Every one of them, globally. Now look at what a model API knows about a session at request time. restriction: deny any foreign national, anywhere session metadata: auth token, IP, usage tier NOT in session: verified nationality isolatable set: ∅ only compliant state: serve nobody An API session doesn't carry a verified passport. IP geolocation is trivially defeated by a VPN and tells you location, not citizenship anyway. There's no field in the request that maps to the restricted class. When you can't isolate the users you're forbidden to serve, the only provably-compliant state is serving no one. Off switch. Global.

Every backend engineer has seen this happen, you build an application on a relational database like MySQL, handling thousands of concurrent transactions effortlessly. Then, the business asks for a real time analytics dashboard. But when you run an aggregation query over historical data, suddenly the database that effortlessly managed live traffic starts thrashing, evicting your working set, and dragging application performance down. This isn't a tuning problem, a missing index, or a badly written query. It’s a fundamental architectural collision. OLTP (Online Transaction Processing) OLTP encompasses nearly every concurrent digital interaction triggered across a distributed system. A user downloading a PDF, a microservice firing an automatic maintenance log, a comment on a social feed these are all transactions. Data engineers rely on OLTP systems (like MySQL or PostgreSQL) to capture these concurrent streams of interactions for creating , updating and deleting records. The Tree Based In-Place Engine To reliably capture massive volumes of transactions without corrupting data or locking up the application, OLTP systems rely on a highly optimized, row oriented architecture built around the B+ Tree. Because they must provide immediate, atomic updates to existing records, transactional databases manage state through a strict sequence of physical tree traversal and in-memory page mutation: The B+ Tree Indexing: When a transaction reads or updates id: 1, the engine traverses a B+ Tree from the root, through the branch nodes, directly to the specific physical leaf node holding that row. This O(\log n) traversal guarantees a fast, isolated point-lookup. It ensures the application always hits the single version of the row without scanning irrelevant data. The Buffer Pool & In-Place Updates: OLTP systems perform in place updates. The database pulls the exact page containing id: 1 from the physical disk into memory (the Buffer Pool). The specific row is mutated directly in RAM

You have 50 documents and you're running them through an LLM in a loop. The first one finishes at the 2-second mark. The fiftieth finishes at the 100-second mark — not because it's harder, but because it waited in line behind the other 49. Pool runs all 50 at the same time. The Problem With Loops Every developer who works with LLMs writes this code eventually: import os from yait_aichain.models import Model from yait_aichain.skills import Skill skill = Skill ( model = Model ( " claude-sonnet-4-6 " , api_key = os . getenv ( " ANTHROPIC_API_KEY " )), input = { " messages " : [{ " role " : " user " , " parts " : [ " Summarise in two sentences: \n\n {text} " ]}]}, ) documents = [{ " text " : f " Document { i } content... " } for i in range ( 50 )] results = [] for doc in documents : result = skill . run ( doc ) results . append ( result ) It works. It's readable. And it's painfully slow. Each LLM call takes roughly 2 seconds. Multiply that by 50 documents and you're staring at your terminal for almost two minutes. The calls are completely independent — document 37 doesn't need the result of document 12. Yet document 37 sits idle, waiting its turn. That's a scheduling problem, not a computation problem. I ran into this directly while building a task that pulled N files or links and produced a consolidated report. The sequential version was logically fine but just hemorrhaged time. I needed to fire everything at once without rewriting the Skill logic — no new prompt templates, no restructured code, just a different execution model. That's what Pool is. Pool: Parallel Map for LLM Calls Pool takes one Skill (or Chain) and a list of inputs , then launches all of them concurrently. Think of it as Array.map() where every element runs in parallel against an LLM. import os from yait_aichain.models import Model from yait_aichain.skills import Skill from yait_aichain.pool import Pool , DONE , FAILED skill = Skill ( model = Model ( " claude-sonnet-4-6 " , api_key = os . getenv ( "