标签：#AR

Your storage hardware narrows the choice first: raw NAND requires UBIFS on UBI; ext4 and f2fs are not candidates there. On managed flash such as eMMC, our default is a read-only squashfs root plus a writable data partition, which pairs cleanly with A/B updates and integrity verification. Choose a plain ext4 root instead when your product needs a writable root and your team values familiar recovery tooling over immutability. Every embedded Linux product ships a root filesystem, and its format is often chosen by default — the vendor BSP generated ext4, so the product ships ext4. It is a real decision with long-term consequences for updates, power-cut behaviour and flash wear. This article works through the root filesystem format decision for the four realistic candidates: ext4, f2fs, squashfs with overlayfs, and UBIFS. The context The root filesystem format decision arises early, usually when the build system asks for it — Yocto through IMAGE_FSTYPES , Buildroot through its Filesystem images menu. Both can generate all four formats, so the build system does not constrain you. Five forces do. Storage technology. Raw NAND attached through the kernel's MTD layer exposes eraseblocks that wear out and can go bad; the filesystem stack must manage wear levelling and bad blocks itself. Managed flash — eMMC, SD, UFS — hides all of that behind an internal controller (an FTL) and presents an ordinary block device. Block filesystems such as ext4, f2fs and squashfs require a block device; UBIFS requires UBI on MTD. The hardware choice between raw NAND and managed flash removes half the candidates before any software argument starts. Update strategy. With image-based A/B updates — the model we recommended in Choosing an A/B Update Layout for Your Product — the root filesystem is replaced as one complete image, so a read-only format fits naturally. Package-based updates on the device require a writable root. Power-cut behaviour. Embedded devices lose power without warning. A never-w

Short answer: for an ask-your-docs feature in a multi-tenant SaaS help center, start with embeddings over document chunks, retain keyword search for exact identifiers, and add reranking only when retrieval evaluation shows that the first-stage ordering is weak. The architecture is simple: ingest tenant-scoped chunks, embed them, store the vectors in a managed index, retrieve a small candidate set, and give only those matches to the answer model. The important marketplace constraint is less glamorous: every retrieval and model call must carry a tenant identifier into metering, or the team will know the total bill while remaining unable to explain which storefront created it. Don't begin with a vendor. Begin with the miss you can tolerate. How should a SaaS help center combine semantic search, embeddings, and keyword search? Semantic retrieval handles the normal language mismatch between a customer's question and the documentation. A user may ask how to “change the shop owner,” while the source chunk says “transfer account administration.” Keyword matching sees different tokens; embeddings map both query and chunks into vectors and can retrieve text with related meaning. That is the decisive reason to use embeddings for support questions, not fashion and not an assumption that vectors make every search problem better. Keyword search still earns a narrow, valuable lane. Error codes, plan names, API fields, invoice identifiers, and product-specific phrases often need literal matching. PAYMENT_1042 is not a semantic concept that should be softened into something approximately related. For a beginner implementation, run vector retrieval as the default and merge an exact-match result when the query contains one of those identifiers; don't build a many-stage ranking system before the corpus supplies evidence that you need one. Chunk boundaries matter because retrieval returns chunks, not abstract documents. Split by meaningful document structure, retain the page title and s

The problem AI agents like Claude Code and Codex write code fast. You run it, it works, you merge. A week later, there's a bug — and you realize you never actually understood the code you shipped. You just transcribed it. This is "vibe coding," and it's becoming the default way a lot of us write software now. What I built BuildIt is a set of hands-on courses where an AI agent proposes code changes like a normal diff — but you can't move to the next step until you explain, in an actual conversation with an AI tutor, why the change was made and what could go wrong. You also write the prompt yourself before the AI generates anything. No skipping. No checkbox you can fake. Real, compilable code from lesson one — not toy examples. 9 courses, 45 real shipped projects: Arduino STM32 (HAL) STM32 (LL) ESP32 Next.js Python React React Native Flutter How it works An AI agent proposes code (same diff screen you already know from Claude Code, Codex, Antigravity) BuildIt demands a line-by-line explanation before you can approve it An AI tutor verifies your understanding through real conversation Only then do you move to the next step Technical details The tutor AI runs entirely locally in your browser — your code never leaves your machine Credits-based pricing — unlock a course, it's yours even if you cancel later Built for teams too — share credits across an org, instill review habits from day one Why this matters AI will write more of our code over time, not less. That makes the ability to actually read and verify it more valuable, not less. BuildIt isn't trying to teach you to write code from scratch — it's trying to make sure you don't lose control of the code an AI writes for you. Would love feedback from anyone who's felt that "I merged this AI diff and don't actually understand it" moment. Try it here

used to have a habit of thinking in code. it'd be like walking down the street and immediately seeing...

Phia, the shopping startup co-founded by Phoebe Gates and Sophia Kianni, is once again under fire for its alleged business practices.

The framing that causes the most damage is treating this as a financing decision. It is not. Taking venture money is choosing a category of business: one that must attempt to become very large very quickly, and produce an exit that returns a fund. Everything else follows from that. What venture capital actually requires A venture fund needs a small number of investments to return the entire fund. That structure means a company growing steadily and profitably at twenty percent a year is a failure in a venture portfolio, even though it is an excellent business by any other measure. Once you take the money, that expectation becomes your operating constraint. Decisions that would be obviously correct for a durable business, such as slowing hiring to protect margin, become hard to defend. Questions that actually decide it Can this business plausibly become very large? Not "could it grow", but could it realistically reach a scale where a meaningful ownership stake is worth a large multiple of the money invested. Most good businesses cannot, and that is not a criticism of them. Does speed determine who wins here? In some markets the first company to reach scale takes most of the value, usually where network effects or heavy switching costs exist. In those markets, refusing capital while a competitor takes it is a decision to lose. In most markets this dynamic does not apply, and speed bought with dilution buys nothing durable. Do you want to run this for a decade and then sell it? Venture capital has an implicit ending. The fund needs liquidity. If you want to own a profitable business indefinitely, you want a fundamentally different structure and should say so before, not after. Is capital genuinely your constraint? Founders often raise to solve problems money does not solve. If you have not found product market fit, capital lets you be wrong more expensively and for longer. If distribution is unproven, funding scales an unproven motion. The honest tradeoff Venture backed

If you have ever needed to send an email, process a payment, or generate a report without making your user wait, you have probably run into Celery. Celery is a tool that lets you run jobs in the background, away from your main app. This article breaks down how it works, step by step, in plain language. What Is Celery, In Simple Terms Think of Celery like a restaurant kitchen. Your app (the waiter) takes an order from a customer. Instead of cooking the food itself, the waiter drops the order into a queue (the kitchen order rail). A cook (the worker) picks up the order from the rail and prepares it. When the food is ready, it goes to a pickup counter (the result backend) where anyone can come check if it's done. Celery has four main players: The Producer - your app, the one that creates tasks. The Broker - the message queue that holds tasks until a worker is free. The Worker - the process that picks up and runs the tasks. The Result Backend - where results are stored, if you need them later. In short: your app sends a task message to the broker. The broker holds it until a worker is free. The worker picks it up, runs the actual function, and (if you set one up) writes the result to the result backend. Your app can then go back and check that result backend to see what happened. Now let's go through each part. 1. How Tasks Get Registered Before Celery can run a task, it needs to know the task exists. This is called registration , and it happens the moment your Python code is imported - not when the task runs. The @app.task decorator You create a Celery app instance, then decorate any function with @app.task . That decorator does not run the function immediately. Instead, it wraps the function and adds it to a task registry - basically a dictionary that Celery keeps internally, mapping a task name to the actual function. from celery import Celery app = Celery ( " myproject " ) @app.task def send_welcome_email ( user_id ): # logic to send an email print ( f " Sending wel

Microsoft today released updates to remedy at least 398 security vulnerabilities in its Windows operating systems and supported software, including one weakness that is already being actively exploited and two others that were publicly detailed prior to today.

This follows many drone incursions into Romania and a failed attack in Germany.

Most agent frameworks give each agent its own context window and call it memory. That works right up until you run more than one agent, and then it quietly becomes the most expensive design decision in the system. We run a fleet where different agents are deliberately backed by different models — one family handles long-form drafting, another handles structured extraction, a couple run on a local path with no external inference at all. Routing by capability is the easy part. The hard part is that an agent which learns something has learned it alone . This is a writeup of what broke, and the design we ended up with. The failure mode The symptom shows up as repeated work. An extraction agent determines that a particular vendor's invoices put the tax line above the subtotal. Useful. Two days later a different agent — different model, different prompt, same pipeline — hits the same vendor and re-derives it from scratch. Then a third does it again. Nothing is wrong . Every agent behaves correctly. The system as a whole just has no way to accumulate anything, because knowledge lives inside whichever context window happened to be open at the time. You are paying inference costs to rediscover facts you already own. The naive fix is to pass more history. That fails for a specific reason worth naming: context windows are per-invocation and per-model. A 200k window on one model does not help an agent running a different model with a 32k window, and neither survives the session ending. You cannot solve a persistence problem with a bigger buffer. What "unified memory" has to mean Once you accept that memory has to live outside the agents, the requirements get concrete: Model-agnostic storage. If memory is stored as one model's embeddings, you have coupled your memory layer to a vendor. Swapping models later means reindexing everything. Written by one agent, readable by all. Otherwise you have per-agent memory again, with extra steps. Attributable. When memory is wrong — and it w

Certification prep often stops at notes and multiple-choice questions. Copilot Studio makes more sense once you actually build something. So I added a free AB-620 hands-on lab to Examplar. It covers creating an agent, writing clear instructions, testing in-scope and out-of-scope prompts, publishing it, and cleaning up afterwards. Each step includes something learners can check before moving on. The public Preview also has 25 original practice questions. No exam dumps. Examplar is my independent, open-source side project. The Preview and lab are free, and the page also links to optional paid packs. Try the free lab: https://examplar.app/exams/ab620/#labs-h Blunt feedback is welcome. Which hands-on scenario should I add next?

But will Gemini's surge survive slowing model releases?

Developers are owning more of the delivery system around code, not just code itself. Join us during GitHub Universe to meet other devs, learn something new, and explore what's next. The post From coder to orchestrator: How agents shift the role of a developer appeared first on The GitHub Blog .

Most people use AI for startup research like this: “Give me 10 promising AI startup ideas.” A few seconds later, you get a polished list. The problem? You have almost no idea which conclusions are backed by evidence, which are assumptions, and which are simply the model confidently connecting dots. So I tried something different. Instead of asking one AI agent to find startup ideas, I built a small Startup Intelligence team using Hermes Agent. The system uses four specialized AI agents that research markets, investigate competitors, audit evidence, challenge each other’s conclusions, and ultimately rank promising B2B AI SaaS opportunities. And rather than producing another Markdown document full of ideas, the workflow produces structured research containing: Market opportunity scores Companies and competitors Customer pain and unmet needs Evidence-backed claims Source URLs and supporting passages AI advantages and workflows Low-cost validation experiments Here’s how the system works. 🎥 Full video walkthrough The Problem With Asking One AI Agent to Find Startup Ideas Startup research looks easy until you actually need to decide where to spend your time and money. A few signals can be surprisingly misleading. 💰 Funding can look like customer demand. A market receiving hundreds of millions in venture capital doesn’t necessarily mean customers are willing to pay for another product. 📈 Growth claims can look like market validation. Especially when the numbers come directly from vendors. 🏢 Customer logos can look like retention. A logo doesn’t tell you how much the customer pays, how heavily they use the product, or whether they’ll renew. ⚔️ A long competitor list can make a market look saturated. But those companies may target completely different buyers, workflows, or budgets. Generic AI research tends to compress all these signals into something like: “This is a rapidly growing market with strong demand and significant opportunity.” That sounds convincing. But as a fou

Depending on the model, you might have hundreds to choose from—or just one.

There are two ways to work with an AI agent and I had tried both. Write the thing yourself and hand over only the tedious parts. Or hand over the whole task and audit whatever comes back at the end. The first is slow. The second is fast right up until it is wrong, and by then the wrong thing is finished. I expected this series to be about forcing a third option into existence. Nine parts of making an agent follow a workflow it would rather skip. That is not what happened. I never had to enforce it once. The queue that started this had a payload contract nobody had verified, and each phase after that cost me something before it gave anything back. A plan that would not move until the risk register named the provider contract the brief had only guessed at. A build that missed nothing except what my own brief left out. A review that stopped handing back a feeling and started handing back a verdict on every requirement I had already called done. A matrix instead of a trusted green run. A rollback with a name on it before anything got called shipped. And a retrospective that would not let a lesson through until it had checked itself against the trail. Eight parts of that. What I did not expect was which part turned out to be automatic. The Fight I Expected Never Started By the time I finish writing a requirement, I already know roughly what it is going to cost. Most engineers do. You can feel the difference between a one-line fix and something that is going to touch four files and a migration before you have written a single line of it. What I assumed was that the agent could not feel that, and that policing the gap would be my job forever. Reminding it to run the chain. Catching it when it decided a spike was small enough to skip. It has not needed the reminder. Small bugs do not trigger a brief and a plan, and they should not. A standard requirement, a spike, anything long or cross-cutting, runs the full cycle in order. The classification lands where I would have put i

River AI, a startup founded by xAI co-founder Igor Babuschkin, has a fascinating vision for personal agents and secured $1.1 billion out of the gate.

TRON processed $2.1 trillion in USDT transfers during Q2 2026, according to Messari. During the same quarter, circulating USDT on TRON reached $87.9 billion, putting it ahead of Ethereum. Those numbers point to something developers working with stablecoins have to consider more carefully: the blockchain underneath a token can shape the entire payment experience. USDT on TRON uses the TRC-20 token standard. That means a USDT transfer is a smart contract transaction rather than a native TRX transfer. The wallet signs the transaction, the network executes the token contract and the resulting balance change is recorded on-chain. For an application accepting USDT, this creates several technical requirements. The system needs to identify the correct token contract, monitor the relevant transfer events and wait for sufficient confirmation before crediting the user's balance. Checking the address balance alone is not enough. TRON's developer documentation provides APIs for retrieving TRC-20 transaction history and filtering transfers by contract address. A payment system can use this data to monitor incoming USDT deposits and associate them with the correct customer account. The transaction also has a resource cost. TRON uses Bandwidth and Energy to process transactions. Regular transactions consume Bandwidth, while smart contract execution requires Energy. When an account does not have enough available resources, TRX is burned to cover the remaining cost. This creates an operational detail that users may never see. Someone can hold USDT in a wallet and still need TRX to send it. A payment provider can handle this in several ways. It can maintain TRX balances, stake TRX for resources or use delegated Energy. Another design can leave the requirement with the user. The choice affects the product. The amount of Energy required can also change depending on the destination account. TRON's documentation notes that a USDT transfer to an address that already holds USDT generally re

📺 Prefer to watch? 90-second YouTube Short · 💬 Telegram Originally published on software-engineer-blog.com . You run code concurrently all the time. But "concurrent" hides a critical choice: are you spawning separate processes or threads inside the same process? That choice decides whether one crash takes down your entire system or stays contained, and whether you're copying data between isolated worlds or racing to read the same memory. Mental model: A process is its own house; threads are roommates sharing one. Processes: Isolation at the Cost of Weight When you start a process, the operating system hands it its own private address space. That address space is walled off. Your process can't touch another process's memory—the OS enforces it at the CPU level. If your process crashes, it corrupts only its own memory. The kernel cleans it up. Every other process keeps running untouched. This is why browsers put each tab in its own process. One tab runs malicious JavaScript, spins into an infinite loop, or has a memory leak—that tab's process dies. The rest of your browser lives. You close the dead tab and open a new one. Your other tabs don't even hiccup. But isolation isn't free. Each process carries: Its own copy of the heap, stack, and memory pages Its own file descriptor table, open sockets, and kernel resources OS overhead to track and protect it Spawning a process is expensive—milliseconds on modern hardware, but measurably heavier than a thread. And if two processes need to share data, they can't just read the same memory. One process must copy data into a pipe or socket, send it across, and the other process must copy it out and into its own memory. That's overhead on every exchange. Threads: Speed and Sharing, With a Trap Threads live inside a single process and share that process's entire memory. The kernel doesn't wall them off from each other. When you spawn a thread, you're not duplicating the heap, the file descriptors, or the kernel state—you're just cr

Block Blast!, the most downloaded mobile game of 2025, is coming to Apple Arcade in September where it will be ad-free.