"It is a matter not only of customer protection, it's also a matter of democracy protection."

MAGA is loudly calling for the former White House chief medical adviser to end up in prison. WIRED asked legal experts to weigh in on whether that’s even possible.

Apple CEO Tim Cook envisions users being able to buy more compute for Siri AI via Apple's existing iCloud+ subscriptions.

How a branch-free loop and byte-space arithmetic let GitHub case-fold every byte of code search at >45 GiB/s on a single core. The post Don’t stop early: Case-folding source code at memory speed appeared first on The GitHub Blog .

security #api #domain #subdomaintakeover #defcon #whois #rapidapi #threatintel DEF CON 32 made one thing clear: open-source security chips and hardware keys are having a moment. But while badges get the spotlight, most real-world attacks still start with something far less glamorous — a forgotten DNS record, a dangling CNAME, or a missing DMARC policy. Subdomain takeover remains one of the most reliable paths from "benign misconfiguration" to "account compromise." If your organization owns dozens or hundreds of domains, manual checks do not scale. This is where an API-first domain intelligence tool becomes essential. In this post, we'll use the Domain WHOIS API to automate: WHOIS/RDAP lookups and domain-age checks DNS record enumeration and SSL certificate inspection Subdomain discovery and takeover-risk scoring Email-security validation (SPF, DMARC, DKIM, DNSSEC, MTA-STS) Historical snapshots via /history Why subdomain takeover still matters A subdomain takeover happens when a DNS record points to a third-party service — GitHub Pages, Heroku, AWS S3, Vercel, etc. — that is no longer registered under your account. An attacker can claim the dangling endpoint and suddenly serve content under your brand's domain. Bug bounty programs consistently rank subdomain takeovers as high-severity findings because they enable phishing, session hijacking, and reputation abuse. The root cause is usually an orphaned CNAME that nobody is monitoring. The fix is continuous monitoring. Instead of running dig , whois , and openssl by hand, we can consolidate everything into a single API call. What the Domain WHOIS API returns The API combines several data sources into one response: Capability Use case WHOIS via RDAP Ownership, registrar, creation/expiration dates DNS records A, AAAA, CNAME, MX, NS, TXT records SSL certificate Issuer, expiry, SANs, validity Subdomain discovery Asset inventory and shadow-IT detection Takeover risk Dangling CNAME/A-record scoring Email security SPF, DMARC,

One hundred days ago, I had no idea this challenge would become one of the most rewarding technical journeys I've taken. There were days when everything clicked, and there were days when nothing compiled. I celebrated successful deployments, stared at cryptic errors for hours, rewrote programs that weren't good enough, and learned that understanding Solana has far less to do with memorizing APIs than changing how you think about state, ownership, and security. Looking back now, I realize I didn't just complete 100 challenges; I built a completely different mental model of software. Where I started I came in with a biochemistry degree I never used, a self-taught engineering career I built in public, and a GitHub full of Rust and Python work. I co-maintain statix, a Nix linter that ended up in the canonical NixOS/nixpkgs upstream. I had shipped real software before. What I did not have was any intuition for how Solana actually works. I knew the buzzwords. I had the mental model of "it's fast and cheap." I did not know what an account was. I did not know what a program was. I did not know why those two things were different. That gap, between knowing the words and understanding the model, is what these 100 days actually closed. What I expected I expected Solana to feel like a database with extra steps. In Web2, you have a server that holds state. You call an API. The server reads from the database, does something, writes back. I expected a blockchain to be the same thing, just slower and decentralized. The first thing that broke that model: accounts. On Solana, an account is not a row in your database. It is the database. Every piece of state, your wallet balance, a token you hold, the program you deployed, is an account. Programs are accounts. Data is accounts. Everything is an account. That sounds obvious written down. It took me until around Day 15 to actually feel it, when I was staring at a getAccountInfo call wondering why the program I deployed was also an accou

--- title : " Perfect Landing — Soul & Spoon (Comfort Food Edition) — Research Summary" published : false tags : [ " frontend" , " html" , " css" , " javascript" , " accessibility" , " performance" , " react" , " svelte" ] cover_image : " https://images.unsplash.com/photo-1543353071-087092ec393a?q=80&w=1600&auto=format&fit=crop&ixlib=rb-4.0.3&s=3" canonical_url : " " series : " " --- Perfect Landing — Soul & Spoon Research Summary A concise, ready-to-paste DEV post that summarizes the research, design decisions, technical choices, and next steps for the Soul & Spoon landing-page project — a warm, accessible, performance-minded single-page site celebrating soul food. What I Built Soul & Spoon — Comfort Food Landing Page is a single-page landing site that showcases soul-food plates with a polished, modern frontend. The static prototype includes: Hero with a full-bleed background and clear CTAs. Featured dishes section with responsive cards and descriptive copy. Gallery of soul-food plates with a keyboard-accessible lightbox. Contact form with client-side validation and toast feedback. Responsive, accessible, and performant implementation using semantic HTML, picture / srcset /WebP, lazy loading, and minimal JavaScript. Research Summary and Rationale Design goals Evoke warmth and comfort through color, rounded shapes, and soft shadows. Prioritize readability and hierarchy for quick scanning on mobile and desktop. Keep interactions simple and predictable: smooth scroll, accessible modal, and unobtrusive toast notifications. Accessibility findings Semantic elements ( header , main , section , figure , figcaption , footer ) improve screen-reader navigation and SEO. Keyboard operability is essential: gallery images must be focusable and open via Enter/Space; Escape should close the lightbox. ARIA attributes ( aria-hidden , aria-expanded , role="dialog" ) plus focus management significantly improve modal usability. Performance findings Images dominate page weight; srcset an

I've spent years working with backend systems. APIs, databases, caching, integrations, performance, authentication, cloud infrastructure — these are the kinds of problems that become familiar after you've been building software for a while. Recently, I've been spending more time learning another side of software engineering: LLMs, RAG, AI Agents, tool calling, and MCP. At first, it felt like entering a completely different world. New terminology. New frameworks. New architectural patterns. And honestly, it made me feel like a beginner again. But the deeper I went, the more I noticed something interesting: AI engineering has a lot more backend engineering in it than I initially expected. The Traditional Backend Mental Model A simplified backend architecture might look like: Client ↓ API ↓ Business Logic ↓ Database ↓ Cache / External Services Of course, production systems have much more around this: Authentication Authorization Logging Monitoring Queues Caching Load balancing Rate limiting Distributed systems Cloud infrastructure But the general flow is deterministic. The application receives a request. Our code decides what happens. The application returns a response. Then we add AI. Adding an LLM Looks Easy The first architecture is surprisingly simple: User ↓ API ↓ LLM ↓ Response Send a prompt. Get a response. Done. For a prototype, this can be enough. But production applications rarely stay this simple. Suppose we're building an assistant that answers questions using internal company documents. Now we need retrieval. Enter RAG A simplified Retrieval-Augmented Generation pipeline might look like: Documents ↓ Chunking ↓ Embeddings ↓ Vector Database Then, when the user asks a question: User Question ↓ Embedding ↓ Vector Search ↓ Relevant Documents ↓ Context ↓ LLM ↓ Answer Conceptually, this is easy to understand. But implementing it properly raises a lot of questions. How should we chunk documents? A fixed number of characters? Tokens? Paragraphs? Sections? Semantic

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

I run a content pipeline that picks trending topics and publishes articles automatically. Last week I found out it had published the same story three times. Not the same title — the same exact topic, reworded each time. My dedup check was supposed to stop that. It didn't. Here's why, and how I killed the check. The Bug My pipeline had a similarity gate. Every candidate title got compared against the last 30 published titles, and anything scoring 0.58 or higher was rejected. Straightforward, right? from difflib import SequenceMatcher def jaccard_bigram ( a : str , b : str ) -> float : def bigrams ( s : str ) -> set [ str ]: return { s [ i : i + 2 ] for i in range ( len ( s ) - 1 )} x , y = bigrams ( a ), bigrams ( b ) return len ( x & y ) / len ( x | y ) if ( x | y ) else 1.0 def similarity ( a : str , b : str ) -> float : return max ( SequenceMatcher ( None , a , b ). ratio (), jaccard_bigram ( a , b )) THRESHOLD = 0.58 Here's the pair that slipped through. The candidate: 中国军队国际形象网宣片《当红》 And a title I had already published: 《当红》网宣片刷屏，普通人看到的中国军人是什么样 Same film. Same topic. Third time it was being covered. Watch what the algorithm did: candidate = " 中国军队国际形象网宣片《当红》 " published = " 《当红》网宣片刷屏，普通人看到的中国军人是什么样 " print ( similarity ( candidate , published )) # SequenceMatcher: 0.187 # jaccard bigram: 0.185 # max: 0.187 < 0.58 -> PASSED 0.187. The gate let it through with a five-fold margin to spare. Why It Failed The name 当红 is the same in both titles. That is the whole topic. But the algorithm does not care about that. SequenceMatcher matches in order. In the published title, 当红 sits at position zero. In the candidate, it is at the end. Reordered tokens break the match, so the ratio collapses to the shared fragments — 网宣片 plus the generic words around it. The bigram fallback does not save you either. Jaccard over character bigrams measures surface overlap, not meaning. Five shared bigrams out of twenty-seven total. 0.185. It "proves" the titles are unrelated because most of

The leading U.S. automakers are mentioning EVs on their investor calls at pre-pandemic rates, according to new data from TechCrunch and Hudson Labs.

Most Astro content I come across falls into one of two buckets: "here's a nice website I built" or "here's how Astro compares to Next.js for a marketing page." Both fair, both true. But the site I work on doesn't look like either of those, and it's the use case I almost never see written about: hundreds of near-identical, dynamically generated pages, all needing to rank in search, all needing to load fast, in two languages and two markets. Concretely: a home-services marketplace with city pages, service pages, and city × service combination page — the kind of programmatic SEO structure where the page count isn't in the dozens, it's in the hundreds today and headed toward tens of thouisands as the underlying data grows. That's a genuinely different problem than "make one fast landing page," and it turns out Astro is unusually well suited to it — better suited, in some concrete ways, than the frameworks that get all the programmatic-SEO blog posts. The default that actually matters: zero JS unless you ask for it Every "why Astro" post mentions the islands architecture. What gets undersold is what that means specifically for a large templated site: a city × service page — heading, worker cards, an FAQ block, some internal links — ships as plain HTML with no JavaScript bundle at all, by default. Not "a smaller bundle." None. Compare that to a static export from a React-based meta-framework, where every page is still a component tree meant to hydrate, so you're shipping (and executing) framework runtime JS even for a page that never needs to do anything client-side. At one page, that's not a big deal. At a few hundred templated pages, each with real content and real images, it's the difference between a site that stays fast as it grows and one that needs constant bundle-splitting effort just to stand still. In Astro, the handful of things that genuinely need JS — a filter widget, a search box — opt in explicitly, and you choose when: astro Everything else on the page is