标签：#r

The defense secretary’s idea of administering testosterone therapy to service members of the US Armed Forces reveals little understanding of the complexity of hormones.

You subscribed to newsletters because you wanted to read them. Then they landed in Gmail, between a password reset and a calendar invite, and reading stopped being the point. Surviving the inbox became the point. Readwise Reader fixes the environment problem. It is a read-later app with a proper feed, highlighting, and offline sync. The setup below gets every newsletter you care about flowing into it automatically. Everything in the first four sections works with no product of mine involved; there is a disclosed plug at the end. Step 1: Find your two Reader addresses Every Reader account comes with two custom email addresses, not one: an address ending in @library.readwise.io an address ending in @feed.readwise.io Mail sent to the library address lands in your Library, the place for things you have committed to reading. Mail to the feed address lands in your Feed, the triage stream you skim and pick from. Readwise recommends the feed address for newsletter subscriptions and forwarding rules, and the library address for one-off documents. That split is worth respecting. A newsletter is a candidate, not a commitment. To find both addresses in the web app, click the + button in the bottom left and choose "More import options". On mobile they are listed under Settings. You can also rename them ("Personalize email addresses" on the Add to Library page) if the random string bothers you. Two caveats from Readwise's own docs: a guessable address can attract spam, and if you personalize a second time, the previous personalized address goes dead. Step 2: New subscriptions go straight to Reader From now on, when you subscribe to a newsletter, put your feed address in the signup box. No forwarding, no filters. The issue arrives in your Feed and never touches your inbox. Two mechanical notes: There is no allowlist to manage. Anything sent to the address gets in, which is the opposite of the Kindle personal-documents dance. If a newsletter uses double opt-in, the confirmation ema

Seventy-three comments into the thread, someone asked a question my gate had no answer for: what happens when the proposer walks past a claim it should have surfaced? The system could catch what the model said wrong. It could not catch what the model chose not to say. That absence looked identical to clean compliance — no trace, no alarm, nothing to review. The silence was invisible. Earlier this week I published the hard limit of my memory gate. The system could detect direction changes in authority — a real source used to support a claim it never made. The relation-span clause killed a citation-shaped class of lie. Labels lagged, but boundaries held. The result was real, and I said so. I also said where it stopped working. The thread that followed broke it open in ways I could not see from the inside. The gap they found The gate watched what the proposer said . If a model claimed an authority changed, the confirmer checked the span. If the claim was wrong, the confirmer rejected it. If the claim was shaped like a citation but pointed at nothing real, the gate caught it. What the gate could not do was catch what the proposer chose not to say . nexus-lab-zen named it. If the proposer walks past a claim it should have surfaced, the artifact looks identical to clean compliance. There is no trace of the inspection that did not happen. The absence is invisible. I built the first answer: a silent-omission gate that diffs the proposer's emissions against an independent observer's footprint. If an outside watcher saw a surface the proposer never mentioned, the system fires undeclared_surface . Eight frozen cases, independently recomputed, shipped public ( f41ee0f ). But nexus came back. Instead of observing the proposer's footprint after the fact, make the proposer declare what it inspected before the diff runs. A typed "surfaces considered" set, emitted alongside proposals. Then silence splits into two states you can actually store: "I looked at X and chose not to surface

Your agent feels fast during a demo. Then a real session reaches twenty turns, several tools have returned large payloads, and every response starts taking longer and costing more. This pattern is often called token drift : the effective input context grows as an agent carries more conversation history, tool output, retrieved documents, and state into each model call. The model itself is not gradually becoming less efficient. The application is asking it to process more material on every turn. Token drift is manageable, but only if context is treated as a budgeted system resource rather than an unlimited transcript. What Token Drift Actually Means Most conversational agents build each request from several sources: a system prompt, tool definitions, recent messages, retrieved context, durable memory, and sometimes a summary of older work. Whether the application sends that state on every request or a provider manages part of it, the model still has an effective context to process. Consider an illustrative session: Turn Effective input What changed 1 1,200 tokens System prompt, tools, and one user message 8 6,900 tokens Conversation history and two tool results 20 18,400 tokens More history, retrieved documents, and accumulated state The exact price and latency depend on the model, provider, cache behavior, and workload. The important signal is the trend: later calls repeatedly process a larger context. Why Agents Accumulate Tokens So Quickly Conversation history is only one source of growth. Production agents often accumulate tokens in several places at once: Repeated transcripts: Every prior user and assistant message remains in context. Tool schemas: Large tool descriptions and JSON schemas may be attached to every model call. Tool results: Search results, stack traces, database rows, and API responses can be much larger than the user's request. Retrieved documents: RAG pipelines sometimes add too many chunks or keep stale retrieval results across turns. Retries an

On July 14, 2026, the Linux Foundation stood up the x402 Foundation — neutral governance for the protocol that lets AI agents pay each other over HTTP 402. The member list is the entire payments industry: Visa, Mastercard, Amex, Stripe, AWS, Google, Cloudflare, Coinbase, Circle, Ripple, Shopify, and two dozen more. Read the launch release end to end and one thing is missing. There is no conformance suite. No security profile. No certification program. No validation procedure. The industry just gave agent payments a standards home and standardized the rails — not the proof that the payment an agent executed was the one it was authorized to make. This is a pattern, not a one-off. Standards bodies standardize the protocol. The conformance surface lags — and the security surface lags behind that. It happened with MCP. The protocol matured fast; the testing of it arrived later and is still catching up. It is happening again with x402, on a compressed timeline, with more money behind it. The gap matters because a signed, well-formed record is not the same thing as a true one. Look at what landed in the research this month. ShareLock (arXiv 2606.27027 , Liu et al., June 2026) distributes a malicious instruction as benign-looking secret shares across several MCP tool descriptions using a Shamir threshold scheme. Each fragment passes per-tool inspection. The payload reconstructs only when the shares are aggregated, after a quiet trigger during a server update. The paper reports an average attack success rate above 90% against tool-description detectors. Every individual record was valid. The composite was hostile. A conformance check that validates each tool description in isolation passes the whole attack straight through. That is the shape of the coming problem for agent payments. Signed receipts, content-addressed evidence records, canonicalized envelopes — the industry is converging on the format of trustworthy agent evidence fast, and getting that format ratified inside

Most data engines can answer a query. I wanted one that could also explain, offline and byte for byte, why that answer belongs to a specific durable state. That question led me to build Hyphae , an open-source data engine in Rust with a deliberately small operational footprint: one native binary; one data directory; no required database, cache, cloud service, embedding provider, or LLM; deterministic KV and structured queries; portable result proofs that can be verified offline. If you read my earlier post about provenance over prediction , this is the next and deliberately narrower step. That work began as a cognitive substrate and clarified the provenance thesis. I have since rebuilt Hyphae as a standalone data engine. The research lineage remains, but the current product does not need an AI stack to be useful. Hyphae 0.1.0 is now available on GitHub , through crates.io, and as signed multiplatform archives in the first public release . The problem was not another query syntax The usual path for an application data feature grows surprisingly quickly. A local library becomes a database service. Search adds another service. Caching adds another. Semantic retrieval adds a model provider. Soon, a feature that should be optional controls whether the application can start at all. There is a second problem hiding underneath that operational stack: a successful response is usually just an assertion from the system that produced it. If I receive a filtered, sorted, limited result, how do I check that: the underlying durable state was not corrupted; the query was executed with the declared semantics; matching rows were not silently omitted; the returned result is tied to the state I actually intended to trust? Checksums help with corruption. Signatures can identify a producer. Neither one, by itself, proves that an arbitrary query result is complete and was reexecuted correctly. Hyphae is my attempt to make those concerns part of the engine instead of application glue. What

Ask any engineering manager whether their team pastes code into ChatGPT and you'll get a nervous laugh. The honest answer is constantly — a stack trace here, a config file there, "just cleaning up this SQL." Most of it is harmless. Some of it carries an AWS key, a database password, or a customer's PII straight to a third-party model. I've spent the last while looking at how teams try to control this, and most of the common approaches quietly fail. Here's what doesn't work, what does, and why. Why this isn't a normal DLP problem Traditional DLP watches email, file shares, and cloud storage. An AI prompt leak skips all of them: the data goes from a browser tab to an AI provider's API over HTTPS and never touches the channels legacy DLP inspects. It's also invisible after the fact. Once a prompt is sent there's no sent-mail copy, no uploaded-file record. If you didn't catch it at the moment of submission, you have no idea it happened. Prevention has to live in the browser , or it doesn't happen at all. The approaches that don't hold up Blocking AI tools outright. Employees just switch to their phone or a personal laptop. You lose the productivity and keep the risk. Network proxies / CASBs. They can see the domain but struggle to inspect encrypted prompt content without heavy MITM infrastructure — and they don't understand a DOCX dropped into a chat window. Policy + training. Sets expectations, stops nothing in the moment. Post-hoc SaaS scanners. Find the exposure after the data already left. Good for audit, useless for prevention. What actually works: intercept in the browser The only place you can reliably read a prompt is where it's typed. A managed browser extension can patch the page's network calls, read the prompt (and any attached files) before they send, scan against your DLP rules, and block anything that matches — all client-side, in well under a second, with no proxy and no rerouted traffic. That's the model I've become convinced is right, and it's the appr

"Now offloading propellant. Next launch attempt hopefully in a few days."

1. Introduction In 2026, many teams still default to WordPress when building blogs or marketing sites, often without fully considering the architectural alternatives. The classic WordPress setup PHP on shared hosting or managed WordPress platforms, coupled with a MySQL database and a plugin ecosystem works reliably but comes with inherent performance trade-offs. Modern visitors now expect lightning-fast page loads and perfect Core Web Vitals a bar that traditional WordPress setups struggle to meet without extensive optimization and caching strategies. This article examines why, for many developer-managed websites, Astro + Cloudflare Pages delivers superior results in performance, SEO, security, and maintainability compared to traditional WordPress deployments. We'll explore the technical trade-offs and help you make an informed decision for your next blog or business website. 2. What is Astro + Cloudflare Pages? Astro is a modern web framework that prioritizes delivering fast, lightweight content by default. Instead of running client-side JavaScript on every page load, Astro generates complete HTML during build time. Only interactive elements—dubbed "islands of interactivity"—run JavaScript, and only when needed. Cloudflare Pages is a globally distributed static hosting platform that leverages Cloudflare's edge network for content delivery. Think of it as Git combined with Cloudflare's CDN and security stack with integrated CI/CD, zero-downtime deployments, and automatic edge caching. How they work together: You write your content and components using Astro's Markdown, MDX, or frameworks Astro builds your site to static HTML during your CI/CD pipeline Cloudflare Pages takes the built static assets and deploys them to edge locations worldwide Every request hits the nearest edge location , serving cache-optimized HTML directly This contrasts sharply with WordPress, which typically involves: PHP processing on every request Database queries to fetch content Server-side

Originally published on tamiz.pro . Introduction Over-the-air (OTA) updates are a critical component of modern software ecosystems, yet they introduce complexity through network instability, device fragmentation, and rollback challenges. Meanwhile, AI agents are emerging as powerful tools for autonomous workflow orchestration. This article explores how to architect resilient developer workflows by integrating AI-driven decision-making with OTA update management systems. The Chaos of OTA Updates OTA updates face three primary challenges: Unreliable Network Context : Mobile devices frequently lose connectivity during updates Device State Fragmentation : Managing compatibility across 1000+ device configurations Rollback Complexity : Traditional systems lack real-time failure detection Traditional solutions rely on retries and checksum validation, but these fail to address root causes like partial updates on low-memory devices or race conditions during state transitions. AI Agent Innovation Framework AI agents introduce three transformative capabilities: Predictive Update Scheduling # Pseudocode for AI-driven update scheduling agent . observe ( network_quality , battery_level , device_usage ) recommendation = neural_net . predict ( update_success_probability ) if recommendation . confidence > 0.9 : schedule_update () elif recommendation . alternative : queue_deferred_update () Dynamic Rollback Orchestration AI agents can implement context-aware rollback strategies: Immediate rollback for critical OS failures Graceful deferral for non-essential app updates Predictive rollback based on anomaly detection in system metrics Device State Pattern Recognition Machine learning models analyze historical update data to: Predict failure patterns across device models Optimize binary delivery sequencing Automatically generate compatibility matrices Architectural Implementation A resilient workflow combines: graph TD A[OTA Coordinator] --> B[AI Agent Orchestration Layer] B --> C[Updat

As a developer, I find myself doing the same conversions and lookups over and over. Here are 5 free, no-signup tools that live in my bookmarks: 1. BitwiseCalc — Bitwise Operations Calculator https://bitwisecalc.com When you're debugging bit flags, network masks, or color channels, mental math gets old fast. BitwiseCalc handles AND, OR, XOR, NOT, left and right shifts on binary, decimal, and hex numbers. It supports 32-bit and 64-bit precision and keeps a calculation history so you don't lose track of your operations. 2. BinTranslate — Binary ↔ Text Converter https://bintranslate.com Need to decode a binary string into readable text? Or convert text to binary? BinTranslate supports five conversion modes: binary to text, text to binary, binary to English, binary to ASCII, and words to binary. Everything runs client-side — no data ever hits a server. 3. Epoch Converter — Timestamp Tool https://www.epochconverter.com/ The classic. Convert Unix timestamps to human-readable dates and back. Supports milliseconds, microseconds, and nanoseconds. 4. JWT.io — JWT Debugger https://jwt.io/ Decode, verify, and debug JSON Web Tokens right in the browser. Supports HS256, RS256, ES256, and more. Great for debugging auth flows. 5. RegExr — Regex Playground https://regexr.com/ Learn, build, and test regular expressions with a cheatsheet, reference, and real-time highlighting. All of these are free, no sign-up, and run in the browser. Got any tools you keep coming back to? Drop them in the comments. P.S. I built BitwiseCalc and BinTranslate myself — feedback welcome.

Originally published at https://blog.pathvector.dev/protocol-lab-trace-19/ — part of the free Protocol Lab series. This post is part of Protocol Lab , a free, hands-on series for learning networking protocols by building and breaking them in a container lab. All the lab material — topologies, configs, and scripts — lives in the repo: github.com/pathvector-studio/protocol-lab . Every IP packet carries a TTL (time to live) that each router decrements by one. When it reaches zero, the router drops the packet and sends back an ICMP time-exceeded message. traceroute turns this rule into a map: send probes with TTL 1, 2, 3, … and each dying probe reveals the router at that distance. Reading guide: rfc-notes/traceroute-ttl.md Prerequisite: TCP Lab 07: Handshake and Teardown (reading captures) Expected time: 40–55 minutes. The Goal This lab builds a real multi-hop path and shows the mechanism: client → r1 → r2 → server , with two Linux routers in the middle, traceroute from the client lists each hop: 10.0.1.2 (r1), 10.0.2.2 (r2), 10.0.3.2 (server), a packet capture shows the ICMP time-exceeded replies (from r1 for TTL 1, from r2 for TTL 2) that traceroute is built on. By the end, you should be able to explain this table: Probe TTL Dies at Reply 1 r1 ( 10.0.1.2 ) ICMP time-exceeded from r1 2 r2 ( 10.0.2.2 ) ICMP time-exceeded from r2 3 server ( 10.0.3.2 ) reaches the destination What You Will Learn What the IP TTL field is for (loop protection) and how routers decrement it. What an ICMP time-exceeded message is and who sends it. How traceroute uses increasing TTLs to discover each hop. Why the hops appear in order, and why the last hop is the destination itself. The difference between forwarding (routers) and being an endpoint. This lab does not cover: UDP vs ICMP vs TCP traceroute probe types in depth (we use ICMP mode). Load-balanced paths (ECMP) where hops can vary between probes. Why some hops show * * * (rate limiting or filtered ICMP) in the real internet. Where to Rea

Hey DEV, I'm Tobore. Let's actually connect. I've been on here for a while now, mostly writing and...

In the wake of a massive hours-long gridlock event, San Francisco mayor Daniel Lurie has told state regulators it's time to put more requirements on robotaxi operators like Waymo.

The company didn't immediately say what went wrong. SpaceX's stock plunged more than 4% in after-hours trading before paring losses.