标签：#RAM

The Problem I was staring at my terminal during a deploy, waiting for the build to finish, when I realized something: I'd been typing figlet "Hello World" into my terminal for years to generate ASCII art for commit messages and README files. But every time I wanted to share that art with someone who wasn't a developer, I hit a wall. "Just install figlet," I'd say. "Install what now?" they'd reply. The problem wasn't that ASCII art tools don't exist online. The problem was that the ones I found were either bloated with ads, required JavaScript frameworks that made the page take forever to load, or couldn't handle non-Latin characters gracefully. I wanted something that just worked in a browser tab, no installation, no server, no fuss. So I decided to build my own. Because apparently I enjoy reinventing wheels. The AI-Assisted Development Journey Here's where things get interesting. I've been using AI pair programming for a while now, and this project felt like the perfect test case: it's well-defined, has clear requirements, and involves a lot of repetitive font data that would be tedious to type manually. The Initial Prompt I started by describing the requirements to an AI assistant in pretty specific terms: Build a single-file HTML tool that converts text to ASCII art. Must have multiple fonts (Block, Slant, Small, Standard, Mini). Real-time preview. Copy to clipboard. Download as .txt. Support dark mode. Chinese/English i18n. Vanilla JS only. The AI came back with something surprisingly decent. It had the basic structure right, the font data was embedded, and the rendering logic was clean. But there were issues. Where AI Got It Wrong The first problem was character handling . The AI assumed that all input would be uppercase English letters. When I tested with lowercase, numbers, and special characters, it just... broke. Not crashed, but silently dropped characters. // What the AI initially wrote (simplified) function getChar ( char , font ) { return font [ char .

Every card in RealFeedApp has a cover image. They aren't fetched from the articles — publishers' images come with rights I don't have — so the app uses its own bank, generated ahead of time, one pool per topic. I generated that bank once, shipped it, and this month threw all of it away and started over. Twice over, actually, because there were two separate failures and only the first one was my fault in the obvious way. Failure one: I got exactly what I asked for The original prompt asked for a dark, moody look — very dark near-black background , generous negative space . In a preview grid at full size, the results were genuinely nice. Restrained, editorial, not the usual glowing-blue-circuit-board thing. Then I looked at the actual feed. Cards render as tiles a bit under 400 pixels wide. A small object floating in a large field of black, scaled down to a tile, is a black rectangle. Not a bad image — no image at all. The model had done precisely what I asked: it put a modest subject in a lot of empty darkness. Negative space is a compositional virtue at poster size and a bug at thumbnail size. The lesson is dull and I'll probably need it again: prompt for the size the image will be seen at, not the size you review it at. I was approving art in a grid of large previews and shipping it into small tiles, and never once compared the two. The rule that replaced the old one is three words long — brighter, higher contrast, subject filling the frame edge to edge. Failure two: the model started writing the news The rewrite asked for documentary photography. The first batch came back with something I didn't expect: several images contained a coloured band along the bottom of the frame with a headline in it. Invented words, mangled letterforms, confident typography. One read TROOLDOGS NEWS . Three images out of fifteen. Not a fluke, a pattern. The cause was in the prompt, and it was three words working together. I had asked for an editorial look, described the images as news f

Most modern auth systems eventually hit the same two failure modes. Problem 1 – JWT-based auth systems JWT looks perfect on paper: stateless, self-contained, fast verification. In real production auth systems, the moment you need instant revocation, logout, permission changes, or response to token theft, the model breaks. You are forced to introduce a denylist (Redis or database). That destroys the original “stateless” benefit and adds a lookup on every request. Signature malleability and JWKS cache-miss flooding create additional operational and security risks. This is one of the most common pain points in high-scale authentication systems today. Problem 2 – OAuth 2.0 opaque-token auth systems OAuth 2.0 gives real-time revocation through token introspection. The cost is severe: every protected API request now pays an extra network round-trip to the authorization server. At low traffic this is invisible. At high throughput the introspection endpoint becomes a shared bottleneck, connection pools saturate, and the p99 latency of the entire auth system tracks the auth server’s latency. The classic front-channel redirect flow also creates friction for native apps, CLIs, desktop tools, and autonomous agents. These two patterns cover the majority of production auth systems currently in use — and both break under different kinds of load. Solution – GNAP (Grant Negotiation and Authorization Protocol, RFC 9635) GNAP redesigns the authorization model around asymmetric key-bound tokens. The client proves possession of a private key (typically Ed25519) on every request using HTTP Message Signatures. Resource servers verify the signature locally in tens of microseconds with zero database queries and zero network calls for the token itself. Tokens remain manageable and revocable when needed, but the common path stays extremely cheap and truly local. Interaction can happen entirely on the back channel, removing the browser-redirect requirement for many non-web clients. I recorded

submitted by /u/fagnerbrack [link] [留言]

*Part 2 of "Multi-Agent Systems in Production: What They Don't Tell You", a four-part series...

Question : Implement next permutation, which rearranges numbers into the lexicographically next greater permutation of numbers. If such arrangement is not possible, it must rearrange it as the lowest possible order (ie, sorted in ascending order). The replacement must be in-place and use only constant extra memory. Here are some examples. Inputs are in the left-hand column and its corresponding outputs are in the right-hand column. Example : 1,2,3 → 1,3,2 3,2,1 → 1,2,3 1,1,5 → 1,5,1 Idea : Scan from right to left and find the first element that is less that its previous. eg: 1 6 3 5 -> here it is 3. Let's name it as index. Again scan from right to left and find the first element that is greater than 3 and that's 5. Let's mark it as idx. 3.In this step we swap 3 and 5. Reverse elements from index+1 till the array length. Code: public void nextPermutation(int[] nums) { int index = -1; for(int i=nums.length-1;i>0;i--){ if(nums[i]>nums[i-1]){ index = i-1; break; } } if(index==-1){ reverse(nums,0,nums.length-1); return; } int idx=0; for(int i=nums.length-1;i>=index+1;i--){ if(nums[i]>nums[index]){ idx=i; break; } } swap(nums,index,idx); reverse(nums,index+1,nums.length-1); } void swap(int[] nums,int i,int j){ int temp =nums[i]; nums[i] = nums[j]; nums[j] = temp; } void reverse(int[] nums,int i ,int j){ while(i<j){ swap(nums,i,j); i++; j--; } } Code Explanation : We first initialize index=-1 and traverse backward to find the first one with i that satisfy the condition nums[i]>nums[i-1] . We assign this to index and break out of the loop. for(int i=nums.length-1;i>0;i--){ if(nums[i]>nums[i-1]){ index = i-1; break; } } Next step we are discussing a corner case. For example if the given array is 3,2,1 then we cannot find the element that satisfies the previous condition. So when the array is given in decreasing order we just reverse it and return. if(index==-1){ reverse(nums,0,nums.length-1); return; } Next iteration we are considering another variable idx and traverse backw

There's a very specific kind of AI project that looks incredibly impressive in the architecture diagram and does almost nothing a simple version couldn't do better. It has a vector database. It has a multi-agent orchestration graph. It has a fine-tuned model, a memory layer, custom tool wrappers, three retries with exponential backoff, and a couple of "future-proof" abstractions nobody's actually using yet. The agent at the center is simple. The scaffolding around it is a cathedral. Here's the uncomfortable truth most teams learn the hard way: AI apps rarely fail because someone picked the wrong model or framework. They fail because layers got added before anyone could name the problem each layer was supposed to solve. The biggest mistake in building AI apps isn't starting too small — it's starting too big. So here are 7 signs you've crossed into over-engineering, the simpler thing to do instead, and — at the end — a practical playbook for not falling into the trap in the first place. See how many feel a little too familiar. 1. You reached for a vector database before you needed one "First, set up your vector database" became the default opening line of every AI tutorial — so teams spin up Pinecone or Chroma reflexively, before they've confirmed they even have a retrieval problem that requires embeddings. The plot twist of the last year is how often that's overkill. Some of the most capable coding agents around quietly dropped vector search in favor of plain tool-driven search — grep, reading the file tree, asking for files by name. In one widely-cited case, ripping out the embedding pipeline and replacing it with grep reportedly outperformed the vector setup, by a lot. That doesn't mean vector DBs are dead — they're still a strong fit for large, stable knowledge bases (product docs, FAQs, glossaries) with a good reranker. But if your data is small enough to fit in context, or searchable with keywords and filters, you may be maintaining an entire embedding-and-migra

This is a simplified guide to an AI model called Beat_this maintained by Xavriley . If you like these kinds of analysis, you should join AImodels.fyi or follow us on Twitter . Overview beat_this is a beat and downbeat tracking model from the ISMIR 2024 paper "Beat This! Accurate Beat Tracking Without DBN Postprocessing" by xavriley and collaborators at CPJKU. The model detects precise beat positions and downbeat boundaries in audio files without relying on Dynamic Bayesian Network postprocessing, achieving state-of-the-art F1 scores while maintaining generality across diverse music genres. The architecture alternates convolutions with transformers operating either over frequency or time dimensions, and is trained on multiple datasets including solo instruments, pieces with time signature changes, and classical music with high tempo variations. The main model ( final0 , final1 , final2 ) weighs approximately 78 MB each, with a smaller variant available at 8.1 MB. The most critical detail before using it: the model achieves good results specifically because it avoids meter and tempo constraints that traditional systems impose, but this means it can still fail on difficult and underrepresented genres and performs worse on continuity metrics compared to methods using postprocessing. Best use cases Music information retrieval and analysis workflows. If you build music analysis software that needs to segment tracks into beat-aligned sections for tempo detection, structural analysis, or synchronization with other modalities, beat_this provides clean beat and downbeat annotations without requiring external postprocessing pipelines. The model outputs precise timestamps suitable for downstream music information retrieval tasks like onset detection or harmonic analysis. Rhythm-aware music production tools. For digital audio workstations, beat detection plugins, or metronome applications, this model provides frame-level accuracy suitable for real-time audio alignment and grid s

I went through the documentation and feature list of React DataGrid, and I wrote React DataGrid: A...

Originally published on hexisteme notes . A user complaint sent me into a caption pipeline: "the subtitles cut to two words in places where the sentence doesn't make sense." The fix I shipped for that complaint introduced a second bug, one word narrower and easy to miss, because the code that measured whether a line of text would fit reproduced an assumption about the text that the code drawing the line didn't share. Every test passed the whole time. I only found it by watching the rendered video. The bug the complaint pointed at The captioning system splits a transcript into short chunks that pop onto screen a few words at a time. The chunking function was doing fixed-size slicing — take the next N words, regardless of what came before or after. That's blind to sentence boundaries, so two unrelated sentences could land in the same chunk: loss. Today reads as one visual unit even though it's the tail of one sentence and the head of the next. The fix was a rule set, not a single tweak: hard break after terminal punctuation ( . ! ? … ) soft break at commas, semicolons, and em-dashes extend or push a chunk rather than let it end on a function word ( of , the , than , is , and about thirty others) target three words per chunk, four as a ceiling a pixel-width cap on the rendered chunk, measured against the actual caption font (Montserrat ExtraBold), with a budget of 1080 × 0.92 = 993.6px The first four rules are about where a line is allowed to break. The fifth is a physical constraint: however good the break points are, a chunk still has to fit on screen at the font size actually in use. That's the one that went wrong. What the width guard actually measured To get the pixel width of a candidate chunk, the guard rendered the chunk's text through the font and measured the result — which is the correct approach in principle, not a shortcut. Text width isn't a fixed number of pixels per character; it depends on the specific glyphs, so measuring the real string through the r

ESP32 + Python: From Microcontroller to IoT Artcal 0: Introduction When it comes to transferring data from one place to another, things can sometimes become tricky, especially when communication happens between the hardware and software levels. In this article series, I would love to share the experience and knowledge I’ve gathered while working with ESP32 and Python. We’ll explore how these two technologies can work together, starting from the basics and gradually moving towards more interesting and practical projects. If you have any questions, suggestions, or ideas along the way, feel free to share them in the comments section below. I’d love to hear from you and discuss them with the community. So, without further ado, let’s begin! 🚀 What is ESP32? Think about Esp32 as a microcontroller with Internet facilities, consisting WiFi, Bluetooth and a own wireless data transfer protocol called ESP-NOW between ESP32 chips. Nowdays, the developers have made development boards integrading these chips for the easy use. ESP32 is a family of microcontrollers developed by Espresiff. This can read sensor inputs, process data, contol devices and specially connect to the internet. This is like Arduino but better, faster and smaller. With these information that we have, we can speak about this board as, "A powerful microcontroller that can interact with electronic components and communicate with other devices through Wi-Fi, Bluetooth, and other communication methods." Python??? We use different languages to tell the same thing but in different ways. We use programming languages to tell the computer the same thing but in different approches. Some languages can be hard to learn and some are easy. Some are well developed and some are not. Python programming language was created back in 1980s by Guido Van Rossum, with the development begining around 1989. It was publicly released in Feb, 1991. 🐍 1989 — Guido van Rossum developing Python. 🐍 1991 — The first public release. 🐍 2000 — Py

Introduction I run a site that collects overseas viewer comments about individual anime episodes, translates them, and publishes them. It updates automatically every day. There is one failure mode that matters more than all the others: creating a page for an episode that has not aired yet. If the page exists before the broadcast, there are no comments to put on it. But the heading "Episode 8 — overseas reactions" is already live. An empty page is recoverable. What is not recoverable is a pipeline that decides an empty page looks bad and fills it with something plausible. At that point invented sentences are wearing the face of real people. This post is about the check that prevents that, and about the day it actually fired. The overall shape The obvious implementation is arithmetic on dates: Take the air date of episode 1 Assume weekly broadcast Count the weeks elapsed until today Treat every episode up to that number as aired That works for producing candidates, but it is not evidence that anything aired . A skipped week makes the real count lower. So does a recap episode. Calendar arithmetic never observes the broadcast; it only restates an assumption. So I split the pipeline in two: Candidate generation — weekly arithmetic, guessing which episodes are missing. Guessing is fine here. Existence check — does an observation from outside my system exist for this episode? No guessing allowed here. For the existence check I use the per-episode discussion threads on MyAnimeList (a large anime database; MAL from here on). One thread is created per episode after it airs, and the timestamp of the first post in that thread is readable. Viewers post after watching. So that timestamp is external evidence that the broadcast happened. Better still, it lives in exactly the same place I fetch the comments from, so verification costs no additional data source. The core of the implementation The check is a subtraction between what I claim and what the outside world recorded. /** * @

I Built AgentCheck Because “The Coding Agent Said Done” Wasn’t Enough AI coding agents are getting surprisingly good at writing code. I use them regularly, and they can handle increasingly large tasks: refactoring code, adding features, updating dependencies, modifying configuration, creating migrations, and touching files across an entire repository. But I kept running into the same problem after the agent finished: How do I independently verify what it actually changed? The agent usually gives me a perfectly reasonable summary. Something like: Done. Implemented the requested changes, updated the tests, and cleaned up the affected code. Useful? Absolutely. Enough for me to commit without checking? Not really. So I built AgentCheck . The Problem Happens After “Done” After a coding agent finishes a task, I still find myself manually checking things like: Which files actually changed? Were any files deleted? Did configuration change? Were dependencies added or updated? Was a database migration introduced? Did anything that looks like a secret appear? Were related tests changed? Is the overall change set larger or riskier than expected? Of course, Git already gives us the raw information. I can run: git status git diff git diff --stat Then inspect individual files. And I still do that. But once coding agents become part of your normal workflow, repeating the same verification process after every task starts to feel like something that should be structured. That was the idea behind AgentCheck. What AgentCheck Does AgentCheck creates a trusted checkpoint before your coding agent starts working. Then, after the agent finishes, it compares the current Git-visible repository state with that checkpoint. The basic workflow is deliberately small: agentcheck start Then let your coding agent work. That can be: Codex Claude Code Cursor another AI-assisted coding tool or technically even a human When the work is finished: agentcheck AgentCheck then produces four sections: Changes

There are two kinds of articles about coding with AI. The ones that generate a sorting function and...

submitted by /u/fagnerbrack [link] [留言]

A developer usually meets Mac power management through a simple need. A build, local server, download, or agent is still running, and idle sleep would interrupt it. The caffeinate command can be enough for that open lid case. Lid close is a different boundary. An idle sleep assertion does not mean the same thing as a closed display session, and a product should not blur the distinction. I built Afterlid around three explicit states. Sleepy follows normal sleep. Awake prevents idle system and display sleep while the lid is open. Always On is the lid closed mode, with the display off. The important engineering work begins after activation. What happens if the app crashes? What happens when the battery is falling or the machine is under thermal pressure? What state is restored after a helper failure? For Afterlid, Always On ends at 30 percent battery while unplugged, under serious or critical thermal pressure, when the app heartbeat disappears, or after eight hours. When a limit fires, the app drops its wake assertion and returns the Mac to normal sleep behaviour. The current implementation uses a small privileged helper and an undocumented macOS sleep setting for the lid closed path. That makes broad hardware testing and honest release notes essential. It is not something I want to hide behind a friendly menu bar character. A useful principle emerged from the work: activation is a feature, but recovery is the product. If you are building a system utility, test the path back to the operating system defaults with the same seriousness as the path into your special mode. Founder disclosure: I built Afterlid. The full product and current boundaries are here: AfterLid

submitted by /u/tymscar [link] [留言]

I Built a Python Bot That Plays Blackjack on Discord's OwO Bot 🃏 An automation experiment in game logic, human-like timing, and why the house still wins. ⚠️ Disclaimer first: This project is for educational purposes only . It's a coding experiment about automation, pacing, and basic blackjack strategy. I'm not promoting gambling, I'm not responsible for any losses, and self-bots can violate Discord's Terms of Service — know the rules before running anything like this. What is this thing? If you've spent time in Discord economy servers, you've probably met OwO Bot — one of the most popular Discord bots out there, with its own cash economy and gambling minigames, including Blackjack . I asked myself a fun engineering question: Can I write a Python client that plays full Blackjack sessions on its own — with human-like pacing, break cycles, and a sensible betting strategy? That experiment became GhoSty OwO BlackJack Farm — a Python-based Discord self-bot focused on OwO Bot's Blackjack, now at V2.1 . What it does 🔄 Full Blackjack automation — handles the game loop end-to-end. 💡 Smart betting — strategy-based decisions instead of random yolo bets. 😴 Smart Sleep — lifetime work/break cycles instead of 24/7 spamming. ⏱️ Dynamic gaps — randomized delays between every action. 🚨 Zero win guarantees — on purpose. More on that below. The stack (and why an old discord.py) Python 3.10+ discord.py==1.7.3 colorama Yes, 1.7.3 is ancient — deliberately. The self_bot=True pattern that this kind of client relies on was removed in newer discord.py versions, so legacy 1.7.3 is the line that still supports it. If you've never touched pre-2.0 discord.py, this project is a small time capsule of that API. The whole project is intentionally tiny: OwO-Blackjack-Farm/ ├── main.py # bot + game logic ├── config.json # your token & settings ├── requirements.txt └── README.md Setup is two steps: drop your token into config.json , then: pip install discord.py == 1.7.3 colorama python main.py Start it

submitted by /u/kciter [link] [留言]

submitted by /u/Ok_Marionberry8922 [link] [留言]