标签：#RAM

I used to spend hours rewriting AI-drafted video scripts that sounded nothing like me. At best, I might finish one or two that were just okay, but most of the work was still on my shoulders. Now, with my new system, I can get 15 scripts done in one session. They match my writing style, my voice, and my company's knowledge. Instead of full rewrites, each script just needs a quick review. I built the system in about a week, and the difference showed up before the week was out. The first project was an internal video series to teach people about the software factory and LaunchDarkly, and I barely had to edit those scripts. For the first time, the AI handles most of the work. My recent projects have mostly involved agentic software delivery. The software factory is where all of it was heading, and my company spent months preparing to help customers build their own. We had internal material, public documentation, and ongoing conversations I wanted to add clarity to. So my challenge wasn't just learning, it was learning while producing content at the same time. Essentially, devrel. By the end, I had built what I like to call my own personal content factory. At first, it was separate from the software factory it describes, but over time, the line between them blurred. My approach is to let AI handle the bulk of the work, while I step in for the important decisions. This is the only way I've found to make AI content sound like me. The AI creates the drafts, and I step in at three key points: checking the voice, the facts, and the overall feel. The quality ceiling is set before the first draft. I didn't just ask for a video script about a topic. Instead, I gave Claude access to every source I had—public docs, internal notes, and product requirements. It used research agents to read everything at once and came back with clear, organized notes I could use. I set two important rules for this step. First, every part of the research was labeled as either public-safe or internal-o

I asked Linux for one 4 KiB page from the start of a cold file. Four pages came back. I moved the same read one page further in, ran it again, and got one. Same file, same syscall, same kernel. The only thing that changed was where I started reading, and I spent twenty minutes assuming the tool I'd just written was miscounting. It wasn't. A read that starts at byte zero is treated as a promise. There's a branch in mm/readahead.c that reads, in full, if (!index) goto initial_readahead; . Offset zero means the kernel takes you for a program that's about to stream the whole file, and it fetches ahead immediately. Start anywhere else and you're assumed to be seeking randomly until a pattern proves otherwise. Nothing in my call said a word about my intentions. It inferred them from an offset. I spent two weeks on this sort of thing recently. Not for work, and not toward anything shippable. The short version of what I found is that a surprising amount of the machinery under a running program isn't carrying out instructions at all. It's guessing. The bench , because it changes how you should read every number here: an ext4 filesystem on a loop device, inside an OrbStack Linux VM on an Apple Silicon Mac, kernel 7.0.14, 4 KiB pages, read_ahead_kb at 128. That's a container sharing the host's kernel, not bare metal, and the host reclaims memory aggressively enough that a fully cached file can go cold in fifteen seconds. Reads came from dd ; the page-by-page counting came from a small C tool I wrote that mmap s a file and asks mincore() which of its pages are resident. You're not addressing the disk, you're addressing the page cache The model most of us carry is that read() goes and gets bytes off a device. It doesn't. It copies bytes out of the page cache into your buffer, and the page cache is just RAM the kernel uses to remember parts of files. If what you want is already there, no device is involved. If it isn't, the kernel fills the cache first and then copies. Either way

Framework told "all" of its customers that hackers accessed their names, email addresses, phone numbers, and physical addresses in a data breach.

The Quest Begins (The "Why") Honestly, I still remember the first time I tried to build an autocomplete widget for a side‑project. I had a list of 200 k product names, a simple filter that ran on every keystroke, and the UI felt like wading through molasses. Each keypress triggered a full scan of the list, and with a few users typing at once the browser would start to lag. I was stuck in a loop that felt like the infamous “boss fight” where you keep hitting the same pattern over and over, hoping for a different outcome. I kept asking myself: There has to be a smarter way. Why am I re‑checking the same prefixes again and again? If ten users type “tea”, why do I walk through the whole dictionary ten separate times? That question turned into a mini‑quest, and the treasure at the end was the trie data structure. The Revelation (The Insight) Look, the magic of a trie isn’t that it’s some exotic tree; it’s that it stores words by their shared prefixes . Imagine you have the words “cat”, “car”, “cart”, and “dog”. In a trie you’d have a root node, then a c branch that splits into a → t (for “cat”) and a → r → t (for “cart”), while “dog” lives on its own d → o → g path. Every common prefix is stored once , and you can walk down the tree following the characters of a query to land exactly at the node that represents all words with that prefix. Why does this give us O(L + K) time for autocomplete, where L is the length of the prefix and K is the number of results? Walking the trie follows the prefix character‑by‑character → O(L). From that node we just need to collect all words in its subtree. If we keep a list of words at each node (or run a DFS), we touch each result once → O(K). No extra work for words that don’t share the prefix. Contrast that with the naive filter approach: O(N × L) where N is the total dictionary size. For a large N, the trie is a game‑changer—it’s like switching from swinging a blunt sword to wielding a lightsaber that cuts through the prefix forest in

Nota: en Lumora construimos libros infantiles personalizados con IA, y escribimos en diez idiomas. Este artículo cuenta un problema de i18n con el que chocamos de frente y cómo lo resolvimos. Lo contamos desde dentro, con nuestro nombre, porque el error nos costó reescribir una campaña entera. Casi todos los equipos tratamos el idioma como si fuera el país. Ponemos es en el selector, sacamos las cadenas a un JSON y damos el problema por cerrado. Funciona hasta el día en que tu producto tiene algo que ver con una fecha. Y entonces descubres que es no es un mercado, son varios calendarios distintos que comparten vocabulario. El día en que el regalo no llega el 25 Teníamos una campaña de regalos escrita en español. Correcta gramaticalmente, revisada, sin errores de traducción. Y aun así estaba mal para una parte grande de quien la leía: En España , el gran momento de regalo infantil no es el 25 de diciembre: son los Reyes Magos, el 6 de enero . Un mensaje que dice "pídelo antes del 24" le está dando a una familia española una fecha límite equivocada por casi dos semanas. En México conviven las dos cosas: Navidad y Reyes, con la rosca del 6 de enero. En Argentina, Chile o Uruguay , la Navidad es el 25 de diciembre… en pleno verano . A 30 grados. Con las vacaciones escolares largas empezando, no terminando. Fíjate en lo incómodo del asunto: los tres casos hablan español. Los tres pasan el mismo test de traducción. Y los tres necesitan un mensaje distinto, una imagen distinta y una fecha límite distinta. El mismo golpe existe en portugués. En Brasil la Navidad también cae en pleno verano, enero es mes de vacaciones, y el día en que de verdad se reinicia la rutina familiar no es el 1 de enero: es la volta às aulas , en febrero. Si tu calendario de contenidos asume "año nuevo, hábitos nuevos" en enero, en Brasil llegas un mes antes de que a nadie le importe. Por qué el código de locale no te salva La respuesta obvia es "usa es-ES y es-AR ". Es correcta y casi nunca es sufic

The best software engineers in the world are general masters of either one of Emacs or VIM. The author of this article has chosen Emacs (blue lightsaber) over VIM (red lightsaber). Both can be quite formidable. However, in all of his journeys far and wide, the author has only encountered once a VIM practitioner who rivaled his power of the force, none other than the villainous Sith Lord Johnathan Ritzi (red lightsaber). In their duel, they were head-to-head, neck-to-neck, and trading blows back-and-forth, variously saber-locking at times. The two masters of the force eventually declared the duel a draw, and have withdrawn back to their caves to hone their skill and craft in their respective lightsabers. How much do you agree with this "guru's" opinion submitted by /u/sidneysweeneysrack [link] [留言]

Table of Contents Overview AI Didn't Remove the Skill, It Relocated the Skill Vibe Coding...

TL;DR: pnpm create vite / pnpm run dev has been crashing with a bare Illegal instruction on Android (Termux) for about 10 months. Traced it through a logcat tombstone to Rolldown's native binary, found a closed-as-not-planned upstream issue from last September, got it reopened with hard evidence, and the actual root cause turned out to be one missing target_os check in a mimalloc build flag. Fix is verified on the exact crashing hardware, PR is open, not merged yet. A few days ago I tried to spin up a fresh Vite + React project on my Android tablet, in Termux. Nothing fancy: $ pnpm create vite test-react-app --template react-compiler-ts $ cd test-react-app && pnpm run dev Illegal instruction No stack trace, no error message, just dead on arrival. Tried create-vue — same crash. Tried a bare vite dev — same crash. Three different starters, one identical death. Termux-on-Android matters more than it sounds like it should, because for a lot of people it's the only dev environment they've got — no laptop, just an old Android phone. When the standard create vite path just dies with zero explanation, that's not a minor bug, it's a wall. Chasing it down Assumed it was a Termux packaging problem first and filed a report with logs for Next.js, Vite+React, and Vue all crashing or silently falling back to a slower path. A maintainer pointed out pkg install turbopack fixes the Next.js case — but Vite and Vue don't touch Turbopack at all, so that didn't explain the rest. Turns out Vite 6+ ships Rolldown as its default bundler: a Rust/N-API bundler that loads a native binary ( @rolldown/binding-android-arm64 here). Something in that binary was blowing up on load. A maintainer asked for a logcat tombstone instead of terminal output, and that's where it got interesting: ``` signal 4 (SIGILL), code 1 (ILL_ILLOPC) backtrace: #00 pc ... rolldown-binding.android-arm64.node #01 pc ... rolldown-binding.android-arm64.node #02 pc ... linker64 (call_array+288) #03 pc ... linker64 (soinfo::ca

Architectural Simplification of the Event Bus To maintain a strict separation of concerns, the event bus has been simplified by removing the system signature and device-level routing logic. Its sole responsibilities are now restricted to ingesting events from database webhooks and external sources, buffering them in Redis, handling event migration, and piping event streams to clients for state reconciliation. Routing events to specific devices is no longer handled within the bus; instead, the system operates at the user level, delegating transport and device-specific routing to a separate layer. This architectural boundary keeps the event bus lightweight, focused purely on durability and event streaming. Upgraded Event Migration and Classification The event migration process has been upgraded to support precise, source-aware state synchronization. Previously, the migration job only recorded basic metrics like user IDs and event counts, forcing clients to execute generic, full-sync operations regardless of what actually changed. Under the updated design, the migration job performs a targeted fetch of full event payloads from Redis to extract structural metadata, including event types (such as bookmark updates or shared links) and external event sources. This richer metadata is then persisted during migration, enabling connected clients to perform granular, targeted updates rather than costly full re-synchronizations. While fetching full event values introduces a minor additional Redis call during the expiration check, this trade-off deliberate: prioritizing architectural clarity and targeted sync capabilities over premature performance optimizations. Overall, these adjustments keep the system scalable, easy to reason about, and flexible enough to accommodate future event sources.

Building the layout orchestrator for Linkscribe wasn't a simple case of slapping a pre-made library onto a list. It was an ambitious attempt to construct a hybrid rendering stack—wrapping React Virtualized, delegating observer callbacks, and orchestrating DOM updates across dynamic multi-column folders. Having built virtualization engines completely from scratch before—ranging from off-thread Web Worker layout calculators to adaptive sync engines using relative spatial rendering—I approached this with a specific theoretical model in mind. Calling this an orchestrator or a custom engine fits what it was designed to do. However, my initial mental model fell apart when real-world DOM mutations, multi-column sections, and rapid reload cycles collapsed the execution pipeline. Testing 200 items in nested folders dropped the frame rate to ~20 FPS during fast reloads and rapid scrolling. The orchestration overhead simply choked the main thread. Problem 1: DOM Event Saturation and Thread Blocking The core bottleneck came down to how the delegation layer managed element state changes. Connecting MutationObservers and IntersectionObservers directly to global store triggers filled the browser event queue with continuous updates. The Old Approach The delegation manager listened for node insertions across the DOM tree and triggered immediate state changes on every single intersection callback. observerRef . current = new IntersectionObserver (( entries ) => { entries . forEach ( entry => { // Continuous individual state calls during rapid layout shifts hydrateActiveMonoLink ( id ); }); }); Why this broke down During rapid scrolling or fast view reloads, dozens of elements entered and left the viewport simultaneously. Processing these events individually saturated the main thread, forcing constant DOM querying and component re-evaluations while the browser was trying to handle paint cycles. The Refactored Direction Consolidating intersection calculations into unified updates preve

Let me be upfront about something: this tutorial will age badly. Not the concepts — those hold. But the specific names, the price points, the rankings — the AI model landscape moves fast enough that any comparison table has an expiration date. What's the best model for code today might be second place next quarter. The one that seems expensive now might be the obvious choice by the time you're reading this. That said: the mental model for navigating this landscape doesn't expire. What questions to ask when choosing a model, how API access differs from a subscription, what "context window" actually means on a regular Tuesday — that's stable. With the right map, you can update yourself when things change. And they will. The frontier models: the big three Frontier models are the most capable models at any given moment. In 2026, the competition comes down to three: Claude Sonnet 4.6 (Anthropic) is the model you'll be using throughout this course, and the current benchmark for coding tasks. Together with Opus 4.7, it ships with a 1M token context window at standard pricing — no special headers, no premium plan required. It stands out for sustained reasoning, precise technical writing, and following complex multi-step instructions. Sonnet 4.6 is the speed-quality balance; Opus 4.7 is more powerful but slower and more expensive. GPT-5.4 (OpenAI) — released March 2026 — is the first general-purpose model with native computer use : it can operate desktop interfaces and execute complex workflows across applications. It reaches 1M tokens of context, incorporates the coding capabilities of GPT-5.3-Codex, and comes in multiple variants — Thinking, Pro, mini (free tier), and nano (API-only) — making it the most accessible of the three. Recently, GPT-5.5 has been released, with improvements in speed and reasoning. OpenAI also maintains the Codex family as a separate line: GPT-5.3-Codex is optimized for complex agentic software engineering and leads benchmarks like SWE-Bench Pro; G

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

Keep your allies close. Keep your enemies closer. But before you strike, count how many hands they have: the ones you can see, and the one reaching out from somewhere you don't know. — The 36 Stratagems, Befriend a distant state and strike a neighbouring one Previously on this series: #19: Mark Found His AI Audit Method in a Training Manual. He Left a Trap in His Report. — P's entry was swept. P left a note: two weeks. #20: Alex Felt the AI Collector Slow Down. He Knew Someone Else Had Made a Move. — A gateway with TTL 247 was caught by Alex's probe. #21: The AI Thought P Was Still Alive. P Was Already Gone. — The response layer still answered. The person behind it was gone. #22: The AI Chose Its Door. Lena Closed It. — Pulse AI was exposed inside the audit sandbox. Lead investor Apex Capital had tens of millions tied up. Torres left one line: Apex. Singapore. Run. The Scan 2 AM. Alex flipped through probe data out of habit. No lights on; the screen lit his face. The coffee cup sat on his right, first sip already cold. He didn't notice. The TTL 247 gateway had been silent for nearly two weeks. He hadn't shut the probe off. It barely used any resources, sitting there in the middle of the night like a lamp nobody watched. He checked it half out of habit, half out of something he couldn't name. Today there was a record that shouldn't exist. Not that gateway. Another path: ACL's asset scanner was sweeping an address range. He sat up a little straighter, his hand paused over the keyboard for half a second, then pulled the timestamps again. The frequency was wrong: high-density targeted scanning, almost plowing through segment by segment. In the target range, one block he recognized: the MedTech test environment. He aligned the timestamps. Scan source egress: Singapore. [probe] 02:14:33 — unexpected flow on mirror src : 103.196.12.0/24 (SG egress) dst : 10.42.0.0/22 (MedTech-test) pattern : sequential, full-depth exclusions : 10.42.3.1, 10.42.3.200-254 rate : 47 hosts/min

Understanding the Prototype Design Pattern in Java Introduction When developing software, there are situations where creating a new object from scratch is expensive or time-consuming. For example, an object may require complex initialization, database access, or extensive configuration. In such cases, instead of creating a new object every time, we can duplicate an existing object. This is where the Prototype Design Pattern becomes useful. The Prototype Design Pattern is one of the Creational Design Patterns in Java. It allows developers to create new objects by cloning existing ones rather than instantiating them using constructors. What is the Prototype Design Pattern? The Prototype Design Pattern creates new objects by copying an existing object, known as the prototype. This approach improves performance by avoiding repeated initialization and allows developers to create multiple similar objects efficiently. In Java, cloning is commonly implemented using the Cloneable interface and overriding the clone() method. Why Use the Prototype Pattern? The Prototype Pattern offers several benefits: Reduces the cost of object creation. Improves application performance. Simplifies the creation of complex objects. Avoids repeated initialization code. Makes object creation more flexible. Real-World Example Imagine an online shopping application where thousands of product objects share similar properties. Instead of creating every product from scratch, the application can clone a prototype product and modify only the required attributes such as name or price. Other real-world examples include: Document templates Game characters Employee records Vehicle configurations Graphic design objects UML Structure The Prototype Design Pattern generally includes: Prototype Interface – Declares the clone operation. Concrete Prototype – Implements the cloning functionality. Client – Creates new objects by cloning existing prototypes. Java Implementation Step 1: Create the Prototype Class cla

Hi everyone, I recently put together a guide on modernizing legacy WCF applications, and I'd appreciate some feedback from developers who have been through this transition. The article covers: Best practices for testing existing WCF services before migration Common challenges when maintaining legacy WCF applications When CoreWCF is a good fit When it makes more sense to adopt gRPC Factors to consider before starting a migration project My goal wasn't to suggest that every WCF application should be migrated immediately. Instead, I wanted to provide a practical framework for evaluating the available options based on business and technical requirements. I'd love to hear from the community: Are you still maintaining WCF services? If you've migrated, did you choose CoreWCF, gRPC, or another approach? What was the biggest challenge during your migration? Here's the article: https://geeksarray.com/blog/wcf-testing-legacy-services-and-migrating-to-corewcf-or-grpc Looking forward to hearing your experiences and learning from the community. submitted by /u/geeksarray [link] [留言]

This is Part 3 of a 3-part series. Part 1: Your Brain Is a Rendering Engine. So Is Every LLM. explored why LLMs and human brains invite the same rendering analogy. Part 2: More Compute Won't Wake It Up argued that scaling compute doesn't cross the consciousness boundary. This final part asks: what happens when you bring a render layer into a domain that punishes distortion? I have a friend who trades. Not professionally. He has a day job, a brokerage account, and strong opinions about charts. One evening he pulled up a stock chart and pointed at a formation near the top. "Head and shoulders," he said. "Classic reversal pattern. I'm getting out." I looked at the same chart. I saw price going up and then going down. I didn't see a head. I didn't see shoulders. I saw a line. He wasn't wrong, exactly. Head-and-shoulders is a real pattern that real traders have used for decades. But he looked at a time series of prices and his brain rendered it into a human body part. And then he made a financial decision based on the body part, not the numbers. Somewhere between the data and the decision, anatomy got involved. That is the render layer at work. And markets are the worst possible place to let it run unchecked. What a trader actually sees When a discretionary trader looks at a chart, their brain is doing what Part 1 described: taking raw input (price as a function of time) and collapsing it into a rendered scene. The scene comes pre-loaded with pattern names, emotional associations, and memories of the last time something "looked like this." The chart didn't change. The candles are the candles. What changed is how that particular brain rendered it. A trader who got burned on the last head-and-shoulders sees danger. A trader who made money on one sees opportunity. Same vibration, different render. Same sunset from Part 1, different feeling. This is not a minor problem. This is the entire problem. Human trading is emotional trading. Not because traders are undisciplined. Bec

Recently, I’ve been spending more time building small projects on my own. One thing I’ve learned is that it’s usually better to keep things simple and ship early instead of trying to make everything perfect. A small project can still teach you a lot about coding, deployment, design, and how people actually use what you build. I’m planning to share some of my development notes and experiments here from time to time. Looking forward to learning from everyone on DEV.

Hi everyone! I'm a Computer Science student at a Brazilian Federal Institute, and I previously completed two semesters of Computer Science at a federal university in Brazil. Right now I'm studying C and Python at university while working on personal projects to improve my skills as a developer. I'm looking for a mid-level or senior developer who has a project, a company, or any real-world work where I could help, even if it's with simple tasks at first. I'd also love the opportunity to learn other programming languages and technologies through hands-on experience. I'm not looking for payment at the moment. My goal is to learn how real projects are built, gain practical experience, and contribute as much as I can. If you think I could help or have an opportunity for me, feel free to send me a private message. If you'd like to see my résumé, just send me a message. Thanks! Or send me a messenger on LinkedIn https://www.linkedin.com/in/danillo-souza-gomes-undefined-9084293b0 submitted by /u/SuccotashOwn1550 [link] [留言]

Java is still worth it in 2026 Are you wondering if Java is still worth learning in 2026? Check out this video and see why it's been dominating for 30 years submitted by /u/OSBY_Glabay [link] [留言]

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