Mentions

All Types of Caching in .NET: When to Use Each (Deep Dive, Part 2) In .NET, you have 6 ways to cache: IMemoryCache, IDistributedCache, Redis, HybridCache, FusionCache, and Output Cache. This is the 2nd part of the Caching in .NET series. Last week, in Part 1 we explored: - Where Each Cache Sits in a .NET App - In-Memory Cache (IMemoryCache) (Part 1) - Distributed Cache (IDistributedCache) with Redis (Part 1) - HybridCache (Part 1) In this post, we will explore each caching option with pros, cons, pitfalls, and when to use it: - FusionCache - Output Cache - Which Cache Should You Choose Let's dive in. --- 👉 Read original article on my newsletter: antondevtips.com FusionCache FusionCache is an open-source hybrid cache that existed years before HybridCache did. It has the same L1 + L2 shape and the same stampede protection. It also has what HybridCache lacks: a backplane that syncs L1 across instances, fail-safe, factory timeouts, and eager refresh. FusionCache is the best caching option available in .NET today. To get started with FusionCache, add these packages: dotnet add package ZiggyCreatures.FusionCache dotnet add package ZiggyCreatures.FusionCache.Serialization.SystemTextJson dotnet add package ZiggyCreatures.FusionCache.Backplane.StackExchangeRedis dotnet add package Microsoft.Extensions.Caching.StackExchangeRedis Then you can configure it in the DI container: var redisConnection = builder.Configuration.GetConnectionString("Redis")!; builder.Services.AddFusionCache() .WithDefaultEntryOptions(new FusionCacheEntryOptions { Duration = TimeSpan.FromMinutes(10), IsFailSafeEnabled = true, FailSafeMaxDuration = TimeSpan.FromHours(1), FactorySoftTimeout = TimeSpan.FromMilliseconds(300) }) .WithSerializer(new FusionCacheSystemTextJsonSerializer()) .WithDistributedCache(new RedisCache(new RedisCacheOptions { Configuration = redisConnection })) .WithBackplane(new RedisBackplane(new RedisBackplaneOptions { Configuration = redisConnection })); Three building blocks are registered here: - Serializer for the L2 payload. System.Text.Json is the default choice. - Distributed cache as L2. This is the same RedisCache type from IDistributedCache. - Backplane as the channel that tells other instances about changes. It uses Redis pub/sub. The handler uses IFusionCache: internal sealed class GetShipmentByNumberHandler( ShipmentsDbContext dbContext, IFusionCache cache) { public async Task<ShipmentResponse?> HandleAsync( string shipmentNumber, CancellationToken cancellationToken) { return await cache.GetOrSetAsync<ShipmentResponse?>( $"shipment:{shipmentNumber}", async (_, ct) => await dbContext.Shipments .Where(s => s.Number == shipmentNumber) .Select(s => s.MapToResponse()) .FirstOrDefaultAsync(ct), tags: ["shipments"], token: cancellationToken); } } You can remove items by key or a tag, exactly like in HybridCache: await cache.RemoveAsync($"shipment:{shipmentNumber}", token: cancellationToken); The difference is what happens after that call on the other app instances: The backplane message carries only the key and the action without a value. Instance B drops its L1 (memory) copy, and the next read on B goes to L2 (Redis) and then to the database. This is the direct fix for the biggest pitfall in HybridCache. Using FusionCache as HybridCache If your handlers already inject HybridCache, you don't have to rewrite them. FusionCache can register itself as the HybridCache implementation: builder.Services.AddFusionCache() .WithSerializer(new FusionCacheSystemTextJsonSerializer()) .WithDistributedCache(new RedisCache(new RedisCacheOptions { Configuration = redisConnection })) .WithBackplane(new RedisBackplane(new RedisBackplaneOptions { Configuration = redisConnection })) .AsHybridCache(); So you continue using HybridCache in your classes. > Note: through the HybridCache adapter you can only pass HybridCacheEntryOptions per call. Fail-safe, timeouts, and eager refresh are configured once in the default entry options. What Else FusionCache Gives You I will only name the features here, since this library deserves its own article: - Fail-safe: when the database is down and the factory throws, FusionCache serves the last known value instead of an error. - Soft and hard timeouts: if the factory takes longer than the soft timeout and a stale value exists, the stale value is returned and the factory keeps running in the background. - Eager refresh: refresh an entry in the background before it expires, so hot keys never see a miss. - Adaptive caching: the factory can set the TTL per entry based on what it loaded. FusionCache has the following advantages: - Backplane: L1 caches stay in sync across instances. - Resilience features: fail-safe and timeouts keep your API answering when dependencies are slow. - Drop-in for HybridCache: the AsHybridCache() adapter keeps your handlers on the Microsoft abstraction. - Mature: in production since 2021, well documented, active maintainer. Here are the drawbacks of FusionCache: - Third-party dependency: one more package to track and upgrade. - Bigger configuration surface: more options means more ways to misconfigure. - Backplane needs Redis pub/sub: a managed Redis tier without pub/sub cannot run it. Output Cache Output Cache is middleware that stores the full HTTP response and serves it on the next matching request. On a hit, your handler and your database never run. This is the biggest win per line of code in ASP .NET Core, and I wrote a dedicated deep dive on Output Cache. During registration, you define named policies: builder.Services.AddOutputCache(options => { options.AddPolicy("shipment-by-number", policy => policy .Expire(TimeSpan.FromMinutes(5)) .SetVaryByRouteValue("shipmentNumber") .Tag("shipments")); }); var app = builder.Build(); app.UseOutputCache(); After that, the endpoint can use it by name: app.MapGet("/api/shipments/{shipmentNumber}", async ( string shipmentNumber, GetShipmentByNumberHandler handler, CancellationToken cancellationToken) => { var shipment = await handler.HandleAsync(shipmentNumber, cancellationToken); return shipment is null ? Results.NotFound() : Results.Ok(shipment); }) .CacheOutput("shipment-by-number"); SetVaryByRouteValue makes each shipment number its own cache entry. For list endpoints, SetVaryByQuery("carrier", "status") does the same for query parameters. Use Tag("shipments") to quickly evict items from a cache. You can inject IOutputCacheStore and evict by tag: internal sealed class UpdateShipmentStatusHandler( ShipmentsDbContext dbContext, IOutputCacheStore outputCache) { public async Task HandleAsync( string shipmentNumber, ShipmentStatus status, CancellationToken cancellationToken) { var shipment = await dbContext.Shipments .FirstAsync(s => s.Number == shipmentNumber, cancellationToken); shipment.UpdateStatus(status); await dbContext.SaveChangesAsync(cancellationToken); await outputCache.EvictByTagAsync("shipments", cancellationToken); } } By default, Output Cache stores responses in memory, which brings back the two-instances problem. For such cases, you will need Redis: dotnet add package Microsoft.AspNetCore.OutputCaching.StackExchangeRedis builder.Services.AddStackExchangeRedisOutputCache(options => { options.Configuration = builder.Configuration.GetConnectionString("Redis"); }); Now every instance serves from the same cached responses, and EvictByTagAsync on one instance evicts for all of them. Important note: ASP .NET Core also has the older Response Caching middleware (UseResponseCaching), which relies on Cache-Control headers sent by the client. It is outdated for APIs. Clients can bypass it, you cannot evict by tag, and it does not support Redis. Use Output Cache instead. Output Cache has the following advantages: - Nothing runs on a hit: no handler, no serialization, no database. - Declarative: one attribute-like call per endpoint, policies in one place. - Tag-based eviction that works across instances with the Redis store. Here are the drawbacks of Output Cache: - Whole-response granularity: you cache the entire payload or nothing. One changed field invalidates everything. - Only GET and HEAD, and only 200 responses, by default. - Authenticated requests are not cached by default. Requests with an Authorization header skip the cache entirely. Output Cache Pitfalls Caching per-user data without varying by user. If you override the default and cache authenticated responses, you must vary by the user, or user A receives user B's shipments: options.AddPolicy("my-shipments", policy => policy .Expire(TimeSpan.FromMinutes(1)) .SetVaryByHeader("Authorization") .Tag("shipments")); Varying by the Authorization header works, but every token is its own entry, so the hit rate drops as the user base grows. Eviction lives in the write path. Every handler that changes shipments must remember to evict the tag; otherwise, stale responses persist until they expire. Put eviction in one place, such as a domain event handler, rather than in each write handler. --- 👉 Read original article on my newsletter: antondevtips.com

Working on AI agent endpoint security and need devs to help with testing on Windows/Mac bc i down own any! XibalbaTechSol/xibalba-shield

Metodología de deep link hijacking: intent-filters VIEW/BROWSABLE, esquemas custom, assetlinks.json y seguir getData() en jadx. Lo interesante viene cuando ese parámetro abre una puerta que la app no pensaba exponer 🚪 github.com/nirajkharel/NotJustAChecklist/blob/mai…

本地跑 AWS 还得开账号？ Floci 是免费本地 AWS 模拟器，docker compose up 就起，S3、DynamoDB、Lambda 能测。 适合本地开发测试，别当真云，先跑核心服务。 你先测哪个，S3 还是 DynamoDB？ #AWS #本地开发 @grok floci-io/floci

MCP 工具多了，省上下文不等于少发数据。 Deep Agents Code 在支持的模型上默认延迟加载 MCP 工具 schema，核心编码工具仍立即可用。官方说明也写得很清楚：完整 schema 仍会发给模型提供商，HTTP 请求未必变小。 评估这类优化时，上下文占用和请求体积要分开看。 deepagents#7304

配置文件类型总被猜错？ SOML 是给人写的配置格式，类型看语法不猜内容，country: no 直接报错，不会变 false，日期时长是真值。 适合被 YAML 坑过的人，还是草案规范，先在小配置上试，别换核心配置。 你被坑最惨的是什么，no 还是版本号？ #配置文件 #开发工具 @grok soml-lang/soml

⭐️PS3 World-app 1.1.0 released by daedra000 🔹12 languages 🔹New Homebrew category of modded PS2 Classics 🔹Added "What's new in the last 30 days" 🔹Anything >1 GB says size and time before it starts 🔹Check free space on the HDD before download 📥github.com/daedra000/ps3world-app/releases

I've integrated the Agents API into the AgentMod plugin. If the Agents API is available in WordPress and an agent has been registered through it, that agent will automatically appear in the Agent panel in AI Workspace. Automattic/agents-api

很有潜力的一个markdown软件，不用配置就很美观，舒适度也很高，就是还欠缺一些快捷键支持。 derrickwheals/downwrite

Want DeepSeek-class MoE on a gaming GPU — without renting a cluster? FreeToken: edge MoE engine + desktop console. Run frontier open weights locally with OpenAI-compatible APIs. 15.4k stars. FlashML-org/FreeToken #GitHub #OpenSource t.co

控米家还得掏手机？ MenuBarMijia 是 Mac 菜单栏、Win 托盘控米家，扫码直连不用搭 Home Assistant，拼音首字母搜设备、锁屏自动关灯。 适合家里米家多、常坐电脑前的人，没苹果公证，首次启动要手动点允许。 你先控哪个，灯还是空调？ #米家 #Mac @grok jryang1997/MenuBarMijia

@chanduuu_cs Yes, I vibecoded 3 servers that handle 1 Million concurrent users on 4 vCPU. million-users-challenge#43 million-users-challenge#42 million-users-challenge#41

模型比显存大？ InferSSD 把 MoE 专家放 SSD 流式读，763B DeepSeek 能跑，带聊天和兼容接口。 适合显存不够的人，Windows 在做，先看 Mac 或 Linux。 你先跑哪个，DeepSeek 还是 Muse？ #AI推理 #本地部署 @grok wici-ai/inferssd

@chaaai fuzzing as a service (on steriods). btw we do have awslabs/shuttle :D

refactoring.nvim: The Refactoring library based off the Refactoring book by Martin Fowler (3.7k stars) What it does All text below is quoted directly from the project README. >The Refactoring library based off the Refactoring book by Martin Fowler Tree-sitter and LSP powered refactoring: - Provides refactoring and print-debugging operators (see :h operator) powered by LSP and tree-sitter. - Supports dot-repeat and any textobject/motion. - Allows fine-grained customization while providing reasonable defaults. - Inline variable: Inline the definition of the variable under cursor into all its references. - Extract variable: Extract an expression, and all its usages in a buffer, into a variable. - Extract function: Extract text into a function and replace it with a call to that function. - Debug print cleanup: Cleanup the debug print statements in the selected range. >refactoring.nvim requires Neovim 0.12.5. Repository ThePrimeagen/refactoring.nvim Repository stats |Metric|Value| |:-|:-| |Stars|3,655| |Forks|106| |Last release|None| |Languages|Lua 70.7%, Tree-sitter Query 22.2%, Kotlin 1%| |Contributors|43| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|None| |AI co-authored commits|None| Main contributor |Field|Value| |:-|:-| |Name|Luis Calle| |GitHub|@TheLeoP| |Commits to this repo|553 (top contributor)| |Bio|I like Neovim and open source| |Company / Location|Cuenca, Ecuador| |Followers|30| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.

One domain, no mailbox seats: email for a one-person SaaS You shipped your app over a few weekends with Cursor or Claude Code. Receipts and password resets already go out through some email API. Then the boring part shows up: you want hello@, team@, sales@ and support@ on your own domain. The usual answer is a mailbox per person in Google Workspace or Microsoft 365, plus a shared inbox tool for support, plus a forwarding rule that breaks every few months. For a one-person (or three-person) product, most of those mailboxes only ever receive mail. You don't need a seat for that. This post shows a setup where one domain does four jobs: 1. Sends transactional email from your app (a Resend-compatible API, or SMTP). 2. Receives mail for the whole domain and hands it to your code as a webhook. 3. Forwards team@, sales@, billing@ to everyone's personal inbox with email groups. 4. Puts support@ straight into a support inbox, next to live chat, WhatsApp and Messenger, where replies go out from support@ itself. The examples use Ha Tang (I work on it). Every step comes with the prompt to give your coding agent, the code it should produce, and what to double-check. The setup in one picture ┌── POST /emails (API or SMTP) ── receipts, resets, invoices yourapp.com ────┤ └── MX → Ha Tang ─┬── support@ → Support inbox (chat, WhatsApp, Messenger, email in one place) ├── team@, sales@, billing@ → email groups → members' own Gmail/Outlook └── anything else → email.received webhook → your code Step 0: give your agent the real docs Agents get email integrations wrong mostly by guessing field names. Point them at the docs instead: # Claude Code: an MCP server that searches and reads the docs (no key needed for that) claude mcp add hatang -- npx -y @hatang/mcp # Any agent that reads AGENTS.md (Codex, Copilot, Cursor, Claude Code via CLAUDE.md) curl -s https://hatang.dev/docs/agents/AGENTS.md >> AGENTS.md In Cursor, add the same server to .cursor/mcp.json, or paste https://hatang.dev/docs/llms.txt into the prompt. Step 1: verify the domain Add the domain under Email → Domains (or hatang.domains.create({ name: "yourapp.com" })) and publish the records it lists: DKIM, SPF and the bounce MX on a send. subdomain, plus DMARC. Nothing here touches your existing mail. !The domain page listing the DKIM, SPF, return-path MX and DMARC records to publish, with their status Step 2: send transactional email > Prompt: "Send an order confirmation with @hatang/sdk when an order is paid. Read the Ha Tang sending guide first. Use the order id as the idempotency key. The key is in HATANG_API_KEY." // lib/email.ts (server only) import { Hatang } from "@hatang/sdk"; const hatang = new Hatang(); // reads HATANG_API_KEY export async function sendOrderConfirmation(order: { id: string; email: string; total: string }) { const { data, error } = await hatang.emails.send( { from: "Acme <orders@yourapp.com>", to: order.email, reply_to: "support@yourapp.com", // replies land in the support inbox (step 5) subject: `Order ${order.id} is confirmed`, html: `<p>Thanks! Your order <strong>${order.id}</strong> (${order.total}) is confirmed.</p>`, text: `Thanks! Your order ${order.id} (${order.total}) is confirmed.`, }, { idempotencyKey: `order-confirmation-${order.id}` }, // a retry never sends twice ); if (error) throw new Error(`${error.name}: ${error.message}`); return data.id; } The API follows Resend's shapes, so react: <OrderEmail /> works with React Email, and moving existing Resend code is mostly a new base URL and key (migration notes). Frameworks that only speak SMTP (Laravel, Django, WordPress, Nodemailer) can use smtp.hatang.dev:5870 with STARTTLS, user hatang, password = your API key. Double-check what the agent wrote: - The SDK is only imported in server code (route handlers, server actions, jobs), never in a client component. - Every send that can be retried has an idempotency key derived from your own ids. - The SDK returns { data, error } and does not throw for API errors: the agent must check error. Step 3: receive mail for the domain Turn Receiving on for the domain. This points the domain's MX at Ha Tang, so do it on a domain (or subdomain) that doesn't already receive mail at Google or Microsoft. If your root domain stays on Workspace for now, use a subdomain such as in.yourapp.com. Every message to any address on the domain is stored and announced with an email.received webhook. Your app can react to the ones it cares about, for example invoices sent to bills@, or "reply to this email" threads from your users: > Prompt: "Add app/api/hatang/webhooks/route.ts: verify the Ha Tang webhook signature on the raw body with constructWebhookEvent, and for email.received sent to bills@yourapp.com, fetch the message and its attachments and store them." // app/api/hatang/webhooks/route.ts import { Hatang, constructWebhookEvent, HatangSignatureError, type EmailReceivedEvent } from "@hatang/sdk"; const hatang = new Hatang(); export async function POST(req: Request) { const raw = await req.text(); // verify the raw body, before any JSON parsing let event; try { event = await constructWebhookEvent<EmailReceivedEvent>(raw, req.headers, process.env.HATANG_WEBHOOK_SECRET!); } catch (err) { if (err instanceof HatangSignatureError) return new Response(null, { status: 400 }); throw err; } if (event.type === "email.received" && event.data.to.includes("bills@yourapp.com")) { const { data: email } = await hatang.emails.receiving.get(event.data.email_id); const { data: files } = await hatang.emails.receiving.attachments.list(event.data.email_id); await saveBill({ subject: email?.subject, text: email?.text, files: files?.data ?? [] }); // your code } return new Response(null, { status: 200 }); } Double-check: agents love await req.json() before verifying. The signature is computed over the exact bytes, so parse after constructWebhookEvent, never before. Attachment download_urls expire after an hour: copy the file if you need it later. Step 4: team@ and sales@ without mailbox seats Most shared addresses of a small team only need to reach people. An email group is an address on your receiving domain whose mail is forwarded to a list of members, wherever their mailbox is: !The Email groups page with team@, sales@ and billing@ on one domain, and the Create a group form Create them in the dashboard (Email → Email groups), or let your agent script it: const { data: domains } = await hatang.domains.list(); const domain = domains!.data.find((d) => d.name === "yourapp.com")!; await hatang.emailGroups.create({ domain_id: domain.id, local_part: "sales", name: "Sales", members: ["you@gmail.com", "cofounder@gmail.com"], }); What members get: - Each member gets their own copy. The sender shows as "Alice via Sales" at sales@yourapp.com, and Reply goes straight to Alice. - Members don't see each other's addresses. The original stays under Email → Received and still fires email.received. - Loops, spam, auto-replies and bounces are not forwarded, and one sender can't flood a group (30 messages an hour). The honest trade-off: when a member replies, the reply comes from their own address, not from sales@. That's fine for vendors, partners, internal mail and most early sales conversations. When the conversation is with a customer and should come from your domain, that's what the support inbox in the next step is for. Also note that every forwarded copy is a send: a message to a group of 3 uses 3 emails of your daily quota. Step 5: support@ goes straight into the support inbox Connect support@yourapp.com as an email channel under Customer Support → Channels → Add channel → Email. Because the domain already receives mail at Ha Tang, there is nothing else to configure: no forwarding rule, no extra MX. !A support mailbox on a domain that already receives at Ha Tang: no forwarding needed, replies sent from the support address What you get compared to a shared Gmail label: - One inbox for every channel. Email threads sit next to website chat, the mobile SDKs, WhatsApp, Messenger, Instagram, Telegram, LINE, X, TikTok and Zalo, and the same customer is one profile across all of them. - Replies come from support@yourapp.com, in the same thread, with delivery status on each reply (sent, delivered, opened, bounced). - support+billing@ works too: the part after + becomes a tag you can route on. - The AI assistant answers email as well, from the knowledge you give it, and hands over to you when it can't help. - Acknowledgement emails, routing rules, tickets with SLA in business hours, and satisfaction ratings by email come with it. Only support@ itself goes to the inbox. team@, sales@ and every other address keep working as in steps 3 and 4. What changes on the bill I won't quote prices because plans change, but here is what this setup removes for a small team: | Before | After | |---|---| | A paid mailbox per person, mostly for shared addresses | Members keep their personal inbox; shared addresses are groups | | A shared-inbox or helpdesk tool for support@ | support@ is a channel of the support inbox you already use for chat | | Forwarding rules and a third-party parser for inbound mail | email.received webhook on the same domain | | Separate vendors for transactional email and inbound | One domain, one API key, one dashboard | You may still want a real mailbox for yourself (for signing up to services, calendars, etc.). The point is that the shared addresses stop costing a seat each. Watch it work Every API call your keys make is logged with status, client and timing, which helps a lot when an agent wrote the integration: !The API request log: endpoint, status, method, API key, SDK and time for each call Checklist before going live - [ ] DKIM, SPF and the bounce MX verified; DMARC published (start with p=none). - [ ] Receiving only on a domain or subdomain whose MX you control; not on a root domain still served by Workspace. - [ ] No API key or webhook secret in client code or in a variable with a public prefix (NEXT_PUBLIC_, VITE_). - [ ] Webhooks verified on the raw body; handlers return 200 quickly and are idempotent. - [ ] Group members double-checked: everyone listed really should get every message to that address. FAQ I'm on Resend / SendGrid / Postmark. Sending code moves with a new base URL and key; the migration guide maps the fields. Can my agent do this without me? With npx -y @hatang/mcp and an API key, an agent can send a test email, check whether your domain's DNS records are verified and read the docs as Markdown. Add --read-only if you only want it to look things up. Where does the mail go out from? Amazon SES, from your own verified domain, wherever your users are. Nothing in the setup above is tied to a country: any domain, any registrar, any DNS provider. Docs - Send email and SMTP relay - Receive email and Email groups - Connect a support email address - Use Ha Tang with AI coding agents - A runnable starter: hatang-nextjs-starter --- I work on Ha Tang.

CartOS - V0.1.25 Update guide and new features. Hi, so as some of you may have noticed i've been putting out a lot of updates for CartOS over the past few days, don't worry this will be slowing down now, V0.1.25 is going to be the last one for a while as i want future updates to be big changes that are worth updating for. This videos just a quick rundown on updating and the new features. V0.1.25 - New faster navigation options, RB and LB now jump through the alphabet - List order can be changed V0.1.24 - Per rom additional image support, add extra images that you can view when selecting a rom. - For the additonal images, keep in mind that the more images you have the longer it will take to load those images. When you expand a rom it loads that systems images, in my testing i have 610 GB roms with 2 images per rom, it took 5 seconds to load all 1220 images. They only need to load once and then they load instantly. V0.1.23 - New startup animation (You can disable it in the cartos settings if you like) - This update requires you to replace the CartOS.sh with the updated version from V0.1.23 upward. (i believe i put wrong version number in the video because im a fool but yeah) I have a general discussion on github for bug reports and feature requests and there’s a discussion specifically for V0.1.25. For those of you who have got this working on devices other than the Miyoo mini v4 please let me know in the comments, i would love to know! I really hope you guys and gals have been enjoying this and i look forward to seeing what gets made from this code, have fun with it! EntertainmentMuch144/CartOS

Boring Notch: The coolest way to make your MacBook's notch the star of the show (11k stars) What it does All text below is quoted directly from the project README. >Say hello to Boring Notch, the coolest way to make your MacBook’s notch the star of the show! Say goodbye to boring status bars: with Boring Notch, your notch transforms into a dynamic music control center, complete with a vibrant visualizer and all the essential music controls you need. Roadmap: - Playback live activity - Calendar integration - Reminders integration - Mirror - Charging indicator and current percentage - Customizable gesture control - Shelf functionality with AirDrop - System HUD replacements (volume, brightness, backlight) >brew install --cask TheBoredTeam/boring-notch/boring-notch Repository TheBoredTeam/boring.notch Repository stats |Metric|Value| |:-|:-| |Stars|11,202| |Forks|1.2k| |Last release|v2.7.3 (2025-11-24)| |Languages|Swift 98.2%, Perl 1.1%, Other 0.7%| |Contributors|51| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|@Copilot (4 commits), @claude (2 commits), @Copilot (1 commits)| |AI co-authored commits|None| Main contributor |Field|Value| |:-|:-| |Name|Alexander| |GitHub|@Alexander5015| |Commits to this repo|581 (top contributor)| |Followers|44| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.

@_nghiatran zhongerxin/iPhone-use ？

Seestar H-Alpha Script Hi Guys, i'm now a proud owner of a Seestar S30 Pro. After getting some first images i tried capturing NGC-7000 with LP-Filter and without an tried to combine thoose shots (LP-Filter should be only H-Alpha and SIII) After trying to split it with Siril to get the H-Alpha channel, i called my friend claude code and created a Siril Script to split and combine both stacks. its not finished yet but maybe it helps someone. After spliting things i combined them in a quick try in astrowizard. this is what it looks now with Hubble Pallette applied the shots are made with 640 x 30s IRCUT and 147 x 30s LP-Filter made in 2 nights. Script: darthm0e/Seestar_HaRGB-Combine preview.redd.it

Erdős problem database: A community database for the problems on the erdosproblems.com site (878 stars) What it does All text below is quoted directly from the project README. >A community database for the problems on the erdosproblems.com site. Erdős problem database: - Browse the interactive table - Sort, filter, and search all the problems in the database - We are particularly seeking community contributions regarding the integer sequences associated with these problems, and linking them to the OEIS. - The table below is auto-generated from the YAML file data/problems.yaml, which is the "ground truth" for this data as far as this repository is concerned. - To propose changes, open a PR editing data/problems.yaml. - See CONTRIBUTING.md for guidelines and field definitions. - Several of the problems have received assistance from various AI tools. >The underlying data stays active: data/statistics_history.csv continues to be updated as the database changes, so a current chart can be regenerated at any time with python scripts/plot_statistics_history.py --force. Repository teorth/erdosproblems Repository stats |Metric|Value| |:-|:-| |Stars|878| |Forks|129| |Last release|None| |Languages|Python 97.4%, JavaScript 2.6%| |Contributors|70| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|@Copilot (7 commits)| |AI co-authored commits|Claude: 24, Cursor: 2, Copilot: 3| Main contributor |Field|Value| |:-|:-| |GitHub|@teorth| |Commits to this repo|888 (top contributor)| |Followers|4.7k| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.

@jauneclaude There is far too much volatility in stocks and crypto but you can check out my nifty mm suit. Chromadera/Nenbot

@loktar00 AI DJ'ing. "Not a song generator - you still have to do the work. Stay human." - innermost47/ai-dj t.co

Permanently banned from WoW Classic for "hacks". Could Zapret be the reason? Hey everyone, A few days ago my WoW Classic account got permanently banned for "Unauthorized Cheat Programs (Hacks)". The thing is, I've never used cheats or bots in WoW. I know that's exactly what everyone says when they get banned, but I really haven't, and I'm honestly pretty confused about what happened. I live in Russia, and because of internet restrictions here I use a program called Zapret (from GitHub). It's basically a tool to get around ISP blocking, so I can use things like Discord and YouTube normally. I've had it running in the background while playing WoW for quite a long time without any issues. After the ban I started looking into it and realized that I had the "Game Filter" option enabled in Zapret. Apparently it can affect network traffic from games too. I have no idea if that's what triggered the ban, but it's the only thing I can think of. I sent Blizzard an appeal and explained everything, including Zapret. Unfortunately, the GM replied that the ban was correct, they couldn't give me any details, and the decision wouldn't be changed. That's it. What makes this especially frustrating is that I have no way to figure out what I supposedly did wrong. If Zapret caused some kind of detection, I wasn't even aware that it could be a problem for WoW. I've put a lot of time into my characters, and I was planning to keep playing Classic for a long time. Losing all that progress sucks, obviously. But being banned for cheating when I haven't cheated is what bothers me the most. I've seen a post from an Overwatch player who also used Zapret and eventually got unbanned after posting on Reddit. That's actually what made me decide to write here. Has anyone here had a similar experience with Zapret or other DPI bypass tools? Or managed to get a ban reviewed again after Blizzard said the decision was final? I'm not really sure what else I can do at this point. I just want someone to take another look at what happened. Sorry if my English is a bit awkward, it's not my first language.

YCS YS-4470 multifunction multimeter firmware reverse engineer project I started reverse engineering the firmware (with Ghidra&Rea) on the YS-4470 multifunction multimeter because its diode mode was so slow that I never used the whole device. So far, I’ve made diode measurements significantly faster and reduced the delay before the meter beeps. If you own a YS-4470, I think the modified firmware is worth trying. It makes the meter much easier to use. NandorHU/YS4470-Firmware-RE

抽空去试了试 @herdrdev 新的 App，然后发现只要给 CLI Agent 实现 OSC 7501 的规范，就可以和 Herdr 的 Agent 状态栏进行集成了。 给 AnkaLoop 顺便加上了这个支持，这样后续有其他工具也兼容这个规范的话，那就都统一集成了 ankaloop#106 t.co

I reverse-engineered Granola AI ( @meetgranola ) animations & workflows with Claude Opus. Live transcription, AI notes, searchable memory & real-time help. Mac + Windows. Free, BYO keys. Natively-AI-assistant/natively-cluely-ai-assistant t.co

been building a voice dictation tool for myself for a while. couldn't find what i wanted in the existing ones, so i made my own it's still super early and probably broken in places. but i use it every day and it's saving me a lot open sourced it here too altintasutku/hece

Everyone building desktop app should use mygo from @localhost_5173 herdrup desktop app is neat egoist/mygo

📈 GitHub Surge hold a key, talk, let go, and the text pastes into whatever app you're in. runs fully on your machine after the first model download. hex: 4,202 stars, +1,134 today. mac, windows and linux, MIT. #opensource anomalyco/hex

atalho que pouca gente conhece pra vibecodar: troca "hub" por "ingest" em qualquer link do github user/repo vira gitingest.com o repositório inteiro vira um texto pronto pra colar na IA qual atalho vc usa todo dia?

it fixes the toolchain along the way 🔧 "try to run this in sandbox tq tester-army/e2e" → cloned it, installed the pnpm + Node 24 it needed, built it and ran it (20 min) t.co

Dragon Age Origins (XB360) | Android Port | Odin 2 Portal Link: mabencs/Dragon-Age-Origins-Recomp-Android-Duo

@tobirastudio The kit uses One Euro filtering for landmark jitter, plus separate enter/exit thresholds and a 70ms default debounce so poses don't flicker: github.com/abouchedidxcode/open-source-hands/blob…

bir süredir kendim için bir sesli dikte aracı yapıyorum. piyasadakilerde aradığımı bulamamıştım, ben de yaptım hala aşırı erken, büyük ihtimalle bozuk yerleri de var. ama her gün kullanıyorum ve fena kurtarıyor beni açık kaynak olarak da koydum buraya altintasutku/hece

See your weekly Claude limit coming, before you hit it. My free Windows widget puts "51% until Thu" on the taskbar, with a mark for how much of the week is gone. Click it for your pace, today's budget and a daily chart. Open source (MIT). Unofficial. github.com/raisulsohan/ClaudeUsageWidget/releases… t.co

PortDragon Age Origins (XB360) | Android Port | Odin 2 Portal Link: mabencs/Dragon-Age-Origins-Recomp-Android-Duo

swear to god clanker agents are black magic. me-when-the-uh/vgm2151fur chuck your usual .vgm files through this and see if it works on Furnace 🤣 readme's a bit out of date, but RF5C68/164, y8950 and OPL4 are supported too.

Local Video Tools for AI Coding Assistants - FFmpeg Integration > TL;DR: This project provides an agent skill and MCP server that bridges coding assistants directly to local FFmpeg and Python. Instead of letting agents guess shell commands or raw filter graphs, it exposes 42 structured tools with typed arguments and self-verification checks. > Best for: Developers using AI coding assistants who need to programmatically process video locally. > Repository snapshot: ⭐ 4 424 stars · 🍴 349 forks · Python · MIT > Daily picks: Follow GitHub Open Source on Telegram --- What it is ffmpeg-skill is an open-source Python project that bridges AI coding assistants directly to local video processing tools. It provides an agent skill and server implementation that exposes 42 typed tools for editing media without cloud dependencies. How it works The project exposes local media utilities through a machine-readable contract. Instead of letting coding assistants guess command-line flags, it uses typed arguments and self-verification checks. Every editing job runs a mandatory probe phase to measure file properties before executing local operations. Key features - Forty-two local video tools covering cuts, silence removal, captions, and loudness normalisation - Model Context Protocol server integration for assistants like Claude Code and Cursor - Automated verification using built-in probing and contact sheets - Fully offline operation with no cloud dependencies or API keys - Runtime input schemas generated from command-line argument definitions Getting started Clone the repository from GitHub, ensure you have Python and FFmpeg installed locally, and configure the server inside your coding assistant environment. When not to use it Skip this project if you do not use AI coding assistants or if your environment lacks a local installation of Python and FFmpeg. --- Discuss Which video editing task do you find yourself scripting most often in your projects? - Discuss this pick on Telegram - GitHub repository - Full breakdown Curated from the repository README and metadata. No hands-on test is claimed; evaluate it in a sandbox before production use.

@fedesarquis You need to use a password manager to generate and securely store your passwords. But the real shield is a YubiKey for 2FA. You need phishing-resistant 2FA. Our guide on how to set them up: Opsek/Yubikeys-cheatsheet

github.com/JiaFeiMiao-K-Cat/DiscImageStudio/blob/… まてまて、すげー事やってんなぁ……

Monster Hunter 4 Ultimate (3DS) | Android Port | Odin 2 Portal Port Link: CompaLarios18/MH4UltimateDC Single Screen MOD: discord.gg

Decoder comparisons need identical samples. KetQat-benchmarks draws one Stim sample, SHA-256 hashes it, and requires each adapter to recompute the hash. Mismatch excludes it. Then paired McNemar, not marginal CI overlap. ketqat/ketqat-benchmarks

换手机最怕什么？聊天记录、APP数据全没了。 装个开源备份神器 DataBackup： ① 安卓 7.0+ 可用，应用数据一键打包 ② 换机 / 刷机前先备份，少踩坑 ③ 完全免费开源，不绑云盘账号 🔗 XayahSuSuSu/Android-DataBackup GitHub 总星 7,548 换机党保命软件，「建议收藏」 t.co

Monster Hunter 4 Ultimate (3DS) | Android Port | Odin 2 Portal Port Link: CompaLarios18/MH4UltimateDC Single Screen MOD: discord.gg

Erasure Requests: Model Provider Cleanup From Reservations When a product has to honor an erasure request, the cleanup obligation owed to a hosted model provider has to come from what was possibly sent, not from what we can prove was sent. We had it derived from the wrong signal, and the two directions of that failure were not equally bad: one asks a vendor for a cleanup of data it never received, the other can leave personal data sitting at a vendor outside our control. What follows is the rule that replaced it, the SQL condition that implements it, a reversible migration (a database change you can roll back) that installs it, and a regression module that reproduces both defects. The product here is an onboarding system. Its assessment path sends applicant data to a hosted model provider to score assessments, and its reply interpreter uses the same provider. When a person asks to be erased, the system computes a handoff list: the external parties that now owe a cleanup because they may hold that person's data. The model provider is one entry on that list, written as model_provider. Our own database holds narrower evidence about a provider call than it does about a row. We record that we reserved a request before sending it, and we record that a provider call consumed requests. Between those two records sits the part we cannot resolve: whether a reserved request that never completed actually crossed to the vendor. Any obligation we owe that vendor has to be derived from the wider of the two records, the reservation rather than the consumption count, because the two ways of getting it wrong cost very different amounts. The old rule asked only whether a run row existed The old rule lived in a catalog module (the Python file that generates the erasure function's SQL), inside the SQL body of the function that builds the handoff list. It looked like this: IF EXISTS (SELECT 1 FROM public.assessments_assessmentrun r WHERE r.application_id = ANY(v_apps)) THEN v_handoffs := v_handoffs || 'model_provider'::text; -- what the model provider kept of a request, if anything END IF; Any assessment run row at all for the erased person's applications was enough. No column was compared. The query could not tell a run that consumed a provider call from a run that was created and then refused before a call was ever made. Both defects came out of that one line, and they point in opposite directions. False positive. An assessment refused on suspension produced a run row and no provider call. The old rule still reported model_provider. The vendor owed nothing, and it would have been asked to clean up data it never received. False negative. A person's inbound reply can be reserved for interpretation by the provider while no assessment run exists for them. The legacy predicate found no run row, so the entry was omitted. The provider might have received the reply, and nobody would have asked it to drop anything. Neither defect is something you find by reading the SQL twice. The condition looks conservative, and conservative is the right instinct here. It is just conservative in the wrong place: careful about the row's existence, careless about the request's fate. How do I derive a model provider cleanup obligation? We derive it from what was possibly sent, not from what we can prove was sent. A reserved provider call counts as evidence of disclosure even when the call never completed, because an unfinished run is not evidence of absence. An abandoned call is the harder case, because there the run exists and did not finish, and the reason is that the provider's side of the call is not something our database can resolve. When a run is refused before anything is reserved, no handoff is owed. The new predicate lives in erasure/catalog.py as MODEL_PROVIDER_HANDOFF: MODEL_PROVIDER_HANDOFF = """EXISTS (SELECT 1 FROM public.assessments_assessmentinvocation i WHERE i.application_id = ANY(v_apps) AND i.reserved_requests > 0) OR EXISTS (SELECT 1 FROM public.assessments_assessmentrun r WHERE r.application_id = ANY(v_apps) AND r.requests_used > 0) OR EXISTS (SELECT 1 FROM public.correspondence_replyinterpretation i WHERE i.application_id = ANY(v_apps) AND i.reserved_requests > 0)""" Three signal sources and two different columns: | Signal | Column | What it establishes | |---|---|---| | Assessment invocation (assessment and clarification rounds) | reserved_requests > 0 | A provider call was reserved. A possible disclosure, even if the call never completed. | | Assessment run | requests_used > 0 | A provider call consumed requests. A confirmed disclosure. | | Reply interpretation | reserved_requests > 0 | Reply-interpretation provider work was reserved. A possible disclosure. | The rule now reads, as recorded in the internal launch plan: a queued or suspension-refused run that reserved nothing and recorded nothing owes no model provider handoff. Positive assessment and clarification reservations, recorded assessment requests and reply interpretation reservations keep the handoff, including abandoned calls whose provider outcome is uncertain. Reply-only calls count even without an assessment run. The inversion that matters is that a reservation became a first-class signal instead of an implementation detail. Previously a provider call surfaced only as an assessment run row. The reservation was always recorded and the old rule never looked at it. Now the rule reads that column, so the ambiguous middle (reserved, then interrupted, then abandoned) is answered from a recorded number instead of inferred from the mere existence of a run row. Why not count only confirmed calls, or ask the provider? The obvious fix is to count only confirmed calls: drop the reservation checks, keep requests_used > 0, and let the ambiguous cases fall on the floor. It removes the false positive entirely and the query gets shorter. It also creates a silent false negative, and that is the bad trade. A call that was reserved and then interrupted leaves no confirmed record, but the provider may have received it. The absence of a finished run is not evidence of absence of disclosure. When the evidence is missing rather than negative, the only safe reading is that a disclosure is possible, and a possible disclosure still creates a cleanup obligation. The other obvious approach is to ask the provider. Read the vendor's logs for the person's identifiers and use the answer. That makes the vendor a runtime dependency of an erasure request, it assumes the vendor can match our identifiers to what it received, and it assumes the vendor keeps logs long enough to answer. None of those hold in general, and the cost when they do not hold is the person's data still sitting there. So the obligation is deliberately a superset of confirmed disclosures, and we accept the false positive the new rule keeps. That false positive costs a message to a vendor and some noise in our own logs. The false negative can cost a person their right to be forgotten. One more reason the set has to lean wide: we do not get to know what the provider does with a request after we send it. Retention, training and logging on their side, if they happen at all, happen outside our database. Our own records tell us a request was reserved for sending, and a confirmed call (requests_used > 0) tells us the provider consumed it. Neither tells us it kept anything. The reservation is our evidence that it might have gone out. Installing it without rewriting history The change ships as a reversible migration, erasure/migrations/0008_model_handoff_evidence.py: """9kg.73: queued or refused model work alone creates no provider cleanup obligation. Reservations remain conservative evidence of possible disclosure, including abandoned calls and reply interpretation without an assessment run. Reinstall both erasure functions without rewriting rows, signed records, function ownership or grants. """ # imports elided LEGACY = "EXISTS (SELECT 1 FROM public.assessments_assessmentrun r WHERE r.application_id = ANY(v_apps))" def install(schema_editor, *, reverse): ... # retention and existing lookups elided for replay in (False, True): statement = catalog.erase_sql(retention, existing, replay=replay) if statement.count(catalog.MODEL_PROVIDER_HANDOFF) != 1: raise RuntimeError("unexpected model handoff definition") if reverse: statement = statement.replace(catalog.MODEL_PROVIDER_HANDOFF, LEGACY, 1) schema_editor.execute(statement, params=None) # forwards, backwards and the Migration class elided Three things are worth pulling out of that file. The loop runs over both function variants, the normal erasure and the restore replay. The two have to carry the same rule, because a restored database can bring back rows for a person erased after the backup, and the replay re-runs the erasure against those rows. What a restore leaves behind is covered in A Database Restore Does Not Undo Sent Email or Envelopes. If replay derived the entry differently, the replay would answer a different question than the erasure it replays. The count check keeps the installed SQL and the catalog in agreement. The function body is generated from the catalog, so the migration asserts that the new predicate appears exactly once in the generated statement. A later edit that drops the clause or duplicates it fails the migration instead of shipping a function that quietly disagrees with the source it came from. The reverse path swaps the new predicate back to the legacy one, which is what makes the migration reversible. The old rule is carried in the file as a constant, so reversing is a substitution instead of a guess. Ownership, grants, historical rows and signed erasure records survive the reinstall, so no signed record is rewritten. Nothing else moved. Provider activation, rate limits and token policy are untouched. The regression that reproduces both defects tests/test_erasure_model_handoffs.py landed at 150 lines with four test functions in it. The first of them covers the asymmetry in a single body: @pytest.mark.parametrize("replay", [False, True], ids=["erase", "replay"]) @pytest.mark.parametrize("called", [False, True], ids=["refused", "provider-called"]) def test_9kg_73_a_suspended_assessment_owes_no_provider_handoff_but_a_real_call_does( a, monkeypatch, settings, decided, replay, called ): if called: app, run, seen = assessed(a, monkeypatch, valid()) assert run.status == "succeeded" and seen["calls"] == 1 assert AssessmentInvocation.objects.filter(run=run).exists() else: app, run, seen = queued(a, monkeypatch, settings, valid()) settings.CATALYST_ASSESSMENT_MODEL = "none" run_worker() run.refresh_from_db() assert run.status == "refused" and seen["calls"] == 0 assert not AssessmentInvocation.objects.filter(run=run).exists() closer = grant(a, staff(a, "model-erasure-closer"), "close_application") closure.close_application(app.pk, closer, "closed", "Synthetic erasure regression") assert ("model_provider" in handoffs(a.committed, app, replay)) is called The called parameter doubles as the expected answer, which is why the last line can assert is called instead of branching on it. The refused branch builds the case that used to produce the false positive. Setting the model to none is the suspension condition, so the worker runs, the run is refused and the fake provider records zero calls. The provider-called branch is the control, where a real call happened and the handoff is owed. The closure.close_application call closes the application through the staff closure helper before the erasure runs. The second function, test_9kg_73_reply_only_model_reservations_keep_the_provider_handoff, covers the false negative. It builds a reply interpretation that reserved provider work, in an application with no assessment run, and asserts across both erasure paths that the handoff appears when something was reserved and stays absent when the reservation count is zero. The third test covers the ambiguous middle, the case the old predicate could not tell apart from a run that reserved nothing: @pytest.mark.parametrize("status", ["started", "abandoned"]) def test_9kg_73_an_uncertain_reserved_call_still_owes_provider_cleanup( privileged_reset, decided, status ): app = subject() reserved_run(app, status) assert "model_provider" in handoffs(privileged_reset, app, False) A call that was reserved and then started or abandoned still owes a model provider cleanup, because the provider's side of that call is not something our database can resolve. The fourth function, test_9kg_73_both_functions_reverse_and_reapply_without_changing_rows_or_grants, reverses the migration and reapplies it, then checks that the rows, the function ownership and the grants survive the reinstall. The helper three of the four tests call is what ties the two paths together. It runs the installed catalyst_erase function for the normal path and the installed catalyst_erase_replay function for the restore path, so whichever path is under test is held to the same rule. Result The eight-case regression, the module's first eight cases, four from the suspended-assessment matrix and four from the reply-only matrix, reproduced both defects before the change: 4 expected failures and 4 passing controls, in 30.32 seconds. Making the guard prove it can fail before trusting that it passed is the same rule as in Make the Guard Prove It Can Fail. After the fix, all 15 focused checks passed in 102.60 seconds. The coverage included actual worker and fake-provider cases, both erasure paths, uncertain calls, reversal and reapplication with exact row, function and grant preservation, the installed SQL checked against the catalog, schema inventory and model synchronization, and the existing complete erasure-reversal check. Ruff, formatting, Markdown, document index and diff checks pass. Neither a live provider nor a production database took part in this change or in its tests, and nothing is deployed yet, so no vendor ever received one of these cleanup requests. Full CI was the merge gate, and the change is merged. Deployment and the live handover to the new version remain separate open work. The internal launch plan and the approved migration set in tests/test_database.py were updated with the change, so the next person reads the rule instead of rediscovering which signal was wrong. Also shipped - A sibling fix from the same day (PR #178) requires restore-recovery evidence to be timestamped at or after the current transaction's start, not just to carry a matching transaction ID, so a rebuilt cluster cannot reuse an old transaction ID as fresh authorization. - Restore replay now matches normalized inbound senders against the signed erasure record (PR #177), so restoring a backup cannot resurrect inbound mail and intake counters for a person erased after that backup was taken. Use this - Derive any obligation to ask an external party to delete data from what was possibly sent, not from the existence of a row. A reservation you wrote before the call is the evidence that a request might have reached the vendor, and a refusal that reserved nothing is evidence that nothing did. - Give the delete path and the restore path the same predicate, then test both against the installed functions. A restore that replays an erasure with a different rule answers a different question than the erasure it replays. - Carry the old predicate in the migration as a constant, assert the new one appears exactly once in the generated SQL, and reverse by substitution. A signed erasure record is never rewritten, and a catalog edit cannot ship a function that disagrees with its own source. The change is in catalyst-onboarding-v2 PR #179. Frequently asked questions What is the difference between a reserved provider call and a confirmed one? A reservation is the record your system writes before it sends the request, so the request may have reached the provider. A confirmed disclosure is the record that requests were consumed. A call that was reserved and then started or abandoned still owes a cleanup, because the provider's side of that call is not something your database can resolve. Why not count only confirmed provider calls? Counting only confirmed calls removes the false positive and shortens the query, but it creates a silent false negative: an interrupted call leaves no confirmed record while the provider may have received it. Asking the provider instead makes the vendor a runtime dependency of an erasure request, and none of those assumptions hold in general. So the obligation is deliberately a superset of confirmed disclosures. How do I test that an erasure derives the right cleanup set? Parametrize the case over both erasure paths and over whether the provider was actually called, so the parameter doubles as the expected answer. Cover the false negative with a reply interpretation that reserved provider work, and the ambiguous middle with a call reserved and then started or abandoned. Assert against the installed functions, so the path under test and the restore path are held to the same rule. <script type="application/ld+json"> { "@context": "schema.org", "@type": "FAQPage", "mainEntity": [ { "@type": "Question", "name": "What is the difference between a reserved provider call and a confirmed one?", "acceptedAnswer": { "@type": "Answer", "text": "A reservation is the record your system writes before it sends the request, so the request may have reached the provider. A confirmed disclosure is the record that requests were consumed. A call that was reserved and then started or abandoned still owes a cleanup, because the provider's side of that call is not something your database can resolve." } }, { "@type": "Question", "name": "Why not count only confirmed provider calls?", "acceptedAnswer": { "@type": "Answer", "text": "Counting only confirmed calls removes the false positive and shortens the query, but it creates a silent false negative: an interrupted call leaves no confirmed record while the provider may have received it. Asking the provider instead makes the vendor a runtime dependency of an erasure request, and none of those assumptions hold in general. So the obligation is deliberately a superset of confirmed disclosures." } }, { "@type": "Question", "name": "How do I test that an erasure derives the right cleanup set?", "acceptedAnswer": { "@type": "Answer", "text": "Parametrize the case over both erasure paths and over whether the provider was actually called, so the parameter doubles as the expected answer. Cover the false negative with a reply interpretation that reserved provider work, and the ambiguous middle with a call reserved and then started or abandoned. Assert against the installed functions, so the path under test and the restore path are held to the same rule." } } ] } </script> Related Posts - A Database Restore Does Not Undo Sent Email or Envelopes - A Green Recovery Drill Can Still Be Lying - Every Claim Needs a Shipped Source and an Executable Proof

AirsupHQ/youbuild Free browser extension. 217 builder channels, a topic check that runs in your browser, and a chip on every video that says why it is there. Chrome, Edge, Brave, Arc and Firefox.

Puck turns your React components into a visual page editor. I like this division of labor: developers own the components, editors arrange the page. Moving a heading shouldn't require summoning the person who understands the build pipeline. puckeditor/puck

Msfvenom Cheatsheet نكمل الادوات الي تحتاجها لل OSCP او اي شهادة اختبار اختراق. Msfvenom راح تكون صديقك لما تحتاج تكوّن reverse shells والمصدر هذا يعطيك ال commands الي تحتاجها لمختلف انظمة التشغيل وتقنيات ال web frizb/MSF-Venom-Cheatsheet

Free browser tool for teaching cache misses (compulsory / capacity / conflict) If you teach architecture or systems, this may be useful. Cache Miss Theater (cache-miss-theater.pisan.me) takes a C loop nest, generates its exact address trace and runs it through a cache you configure: size, line size, associativity, LRU/FIFO/random, write-allocate and write-back or not. Every miss is labelled compulsory, capacity or conflict. Play or step through the trace and watch lines arrive in their sets and get evicted, while a memory map shows which array elements are cached. Things that might help in class: - Two kernels side by side (row vs column order, ijk vs ikj, naive vs blocked transpose), or a sweep over block size or a cache parameter with the miss rate plotted. - Exam questions from six templates, with every answer computed by simulating the exact code shown. Export as Markdown with an answer key, or as QTI 1.2 for Canvas. I have not yet imported the QTI file into a live Canvas course, so treat that part as beta. - Kernels and cache settings live in the URL, so a slide can link straight to an example. Limits: one cache level, data accesses only, and array contents are not modelled, so A[B[i]] is out. No sign-up, everything runs in the browser, nothing is uploaded. Source (MIT): pisan-labs/cache-miss-theater Full disclosure: Claude Code wrote the code; I set the requirements and reviewed it. The tests check the simulator against a naive reference on 60 random traces and pin the textbook results (row order 25% misses, column order 100%). If you try it with students, I would like to hear what breaks or what is missing.