标签：#us

GPU programming usually asks Rust developers to surrender the borrow checker at the launch boundary: references collapse into raw pointers, and aliasing, synchronization, and stream lifetimes become hand-managed invariants. A new NVIDIA Labs paper argues that trade is unnecessary. How cuTile Rust Extends the Borrow Discipline to GPU Dispatch cuTile Rust is a tile-based DSL that carries Rust's ownership and borrowing rules across the host-to-GPU launch boundary — not just through host code. Introduced in "Fearless Concurrency on the GPU" (arXiv:2606.15991), submitted by NVIDIA researchers Melih Elibol, Jared Roesch, Isaac Gelado, Eric Buehler, and Michael Garland , it lets you author the kernel itself in idiomatic, memory-safe Rust rather than wrapping hand-written unsafe CUDA. The mechanism is type construction, not a runtime lock. Before launch, mutable output tensors are partitioned into provably disjoint tiles; each tile program then receives an exclusive &mut view of its slice, while inputs arrive as shared & references . Because the partitions cannot overlap, the kernel is single-threaded in its semantics and data-race-free by construction, yet still compiles to massively parallel GPU code. As Melih Elibol put it, "each tile program gets an exclusive &mut view of its memory, plus the inputs as shared references" (source: users.rust-lang.org ). Explicit unchecked types remain available for local opt-out when you need lower-level control. The safety story would be academic if it cost throughput, but the reported numbers say otherwise. On an NVIDIA B200, cuTile Rust reaches 7 TB/s on memory-bound element-wise operations and 2 PFlop/s on GEMM — roughly 96% of cuBLAS, and within measurement noise of cuTile Python . End to end, the companion Qwen3 inference engine Grout reaches 171 generated tokens/s for Qwen3-4B on an RTX 5090 and 82 tokens/s for Qwen3-32B on a B200 in batch-1 decode . Those are the authors' own measurements on specific hardware — independent reprod

We moved off our first tracer in month eight. The migration took one engineer the better part of a sprint, because the trace data lived in a schema we did not own. Nobody costed that line item on day one. I am writing this so you can. I run reliability for a small team shipping LLM features. When the pager goes off at 2am, I do not care which dashboard is prettiest. I care about two numbers: what this tool costs me per month, and what it costs me to leave. Those two numbers are the whole story, and they are almost never on the comparison page. So here are six Langfuse alternatives. For each I tracked both numbers: the monthly bill on the invoice, and the exit bill that only shows up the day you migrate. I compared Helicone, Arize Phoenix, LangSmith, Braintrust, Laminar, and Future AGI traceAI. They all trace LLM calls (prompts, tokens, retrieval spans, latency). The axis that decides your exit cost is whether the trace format is OpenTelemetry-native or a vendor schema. Get that wrong and the migration bill lands later, with interest. The cost nobody puts on the pricing page Your monthly invoice is the visible cost. The exit cost is the invisible one: re-instrumenting the app, rebuilding integrations, and losing historical traces when the schema does not travel. If your spans are OTel, the exit cost trends toward zero because the data is portable by construction. If they are proprietary, you are paying a deferred bill every month you stay. Sort on that first. Helicone. The gateway-first option. You proxy model calls through it and get logging, cost tracking, and analytics with almost no code change. Apache-2.0, self-hostable, roughly 5,800 GitHub stars as of June 2026. On pure observability ergonomics this is one of the strongest picks, and the proxy model means low setup cost. The thing to watch at scale: a gateway in the request path is one more hop to reason about when latency spikes. Arize Phoenix. The open-source OTel option. Tracing plus evals, self-hostable, a

As Anthropic tightens restrictions on access to Claude in China, users keep finding new workarounds, from proxy services to fake identities sourced on Telegram.

FCC refuses to provide messages, has "wasted a year" of court's time, filing says.

Everyone is selling AI to small businesses right now. Most of it is hype. But some of it is genuinely useful — and knowing the difference can save you thousands in wasted tooling. I run a small agency in Stuttgart that builds websites and automations for local service businesses: coaches, doctors, beauty studios, consultants. Here's what actually moves the needle for them in 2025. What "AI Automation" Actually Means for Small Businesses Forget the generic pitch. For a local service business, AI automation is useful in exactly three places: Client communication at scale — responding to inquiries 24/7 without hiring a receptionist Reducing admin time — intake forms, follow-ups, reminders, invoicing triggers Content creation — but only as a speed boost, not a replacement for your voice Anything beyond that is usually overkill for a business under 10 employees. The One Automation Every Service Business Should Have Automated follow-up after initial contact. Here's the typical flow without automation: Client fills out contact form You see it 4 hours later You write a reply If you're busy, it takes a day Client has already booked elsewhere With automation: Client fills out form Immediate confirmation email ("Got your message, here's how to book a slot") Link to booking calendar You're notified. If they don't book in 48h, a follow-up email goes out automatically This alone converts 20-40% more inquiries into booked clients. No AI model needed — just a simple workflow in n8n, Make, or Zapier. Where LLMs Actually Help Language models (ChatGPT, Claude, etc.) are genuinely useful for small businesses in these areas: Intake Forms → Personalized Responses A coaching client fills out a detailed intake form. Normally, you'd spend 20 minutes reading it and writing a personalized welcome email. With a simple LLM integration: Intake form submitted Webhook fires to n8n LLM reads the form, generates a personalized summary + welcome You review it in 30 seconds and hit send Same personal

The White House asked OpenAI to delay the rollout of its GPT-5.6 AI models, two weeks after Anthropic had to take its most advanced AI models offline.

It's a stretch to think that the continent can build a top-tier model, but it has an advantage: Donald Trump.

GitHub热门项目 | Unlock 2x more Claude Code and Codex usage | Stars: 237 | 14 stars today | 语言: Rust

GitHub热门项目 | Incredibly fast JavaScript runtime, bundler, test runner, and package manager – all in one | Stars: 93,472 | 74 stars today | 语言: Rust

Aseon Labs, which came out of Y Combinator's 2026 spring cohort, has raised $10 million from Crane Venture Partners and others.

Nine jurors. Two hours of deliberation. Twenty-six claims at the original federal complaint's peak. Three surviving claims at trial. Zero claims surviving the verdict. One hundred fifty billion dollars of maximum disgorgement exposure if the verdict had gone the other way. One hundred thirty billion dollars of OpenAI Foundation equity stake under the October 28, 2025 recapitalization. Thirty-eight million dollars of total Musk contributions per his sworn trial testimony. Forty-four million per the legal complaint. Eight years from the January 2, 2016 Sutskever-Musk "less open / Yup" email exchange to the August 2024 federal filing date. Three years of statute-of-limitations runway on the breach-of-charitable-trust claim; two years on the unjust-enrichment claim. The verdict in Musk v. Altman came in this morning at the federal courthouse on Clay Street in Oakland, before Judge Yvonne Gonzalez Rogers in the Northern District of California. The companion piece, The Calendar Technicality , makes the doctrinal argument that the procedural dismissal is the substantive determination California charitable-trust law would have produced on the merits as well. This piece takes the same conclusion through the numbers. The dollar-and-time math closed the merits door before the doctrinal door even came into view. Two hours, in context Federal-court civil-trial deliberations on complex commercial cases typically run between one and five days. The Administrative Office of the U.S. Courts' annual judicial-business reports show median civil-jury deliberation in the multi-day range for cases with three or more issues to resolve and dollar exposure above one billion. The two-hour deliberation in Musk v. Altman is roughly one to two standard deviations below the median for cases of this complexity. The brevity is not a function of jury inattention. The trial ran three weeks. Roughly four hours of testimony came from Altman alone on May 12, with cross-examination opening with Musk's lea

👋👋👋👋 Looking back on your week -- what was something you're proud of? All wins count -- big or small 🎉 Examples of 'wins' include: Getting a promotion! Starting a new project Fixing a tricky bug Found a new song so good it fixed your whole mood 🎵 Happy Friday!

Most developers use AI like a smarter Stack Overflow . Type a question. Get an answer. Go do the work yourself . That's fine but it's the slow way 😩 There's a faster mode, and most people haven't switched to it yet. Diff: Asking & Delegating When you ask an AI : "How do I write tests for my auth module?" You get a nice explanation. Then you write the tests yourself. You're still doing the work 🥸 When you delegate to an AI agent: "Write tests for /src/auth.py . Cover login, logout, and invalid token cases. Run them. If any fail, fix the code until they pass. Tell me what you changed." The agent opens your files, writes the tests, runs them, reads the failures, fixes the code, and comes back to you with a working test suite. You review the result. You didn't do the work. That's the shift 🙂‍↔️ It sounds small. The time difference is huge . How to write a good delegation Every delegation that works has four parts . Think of it like giving a task to a new team member: Goal: what should it produce? Scope: which files or area of the codebase? Success condition: how do we know it's done correctly? Report back: tell me what you changed and why. Here's what that looks like in practice: Debugging: "Here's the error and the stack trace. Find the root cause, fix it, and explain what was broken." Why this works: You're not asking what the error means. You're handing over the whole problem, find it, fix it, explain it 😎 Refactoring: "Refactor this file. Max two levels of nesting. No single function longer than 30 lines. Update every call site in the codebase." Why this works: The constraints are clear and checkable . The agent knows exactly when it's done 🧐 Database migration: "Write a migration script for this schema change. Make it idempotent. Run it against a local test database and confirm it succeeds." Why this works: You gave it a way to verify its own work before coming back to you 🤔 PR review: "Read this PR diff. Find anything that could fail in production. Write the tests

Rule of thumb If your action waits on something external , make it async . If it’s instant CPU , keep it sync ; for expensive CPU , offload . The core idea Async shines for I/O-bound work (DB calls, HTTP calls, queues, files). It frees the request thread while waiting, so the server can serve more requests with the same thread pool . Sync is fine for trivial, short CPU work (formatting, small calculations) where you’re not awaiting anything and the handler returns in a few milliseconds. When to choose async You call EF Core ( SaveChangesAsync , ToListAsync ), HttpClient , Azure SDK ( ServiceBusClient , BlobClient ), file I/O, or any API with Async methods. You expect latency from a dependency (tens–hundreds of ms). You need cancellation and timeouts (propagate HttpContext.RequestAborted ). When sync is acceptable The action is pure CPU and trivial (e.g., quick math, mapping, input validation) and returns immediately. There are no I/O waits and no benefit from freeing the thread. If it’s CPU-heavy (image processing, big JSON transforms), do not just make it async—offload to a background queue/worker or a separate compute service. Async won’t make CPU faster. Pitfalls to avoid Don’t block async : never use .Result / .Wait() on Tasks (deadlocks/thread-pool starvation). Async all the way down : if the controller is async, downstream calls should be too. Don’t fake async : returning Task.Run around synchronous I/O just burns threads. Keep concurrency bounded when fanning out to multiple I/O calls. Mini decision checklist Any I/O? → Use async (end-to-end). Pure CPU? Tiny (≤ a few ms) → Sync is fine. Heavy/variable → Offload to background worker; controller returns 202/Location or uses a queue. ASP.NET Core examples Async (I/O-bound) — recommended [ ApiController ] [ Route ( "orders" )] public class OrdersController : ControllerBase { private readonly OrdersDbContext _db ; private readonly HttpClient _http ; public OrdersController ( OrdersDbContext db , IHttpClientFactory

Diagrid has announced the release of Dapr 1.18, introducing what it calls Verifiable Execution, a new set of capabilities designed to bring cryptographic trust, provenance, and tamper-evident execution records to distributed applications and AI agents. By Craig Risi

Porn music videos have circulated on the fringes of the internet for years. Featuring everything from narrative-driven stories to hypnosis, they are proliferating across X as “bate fuel” for gooners.

For a long time, I thought programming wasn't for people like me. Not because I wasn't interested in technology. Not because I didn't enjoy solving problems. But because I kept hearing the same thing over and over again: "You need to be good at math to become a programmer." The more I heard it, the more I believed it. Whenever I saw developers building websites, apps, or cool projects, I assumed they were all math experts. 🧮 I imagined them solving complex equations all day while I struggled with basic math concepts. So before I even wrote my first line of code, I had already convinced myself that programming probably wasn't for me. And honestly, I think many beginners feel the same way. 🤔 The Fear Was Bigger Than The Reality When I finally started learning programming, I expected math to be my biggest challenge. It wasn't. My biggest challenge was understanding why things weren't working . I spent hours trying to figure out: Why isn't this button working? 🖱️ Why is this variable undefined? 🤨 Why did this code work yesterday but not today? 😅 Why did fixing one bug create three new bugs? 🐛 Very quickly, I realized that programming wasn't testing my math skills nearly as much as it was testing my patience and problem-solving ability. Most of the time, the challenge wasn't: "Can you solve this equation?" It was: "Can you figure out what's causing this problem?" 🧠 Logic Matters More Than Most People Think One of the biggest lessons I learned is that math and logic are not exactly the same thing. Yes, math uses logic. But you don't need to be a math genius to think logically. Programming is often about breaking a big problem into smaller, manageable pieces. For example: If a user clicks a button, what should happen next? If data is missing, what should the application do? If an error occurs, how should it be handled? That's logic. You're constantly thinking: "If this happens, then what should happen next?" And honestly, that's a huge part of software development. Some of

Everything is expensive. Treat yourself to one of these WIRED-tested and -approved Prime Day picks under $30.

TL;DR Welcome back to Dev Opportunity Radar. This is a weekly series where I share opportunities,...

I'm a professional developer, and AI has significantly increased my output—I'd say by maybe 30 or 40 percent. GitHub Copilot has significantly changed the way I work with code. However, I take pride in producing high-quality code quickly, which is why my rates are high. Using AI helps me increase my output while maintaining that level of quality. My take on AI is that it is not going to replace humans anytime soon. It is, however, putting significant pressure on the economy. Previously, setting up a functional, decent-quality project without much complexity took time—at least weeks. Now, such tasks are incredibly fast and easy; anyone can set them up in a few minutes using AI, even without any coding knowledge. Success in most fields, however, is not just a measure of how fast you can build; it's also about how well you can execute. Current AI can offer advice, but it still cannot execute for you. Market success requires sensitivity, context, and adaptability. AI can help significantly if you know how to ask the right questions. But the economy is made of people, not AI (yet). To earn money, someone must give you money because they value what you offer. The arrival of LLMs hasn't changed this. I feel the pressure. The corporation I work for is pushing for AI adoption, and the initial drawbacks and realizations are already becoming apparent. First point: Customers, at best, don't care about your AI. They don't want it. Second point: AI succeeds at making developers more productive but fails with higher complexity—though not for the reason people usually think. With the right prompt, GPT-5.4 can create fairly complex solutions, even more complex than many corporate business processes. The real reason is that, at a certain level, complexity lies not in the total amount of information in the system, but in how the human aspect of the business translates when you try to formalize higher-level context. This is something most developers don't see (or care about). For examp