AI 资讯

Before this week, NFTs on Solana weren't new to me. I've previously worked with Programmable NFTs ( pNFTs ) and even built projects that integrate them. However, most of my experience was centered around the Metaplex ecosystem, so I tended to think about NFTs through that lens. What surprised me during this learning arc was discovering how much can be built directly with Token Extensions. By creating NFTs from the token level upward, I gained a much deeper understanding of the underlying primitives that make digital assets work on Solana. The Mental Model: What Is an NFT on Solana? As developers, we often interact with NFTs through SDKs , frameworks , and marketplace tooling. Those abstractions are useful, but they can hide what's actually happening on-chain. This week helped me simplify the model: An * NFT * is fundamentally a token mint configured with: A supply of one Zero decimals Metadata describing the asset Optional relationships to collections or groups Using Token Extensions, many of these capabilities can be attached directly to the token itself rather than relying on additional programs or infrastructure. That shift in perspective was one of the biggest takeaways from this challenge. What I Built Over the course of this arc, I created an NFT on Solana Devnet using Token Extensions and explored several capabilities that I had never implemented directly before. The process included: Creating a mint configured as an NFT Adding metadata using the Metadata Extension Minting a single token Creating a collection using the Group Extension Associating the NFT with the collection through the Member Extension Auditing the account structure and extension data on-chain Updating metadata after the NFT had already been created One of the most valuable parts of the exercise was inspecting the accounts directly instead of relying solely on SDK abstractions. For example: spl-token initialize-metadata \ <NFT_MINT> \ "My First NFT" \ "MNFT" \ https://example.com/metadata.jso

If you use Cursor, Claude Code, or Windsurf daily, you've probably had this experience: You open a fresh chat, ask for a small fix, and twenty minutes later the AI has rewritten your API layer, added three new dependencies, and switched your data-fetching pattern "for consistency." The model isn't broken. It's contextless. Every new session starts from zero. It doesn't know your stack, your conventions, or the things it must never touch. So you spend the first ten minutes re-explaining — and the last hour undoing. Here's what fixed it for me. The real problem isn't prompts Most devs collect prompts. Notes app, Slack snippets, old chat threads. That helps for one-off tasks, but it doesn't solve the session problem. What you need is persistent context — rules that load automatically before you type anything. Two files do this: CLAUDE.md — read by Claude Code (and usable as project context elsewhere) .cursorrules — loaded by Cursor on every session (rename to .windsurfrules for Windsurf) Drop them in your project root. Done. What goes in a good config file A useful config is not ten lines of "use TypeScript and write clean code." That's too vague to change behavior. Mine include: Project structure — where pages, components, and API routes live Stack + versions — Next.js 14 App Router, not Pages; Zod; shadcn/ui Commands — npm run dev, npm run typecheck, npm run test Coding conventions — naming, import aliases, Server vs Client Components DO NOT section — the most important part (more on this below) Workflow notes — use @folder, prefer editing existing files, minimal diffs Here's an excerpt from the DO NOT section that saved me the most time: DO NOT — Critical Anti-Patterns Do NOT create a pages/ directory or use the Pages Router Do NOT rewrite the entire API layer — extend existing route handlers Do NOT add new npm dependencies without stating why Do NOT make drive-by refactors in unrelated files Do NOT fetch data in useEffect when Server Components can fetch directly T

NVIDIA's cuda-python , the official Python bindings for the CUDA toolkit, recently added automatically-generated .pyi stub files using stubgen-pyx . Their description of why: "This allows IDE auto-completion to work (which is also used by IDE-integrated coding agents). This has also found 2 real bugs in our code already. The ability to catch a certain class of bugs with this will be really helpful going forward, especially since our linting abilities with cython-lint are a bit behind what they are in pure Python." When you commit .pyi stubs alongside a Cython extension, you get an artifact your normal Python linting and type-checking pipeline can analyze. Inconsistencies between what the Cython source does and what the stub claims become visible. NVIDIA found two real bugs this way before they were reported. I'm the author of stubgen-pyx, and this post is a technical walk-through of how those stubs are produced. The problem with existing stub generators When you compile a Cython module, the source disappears. What you get is a .so (or .pyd ) file: a compiled extension with no type information readable by a language server. Tools like mypy's stubgen can generate stubs for these by importing the compiled binary and using runtime introspection. The results are usually disappointing. Take this typed Cython module: """ Mathematical utilities for scientific computing. """ cdef class Matrix : """ A simple matrix class. """ cdef int rows cdef int cols def __init__ ( self , int rows , int cols ): """ Initialize a matrix. """ self . rows = rows self . cols = cols def shape ( self ) -> tuple [ int , int ]: """ Get matrix dimensions. """ return ( self . rows , self . cols ) cpdef scale ( self , double factor ): """ Scale all elements. """ pass cdef int _validate ( self ): """ Internal validation (not exposed). """ return 0 def matrix_product ( Matrix a , Matrix b ) -> Matrix : """ Compute matrix product. """ return Matrix ( a . rows , b . cols ) Running stubgen on the compiled

The 30-second version Anthropic shipped Claude Opus 4.8 a few hours ago. Every benchmark on the announcement page is up: SWE-bench Verified, GPQA, MATH-500, the agentic tool-use evals. The marketing copy reads as it always does — "our most capable model", "strongest coding performance", "better instruction following". If you have been around since 4.5, you know the shape of this announcement by heart now. The announcement skipped the only question that matters for teams running Claude in production: should you upgrade today, next week, or next month, and which of your workloads should stay on Opus 4.7 indefinitely? Anthropic does not write that part. They cannot — it is workload-dependent, and the answer for a code-review agent is different from the answer for a customer-facing chat product. This post is the decision tree I am applying to my own stack today. It is opinionated. Three of the workloads I run are staying on 4.7 until at least mid-July, and I will explain exactly why. Your mileage will vary, but the reasoning shape should transfer. What actually shipped in Opus 4.8 Let me anchor on the facts before the opinion. Opus 4.8 is the third release in the Opus 4.x family this year. The pattern across 4.6 (March), 4.7 (April), and 4.8 (today) has been roughly monthly. Each release has shipped a 2-4 point bump on SWE-bench Verified and a similar bump on the agentic evals. 4.8 follows the pattern: roughly 3 points on SWE-bench, about 2 points on the multi-step tool-use benchmark, and a more visible jump on the long-context retrieval evals — the 'needle in a haystack at 200K tokens' style tests. Three changes are worth pulling out of the announcement: Better long-context coherence . The 4.8 release notes specifically call out improved behavior on tasks that span more than 100K tokens of context. Concretely: less mid-context summarization, fewer instances of the model 'forgetting' early-context instructions, better citation of source material when retrieved chunks sp

The interpreter's variable lookup is now blazing through arithmetic loops at a 57% faster pace. But this isn't just about raw speed — four tracker items were checked off the list, culminating in a more robust system. All rolled out on submain, a direct result of a thorough four-pillar audit. BindingId replaces string hashing at runtime The heavyweight change came from tracker #009. Previously, our interpreter was busy hashing variable names every time they were accessed. That was a repeat offender in wasted cycles. Now, by using a pre-assigned numeric BindingId, we seize efficiency. The semantic phase was already handing out these IDs, but the runtime kept adding the overhead back. It doesn’t anymore. ScopeFrame.vars has transitioned to a HashMap equipped with a zero-cost identity hasher keyed by u32 binding IDs. Name-based lookups are still around but tucked away for less frequent operations like string interpolation. Fixes were necessary upstream: ConstDecl and semantic_impls now hold onto their BindingId, making sure our semantic phase pipelines gracefully into the interpreter's primary key system — narrowing the gap with JIT's variable handling. Here's how the numbers shine on a Windows release build: arith_loop (5M iterations): from 5744ms down to 2481ms (56.8% boost) nested_loops (4M iterations): from 2675ms down to 1796ms (32.8% boost) fib_recursive: from 6835ms down to 6488ms (merely 5.1% faster due to call-frame constraints) Our findings align with expectations: recursive functions aren't bogged down by variable lookups as much as by setting up call frames. Array bounds errors stop lying Misleading diagnostic labels are on their way out, thanks to tracker #002 and #032. Attempts to access out-of-bounds array indices once triggered an error as unhelpful as variable 'index 5' has not been declared . Not anymore. Changes came in two waves. First, we introduced a new error variant: RuntimeError::IndexOutOfBounds { pos, index, length } . Then, three runtime.rs c

Retry storms turned 1 timeout into 340 duplicate calls billed in 90 seconds Infinite tool loop ran 1,200 iterations before I noticed at 2am Partial stream cleanup stopped half-written DB writes corrupting records Trap every error class with a circuit breaker and a hard iteration cap Five Claude API errors quietly drained my account before I built guards around them. None of them threw a loud crash. They just kept billing while I slept. Here is exactly what broke, what it cost, and the traps I now run on every project. The Retry Storm That Billed 340 Times in 90 Seconds The most expensive mistake I made was naive retry logic. A single request timed out. My code caught the timeout and retried. The retry also timed out, so it retried again. Within 90 seconds I had fired 340 requests for one piece of work. The problem was that the Claude API had actually received and processed several of those requests. The timeout happened on my side waiting for the response, not on Anthropic's side. So I was paying for completed work I never saw, then paying again for the retry. My first version of the retry looked harmless. A while loop, a counter set to 5, a sleep of one second between attempts. The flaw was that the sleep was constant and the counter reset on every new job. Under load, jobs stacked, and each one spawned its own retry chain. That is how 1 timeout became 340 calls. The fix was exponential backoff with a hard ceiling and a request ID. I now generate a unique idempotency-style key per logical job and refuse to issue a second call for the same key until the first fully resolves or hard-fails. Backoff starts at 2 seconds and doubles up to 32 seconds, then gives up after 5 total attempts. attempt = 0 delay = 2 while attempt < 5 : try : return call_claude ( job_key ) except Timeout : attempt += 1 sleep ( delay + random_jitter ()) delay = min ( delay * 2 , 32 ) raise GiveUp ( job_key ) The jitter matters more than it looks. Without it, ten failed jobs all retry at the exact

Have you ever wondered how Discord keeps your channel messages available even when a server goes down? Or how Amazon DynamoDB serves petabytes of data with single-digit millisecond latency? The unsung hero powering almost all these distributed systems is hashing — a simple but powerful technique that makes even load distribution, fast lookups, and seamless scaling possible. As more applications move to distributed cloud architectures, understanding hashing for distributed systems is no longer optional for developers. Choosing the wrong hashing algorithm can lead to cascading failures, cache stampedes, and expensive downtime. This guide breaks down every core hashing technique, real-world use cases, best practices, and common pitfalls to avoid in 2026. Table of Contents What is Hashing in Distributed Systems? Core Hashing Algorithms Explained Traditional Modulo Hashing Consistent Hashing Virtual Nodes (VNodes) Rendezvous Hashing (HRW) Jump Consistent Hash Maglev Hashing Multi-Probe Consistent Hashing Consistent Hashing with Bounded Loads Real-World Applications of Distributed Hashing Head-to-Head Algorithm Comparison Best Practices for Distributed Hashing Common Pitfalls to Avoid Conclusion References What is Hashing in Distributed Systems? Hashing in distributed systems is the practice of mapping data keys (e.g., user IDs, object keys, channel IDs) to server nodes using a deterministic hash function. The core goals are: Distribute load evenly across all nodes to avoid hotspots Enable fast lookups (O(1) or O(log N)) without a central coordinator Minimize data movement when nodes are added or removed during scaling Support fault tolerance by simplifying replication across nodes The simplest implementation is modulo-based hashing , where node_id = hash(key) % N and N is the total number of nodes. While trivial to implement, it suffers from a fatal flaw: the rehashing problem. When N changes (a node is added or removed), nearly all keys are remapped to new nodes, causin

We’ve all been there: every year, you get a physical, receive a thick PDF full of blood markers, glance at the "normal range" checkmarks, and toss it into a digital folder titled "Health Stuff" to be forgotten. But what if I told you that those isolated data points are actually a time-series story of your biological aging? In this tutorial, we are going to build a Longevity Knowledge Graph . We will leverage GraphRAG (Graph-based Retrieval-Augmented Generation) , Neo4j , and Unstructured.io to transform a decade of messy medical PDFs into a structured intelligence layer. By the end of this post, you'll be able to query your health history with context that standard vector search simply can't grasp—like "How has my fasting glucose trended relative to my BMI over the last five years?" If you're interested in advanced data engineering patterns or looking for more production-ready AI health architectures, I highly recommend checking out the deep dives over at WellAlly Blog , which served as a major inspiration for this build. Why GraphRAG? (The Problem with Vector Search) Standard RAG (Retrieval-Augmented Generation) is great at finding a specific needle in a haystack. But if you ask, "What is the relationship between my Vitamin D levels and my bone density over time?", a vector database might just pull three separate paragraphs. GraphRAG allows us to: Connect Entities : Link a Blood_Metric (e.g., LDL) to a specific Time_Point . Traverse Relationships : Follow the path from User -> Report -> Marker -> Trend . Global Reasoning : Summarize high-level health trajectories across multiple years of data. The Architecture 🏗️ Here is how the data flows from a messy PDF to a queryable graph: graph TD A[Medical PDF Reports] -->|Unstructured.io| B(Clean JSON/Elements) B -->|Entity Extraction| C{LLM Processing} C -->|Nodes & Edges| D[Neo4j Graph Database] D -->|GraphRAG Query| E[Longevity Insights] F[User Query: 'Is my HbA1c rising?'] --> E subgraph Storage D end Prerequisites To f

Explore our ambitious, people-first industrial policy ideas for the AI era—focused on expanding opportunity, sharing prosperity, and building resilient institutions as advanced intelligence evolves.

Nearly a year after it was announced, Instagram says it's delivering the ability to rearrange the posts in your profile grid. It had been available to some people in test groups, but as of June 8th, it's rolling out widely via the Android and iPhone mobile apps. Until now, the posts on your Instagram profile […]

A pattern keeps repeating itself in AI projects. The model works. The demo works. The proof of...

Apple spending a big chunk of its WWDC keynote on parental controls was surprising for several reasons. But the biggest is that, despite all the airtime, it didn't announce much new beyond a redesigned interface. Almost all the features touted already exist or are upgrades to current options. Why Apple chose to do this isn't […]

I’ve been trying different AI tools lately, and I’m starting to notice that each one has its own strengths and weaknesses. Some feel better for writing. Some are better for research. Some are stronger for coding, image generation, brainstorming, or organizing messy ideas. For people who use AI regularly, what tool do you trust most for specific tasks, and which ones do you avoid for certain work? submitted by /u/GlobalOpsNotes [link] [留言]

iOS 27 has only been out for a few hours, and I've been messing around with the developer beta on my iPhone 16 Pro. I was most interested in trying out the new Siri AI, but unfortunately, I'm still on Apple's waitlist for that. In the meantime, I've been poking around a bunch of features […]

Hi HN, I'm the creator of Mach ( https://github.com/octalide/mach or https://machlang.org ). Two days ago, we finally achieved full self hosting. I wanted to make a post here to show off the language since this is a big milestone for us. ## TL;DR about the language for those curious: - There are no external dependencies anywhere in the pipeline. This includes LLVM, libc bindings, or anything of the sort (save for the historical bootstrap compiler, which requires any C compiler and has been phase

Hi HN, Over the last few days I've been building USTPS (UDP Speedy Transmission Protocol Secure), an experimental encrypted transport protocol built on top of UDP. The primary goal of USTPS is low-latency video streaming. A server can take a video source and expose it through a USTPS endpoint, while Linux and Android (Termux) clients receive the stream and expose it locally to applications such as VLC, mpv, and FFmpeg. Although streaming is the main focus, USTPS is not limited to media delivery.

Is it just me, or does anyone else find they can't help themselves troll AI sometimes. Like I will use Claude for a long research project, write and refine a report, and once done I just love fucking with it. Like asking it to rewrite the report because I am going to send it over to a 4 year old to review, so if you could please put the whole thing in baby talk. Or ask it what I can put on the slides when I present it in order to guarantee that anyone who sees it will become incredibly attracted to me. Or ask it to find the closest tattoo shop near me because I am going to get this whole report tattooed on my ass and moon people on the street as a guerilla marketing experiment. Is my life so dull that I have to resort to fucking with a robot to feel feelings? submitted by /u/musicheadspace [link] [留言]

Tools for Humanity, Sam Altman's identity verification company, is reportedly struggling to generate revenue and will downsize its staff.

The vibe of Apple's 2026 WWDC keynote felt like a spouse proudly listing all the honey-do-list items tackled. One subtle example: the many AI demos of someone standing, phone in hand.

The same general situation has happened to me twice now and I am wondering if it’s something I can break free from or if it’s just the nature of the Startup beast - or what. There seems to be some kind of bubble that starts drying up investment in a startup where I am a technical lead. Both times, things seem to be going well and then 2 years in there are rounds of layoffs due to factors outside my/product’s control where the result is the same. I end up as the last tech generalist. It falls to