标签：#p

GitHub热门项目 | Python SDK, Proxy Server (AI Gateway) to call 100+ LLM APIs in OpenAI (or native) format, with cost tracking, guardrails, loadbalancing and logging. [Bedrock, Azure, OpenAI, VertexAI, Cohere, Anthropic, Sagemaker, HuggingFace, VLLM, NVIDIA NIM] | Stars: 51,382 | 152 stars today | 语言: Python

GitHub热门项目 | A format specification for describing a visual identity to coding agents. DESIGN.md gives agents a persistent, structured understanding of a design system. | Stars: 16,759 | 504 stars today | 语言: TypeScript

GitHub热门项目 | Headunit App for displaying Android Auto | Stars: 1,359 | 79 stars today | 语言: Kotlin

GitHub热门项目 | Flutter makes it easy and fast to build beautiful apps for mobile and beyond | Stars: 177,123 | 44 stars today | 语言: Dart

I just completed my bachelor’s last month and I have realised basic programming knowledge about different languages won’t get me any job. So I have decided to pursue Mern stack + Ai integration path. However I don’t have any money to buy courses. Lucky I have an internet connection and a laptop. I’m already familiar with basic javascript and I want to dive into the intermediate level at the least ASAP! Are there any free courses online for Mern ?? I’m already looking into freecodecamp. However if there are other unpopular options available, help would be appreciated. Thanks!! PS :- I attached google link cuz didn’t know what else to do. submitted by /u/Mental-Parsnip-8026 [link] [留言]

Google’s first new smart speaker in six years is here and once again leads its competitors—now with paywalled features.

Synchronous billing is easy, and that's the problem — it makes you think all billing is easy. When a request does its work inline, the billable number is in the response by the time you send it. The gateway meters from there — the meter write, retries and all, is its problem, not yours. From your side, synchronous billing is one number in the response. Asynchronous work breaks that. The request submits a job; the work happens later, in a worker; the result comes back through a poll or a callback. And the thing you bill for — characters processed, pages converted — isn't known when the request arrives. It's known when the job finishes . So you can't meter at the edge. The meter has to fire from the completion path. And the real difficulty is firing it exactly once per unit of completed work — because requests, polls, and retries all conspire to make that zero times or many times. This is platform-agnostic. Every submit-process-poll API has it. I'll use the system I run as the example, but the shape is the same anywhere. Three ways metering goes wrong On arrival. Carry the synchronous habit over and you meter when the job is submitted. But you don't know the size yet, so you're forced into a crude flat fee — or you bill for work that hasn't happened and might fail. Wrong unit, wrong time. On retrieval. The subtle one. You wire the meter to fire when the client fetches the result. Now a client who submits a job, lets it run — costing you real money downstream — and never bothers to poll is never billed. You did the work for free. "Completion" is not "the client picked up the result." It's the worker finishing. Without a fixed quantity. Input characters or output characters? Pages before OCR or after? If you haven't decided exactly what you measure and where, invoices drift and customers argue. Decide once; measure there. All three point the same way: meter on measured work-completion, with a fixed definition of the unit. Not on arrival. Not on retrieval. The mechanism:

On April 29, 2026, Nathan Sobo published the Zed 1.0 announcement post on Zed's blog. The post landed on Hacker News at 2,047 points and 663 comments — the highest-engagement HN story in the present cache by a substantial margin. The launch announcement is a milestone marker after five years of development, roughly a million lines of Rust, and a custom GPU-accelerated UI framework called GPUI that the Zed team built from scratch rather than building atop Electron, Chromium, or any other browser engine. The structural argument Zed has been making for the last several years is condensed in one sentence from Sobo's post: "Instead of building Zed like a web page, we built it like a video game, organizing the entire application around feeding data to shaders running on the GPU." The video-game framing is not metaphorical. Zed's editor surface is composited by feeding glyph atlases, syntax-tree-derived color spans, and pane-layout geometry into GPU shaders the way a video-game engine composites its frames. The reason this matters is the reason the Zed team gave for starting over from the Atom era: Atom was built as a fork of Chromium, and the same team that built Atom is the team that spawned Electron. The Atom-Electron-VSCode lineage is, in the historical-causal sense, Zed's own. Sobo's post is unusually direct about the inherited limitation: "Electron eventually became the foundation of VS Code (which today seems to be forked into a new AI code editor every other week). Web technology offered an easy path to shipping flexible software, but it also imposed a ceiling. No matter how hard we worked, we couldn't make Atom better than the platform it was built on." The 1.0 announcement is, in part, a statement that the rebuild from scratch has finally cleared that ceiling. Who built it Zed's three co-founders all worked on Atom at GitHub before founding Zed Industries in 2021. Nathan Sobo led the Atom team from 2011 to 2018; he also co-led Teletype for Atom, one of the first

Three AI stories landed this week that all poke at the same nerve: the images, video, and films we actually look at are getting an AI layer — and the line between "real" and "AI-made" keeps thinning. Quick rundown in the short, then my take below: 1. ChatGPT will start showing real, licensed photos — not AI fakes. OpenAI signed a multi-year display deal with Getty Images, so licensed photography shows up inside ChatGPT's search and discovery. It's display-only — the photos aren't used to train models. The twist I can't get over: AI image generation had nearly wiped Getty out (stock down ~55% on the year), and this one deal sent the shares up ~145%. The thing AI almost broke got rescued by AI. 2. ByteDance — yes, TikTok's parent — teased Seedance 2.5: a full 30-second video generated in a single shot, no stitching, up to 50 reference inputs, 4K. Most tools still cap out around 5–10 seconds, so "30s native, one pass" is a real jump in how usable the output is. Public launch is early July. 3. Google DeepMind is partnering with A24 on AI filmmaking — a ~$75M, non-exclusive deal to co-build Veo-powered tools. Notably Google gets no access to A24's film library or data. A prestige studio building with AI in the open makes the whole "AI in Hollywood" debate a lot less hypothetical. As someone building a daily AI-news pipeline on the side, the Getty one is the story I keep chewing on. So much of the "AI vs creators" fight has been framed as scrape-or-die. A display-licensing deal is a third option — pay to show the real thing, instead of generating a confident fake or quietly training on someone's work. I don't know if it scales, but it's the first move in a while that didn't feel zero-sum. The Seedance + A24 pair points the other way though: generation is getting longer, more controllable, and is walking straight into real production. So we get both at once — more verified real media and more convincing synthetic media, in the same week. Curious where other builders land:

You have an API response. You want a Zod schema. So you paste the JSON into a JSON-to-Zod converter, copy the output, and ship it. Here's the trap: a lot of those converters infer basic types only . Your email , your uuid , your url , your ISO timestamp — they all come out as z.string() . The schema compiles, the types look right, and your validator quietly accepts "not-an-email" , "ftp://nope" , and "2026-99-99" forever. I wanted to see exactly how much gets lost, so I ran the same payload through two tools and diffed the output. Everything below is real, copy-pasteable output — nothing edited. The input A pretty ordinary user object: { "id" : "3f2a9c1e-5b7d-4e8a-9f1c-2d3e4f5a6b7c" , "email" : "ada@example.com" , "website" : "https://ada.dev" , "age" : 34 , "rating" : 4.7 , "created_at" : "2026-03-04T10:15:30Z" , "is_active" : true , "address" : { "city" : "Lyon" , "zip" : "69001" }, "tags" : [ "early-adopter" , "beta" ] } Tool 1 — json-to-zod (npm) const user = z . object ({ id : z . string (), email : z . string (), website : z . string (), age : z . number (), rating : z . number (), created_at : z . string (), is_active : z . boolean (), address : z . object ({ city : z . string (), zip : z . string () }), tags : z . array ( z . string ()), }); Structurally correct. But every meaningful field is a bare z.string() / z.number() . This schema will happily validate email: "lol" and created_at: "yesterday" . Tool 2 — TypeMorph import { z } from " zod " ; export const userAddressSchema = z . object ({ city : z . string (), zip : z . string (). regex ( /^ [ A-Z0-9 ][ A-Z0-9 \s\-]{1,8}[ A-Z0-9 ] $/i ), }); export type UserAddress = z . infer < typeof userAddressSchema > ; export const userSchema = z . object ({ id : z . uuid (), email : z . email (), website : z . url (), age : z . number (). int (). min ( 0 ). max ( 150 ), rating : z . number (). min ( 0 ). max ( 5 ), created_at : z . iso . datetime (), is_active : z . boolean (), address : userAddressSchema , tags :

The Switch 2’s price is set to increase by $50 on September 1st, starting at $499.99, so if you’re purchasing one before that (or you already own one), now’s a good time to also save on accessories while you can. Amazon’s Prime Day has delivered many great game deals, but some of the best sales […]

AI has made it easier to produce working software. That part is real. It can write code, draft documents, research a topic, scaffold a prototype, and debug a problem faster than most teams can finish writing a decent ticket. But faster building doesn't automatically mean better product decisions. That's the part I keep coming back to. For decades, software teams optimized around delivery. Requirements, design, development, QA, release. Waterfall softened into Agile. Agile grew into DevOps. The practices changed, but the assumption underneath stayed pretty stable: building software is expensive, so plan carefully before you start. That made sense because, for a long time, it was true. Now that assumption is breaking. AI is doing to software what calculators did to accounting. It isn't eliminating the job. It's moving the job up a level. The syntax, boilerplate, first draft, and some of the debugging are getting offloaded. The work doesn't disappear. The bottleneck moves. Learning is still expensive Here's what didn't get cheaper: understanding what people actually need getting stakeholders aligned deciding what evidence would change your mind putting something real in front of users reading the signal without fooling yourself The old question was: Can we build it fast enough? The new question is: Do we understand the problem well enough? That sounds like a small shift, but it changes the work. It changes what strong engineers spend time on. It changes what product people need from engineering. It changes how teams should define "done." If the code ships but nobody learns anything, did the team actually move forward? Sometimes yes. Often no. Users don't know until they can touch it People are not great at specifying requirements up front. Not because they're difficult. Because they're human. Most of us don't know how we feel about something until we can react to a version of it. A mockup. A prototype. A rough slice. A real workflow with sharp edges. So the fastest pat

Most TypeScript tutorials teach you the language. This article teaches you how to use it. There's a difference. The language has hundreds of features. A real project uses maybe twenty of them regularly, and about eight of them make up the difference between TypeScript that fights you and TypeScript that helps you. These are those eight. Each one comes from a pattern I've seen repeatedly in real codebases: first as an antipattern, then as a realization, then as a habit. The goal isn't to show off advanced type gymnastics. It's to show you the specific things that make your code safer, more readable, and less painful to maintain. TL;DR Most TypeScript pain comes from fighting the type system instead of working with it, any , manual casting, and loose types are the usual culprits. A small set of features, discriminated unions, utility types, satisfies , as const , generics, solve the majority of real-world typing problems. The best TypeScript isn't the most complex. It's the most precise. Table of Contents Tip 1: Use Discriminated Unions Instead of Optional Fields Tip 2: Stop Writing Types Twice with Utility Types Tip 3: Use satisfies to Validate Without Losing Inference Tip 4: Use as const for Literal Types That Don't Drift Tip 5: Write Type Guards Instead of Casting Tip 6: Use Generics to Write Functions Once Tip 7: Use ReturnType and Parameters to Stay in Sync Tip 8: Use unknown Instead of any for External Data Honorable Mentions Final Thoughts Tip 1: Use Discriminated Unions Instead of Optional Fields This is the tip that changes how you model data in TypeScript. Once you see it, you'll spot the antipattern everywhere. The antipattern // ❌ A type that tries to represent multiple states with optional fields interface ApiResponse { data ?: User error ?: string isLoading : boolean } The problem: this type allows impossible states. Nothing stops you from having both data and error set at the same time, or neither set, or isLoading: false with no data and no error . The

Você já fez um commit no repositório do trabalho e percebeu que estava com o seu e-mail pessoal? Ou o contrário? Esse é um dos erros mais comuns de quem usa Git com múltiplas contas no mesmo computador. Neste tutorial você vai aprender a configurar tudo corretamente, de uma vez, usando chaves SSH separadas e .gitconfig condicional — sem gambiarras. O problema Por padrão o Git usa uma configuração global: git config --global user.name "Seu Nome" git config --global user.email "seu@email.com" Isso significa que todos os repositórios no seu computador usam o mesmo usuário. Quando você tem contas separadas (ex: joao@empresa.com no GitLab da empresa e joao@gmail.com no GitLab pessoal), os commits vão sair com o e-mail errado. A solução profissional envolve duas partes: Chaves SSH separadas para cada conta .gitconfig condicional que aplica o usuário certo — e a chave SSH certa — por pasta Passo 1 — Gerar as chaves SSH Abra o terminal e gere uma chave para cada conta. Use nomes diferentes para não sobrescrever: # Chave para a conta pessoal ssh-keygen -t ed25519 -C "joao@gmail.com" -f ~/.ssh/id_ed25519_pessoal # Chave para a conta do trabalho ssh-keygen -t ed25519 -C "joao@empresa.com" -f ~/.ssh/id_ed25519_trabalho 💡 Por que ed25519 ? É o algoritmo mais moderno, mais seguro e recomendado pelo GitHub, GitLab e Bitbucket. Evite RSA a menos que seu servidor seja muito antigo. Ao final você terá quatro arquivos em ~/.ssh/ : id_ed25519_pessoal ← chave privada (nunca compartilhe) id_ed25519_pessoal.pub ← chave pública (você registra no GitLab) id_ed25519_trabalho id_ed25519_trabalho.pub Passo 2 — Registrar as chaves no GitLab Para cada conta: Copie o conteúdo da chave pública: # Pessoal cat ~/.ssh/id_ed25519_pessoal.pub # Trabalho cat ~/.ssh/id_ed25519_trabalho.pub Acesse Settings → SSH and GPG keys → New SSH key na conta correspondente e cole o conteúdo. Faça isso nas duas contas , cada uma com a sua respectiva chave pública. Passo 3 — Configurar o Git por pasta (o pulo do gato)

TL;DR: An API gateway manages HTTP traffic between services — auth, routing, rate limiting, load balancing for REST and gRPC. An AI gateway manages LLM workloads — token-based rate limiting, model routing, cost attribution, semantic caching, guardrails. Use an API gateway for your microservices. Use an AI gateway for your LLM traffic. Most production teams eventually need both, sitting at different layers. This post walks through exactly where each one fits. When we started adding LLM features to our platform, we already had Kong running for our microservices. The instinct was natural: route the LLM traffic through Kong too. Same auth, same rate limiting, same observability stack. One gateway to rule them all. It worked — for about six months, and only in the sense that requests got through. What it didn't give us was anything useful for actually managing AI workloads. We had no idea what each team was spending on tokens. We had no way to set a budget cap that would fire before the bill arrived. Our rate limits were based on requests per minute, which meant a single request with a 50k token prompt counted the same as one with a 200 token prompt. And when OpenAI had a partial outage, Kong had no concept of "try Anthropic instead" — we just served errors. None of that is a criticism of Kong. It's doing exactly what it was designed to do. The problem was us expecting an API gateway to handle a fundamentally different category of infrastructure problem. Here's the precise distinction, and why it matters architecturally. What an API gateway actually does An API gateway is a reverse proxy that sits between client applications and backend services. It handles the cross-cutting concerns of service-to-service HTTP communication: authentication, authorization, rate limiting, load balancing, SSL termination, request transformation, and routing based on URL paths or headers. A typical request flow through an API gateway: Client sends a request to the gateway endpoint Gateway ve

I couldn't find many resources online that showed how to see cache misses on macOS. I thought I'd learn a bit about Instruments, throw some toy problems at it, and write about the experience in a blog post. These toy examples - iterating sequentially then randomly, summing elements in a matrix, naive vs tiled matmul and iterating AoS vs SoA - are great to see some real numbers from L1 data cache misses, but they're far away from real programming problems. What's your experience using tools like Instruments/perf/cachegrind to actually optimize an algorithm? Is it ever needed to measure this at the hardware counter level or can you get away with intuition about the size of your data structure, how it's been accessed and using basic timers? submitted by /u/markuzo1 [link] [留言]

A new member has joined the fulgur family. fulgur-chart — a CLI that takes Chart.js v4-compatible JSON specs and renders deterministic SVG/PNG charts. No browser required. https://github.com/fulgur-rs/fulgur-chart Two things make it different: it doesn't spin up a browser, and for a fixed version, font, and rendering options, the same JSON input always produces byte-identical output. This post covers why I built it, a timing coincidence that made me feel like I was on the right track, and how to use it. Why I wanted graphs in PDFs fulgur and fulgur-chart are built around one idea: AI agents should be able to generate documents that look good . There are three steps to that argument. First, Markdown isn't expressive enough. For client-facing reports, plain Markdown often undersells otherwise strong content. Second, visual quality is persuasive. A well-formatted report lands differently than a wall of text. Third — and this is the one I keep coming back to — in many business workflows, PDF carries more institutional weight than a Markdown file or a transient web page . That authority has two dimensions. There's a cognitive one: PDFs read as "serious documents." Proposals, reports, invoices — the format itself signals credibility. And there's a technical one: PDF can support digital signatures, encryption, and archival profiles such as PDF/A. That's the ground flpdf covers, a pure-Rust PDF toolkit modeled on qpdf's workflow. So the goal is always PDF, not HTML, not a web page. That's what fulgur is for. And a polished report needs charts. But Markdown can't draw charts. Which brings me to a problem I already knew was coming: the Chart.js library requires JavaScript to run . fulgur has no browser and no JS runtime, so there was no path to running Chart.js directly. The design choice: no JS engine The obvious alternative was to embed a JavaScript runtime. I could either run Chart.js with a compatible Canvas implementation, or build a JavaScript renderer that consumes Cha

Modular, one of the most promising chip software startups of the AI era, heads for a multibillion-dollar exit.

The Jeff Bezos-backed startup finally revealed more pricing details for its debut EV, including a $29,950 starting price for the SUV variant, and boosted the base range to 205 miles.

Looking for family fun this summer? You need these WIRED-recommended Prime Day board game deals.