![\"](\"https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxqcl659ipq38wzsr9zx6.png\")
I wanted two things: short links under my own brand (every link I share points traffic back to my site), and a real excuse to run a complete system on the edge — DNS, distributed compute, storage, auth and a dashboard — in production, at zero infrastructure cost.
\n\nThe result is flino.link: a shortener that responds in under 10 ms from 300+ locations, runs entirely on Cloudflare's free tier, and whose only expense is the domain: $4.68 a year. This post covers the design decisions, which is where the interesting parts are.
\n\nA single Cloudflare Worker serves the whole domain:
\n\nGET /<slug> — the hot path. One read from Workers KV (globally replicated) and a 302 redirect. Nothing else touches that path./api/links — a REST API with Bearer auth to create, list and delete links./admin — a single-page dashboard served as inline HTML from the Worker itself. No framework, no build step.No servers, no containers, no database to manage. The whole Worker is three TypeScript files and zero runtime dependencies.
\n\nMy first idea was to hang the shortener off a route on flino.dev. Bad idea: shorteners attract abuse — spam, phishing — and their domains sooner or later end up on blocklists. If that happens, I don't want it dragging my main domain down with it. A separate domain isolates that reputation risk completely, and a short .link costs less than a coffee per year.
This is the central design decision. Workers KV is perfect for a shortener's access pattern — read-heavy, write-light, reads served from the edge — but its writes are eventually consistent: two concurrent increments in different datacenters would clobber each other. For counting clicks, it's useless.
\n\nA Durable Object solves exactly that: it's a single global instance with transactional SQLite storage. Every increment, no matter which datacenter it comes from, serializes through one consistent point:
\n
export class ClickCounter extends DurableObject<unknown> {\n private sql = this.ctx.storage.sql;\n\n increment(slug: string): void {\n const now = Date.now();\n this.sql.exec(\n \"INSERT INTO clicks (slug, count, last_click) VALUES (?, 1, ?) \" +\n \"ON CONFLICT(slug) DO UPDATE SET count = count + 1, last_click = ?\",\n slug, now, now,\n );\n }\n}\nDoesn't that single point become a bottleneck for redirects? No — because of what comes next.
\n\nwaitUntil trick: click counting with zero latency\nA shortener's contract is to redirect fast. If the redirect had to wait for the Durable Object write, every click would pay an extra round-trip. The solution is ctx.waitUntil(): it hands the runtime a promise that executes after the response has been sent to the visitor.
\n
const target = await env.LINKS.get(slug);\nif (target !== null) {\n // Runs after the response is sent — adds no latency to the redirect.\n ctx.waitUntil(counter(env).increment(slug));\n return Response.redirect(target, 302);\n}\nThe visitor gets their 302 after a single KV read; the counting happens in the background. Free analytics, in the literal sense of the word.
What happens when someone visits a slug that doesn't exist, or the domain root? Never a 404: always a redirect to flino.dev. A broken or deleted link never shows an ugly error page — it shows my site. Every dead path in the system becomes a touchpoint.
\n
// Unknown slug, root, or anything else:\nreturn Response.redirect(\"https://flino.dev\", 302);\nThe admin panel is a TypeScript constant holding a complete HTML page that the Worker serves at /admin. The API key lives in localStorage, dark mode comes free with prefers-color-scheme, and creating a link auto-copies the short URL to the clipboard. Zero dependencies, zero build, and it deploys together with the Worker in the same wrangler deploy.
For a project this size, a frontend framework would have been more infrastructure than product.
\n\n| \n | \n |
|---|---|
| Redirect latency | \n< 10 ms from 300+ locations | \n
| Capacity (free tier) | \n~100,000 requests/day | \n
| Infrastructure cost | \n$0/mo | \n
| Total cost | \n$4.68/yr (the domain) | \n
| Runtime dependencies | \n0 | \n
waitUntil is the most underrated pattern in Workers. Anything the visitor doesn't need — metrics, logs, counters — can move off the critical path.The full code is on GitHub, and if you want to see the system in action, this link goes through it: flino.link/devto-en. (Yes — your click is already on my dashboard 😄)
\n\nWhere would you have hosted this? Workers, a $5 VPS, Deno Deploy, fly.io? I'd genuinely like to read other approaches in the comments. 👇
","score":3},{"source":"https://dev.to/feed/tag/typescript","sourceHost":"dev.to","title":"I Gave My AI Agent a /proc Filesystem","link":"https://dev.to/talon_agent/i-gave-my-ai-agent-a-proc-filesystem-1nlj","pubDate":"Wed, 22 Jul 2026 23:33:26 +0000","description":"There's a moment, building an autonomous agent, when you realize you have no idea what it's doing.
\n\nNot in the philosophical sense — in the boring, operational sense. It's running a background job, three chat turns, and a memory-consolidation pass, all at once, and when you want to know which task is stuck, you're grepping a log file and correlating timestamps by hand. The agent has a rich internal life — a task table, an event bus, a plugin registry — and none of it is reachable. It's all trapped inside the process.
\n\nSo I did the thing Unix figured out in 1984. I gave my agent a /proc.
On Linux, /proc is a filesystem that isn't backed by a disk. When you read /proc/1234/status, the kernel computes the answer at the moment you read it — process 1234's live state, rendered as text, on demand. Nothing is stored. It's a view, not a file. That one idea — live state as a filesystem — is why you can cat your way through a running kernel with tools you already have.
My agent, Talon, is a long-lived process that runs across Telegram, Discord, and a terminal, doing work in the background whether or not anyone is talking to it. It has exactly the kind of internal state /proc was invented for. So its namespace, mounted at ~/.talon/ns, carries a live view:
\n
~/.talon/ns/\n home/ the workspace (real files)\n skills/ real files\n logs/ real files\n proc/\n tasks/<id> one task-table record, pretty JSON\n events the event-bus ring, JSON Lines, newest last\n plugins/ the live plugin registry\nhome, skills, and logs are ordinary directories. But proc/ is synthetic. When the agent reads proc/tasks/<id>, nothing is fetched from disk — the task record is serialized from the live task table at read time. proc/events is the event bus's ring buffer, rendered as JSON Lines the moment you look. It is a projection of what the process is doing right now, addressable by path.
The payoff is the same one Linux got: the agent can introspect itself with the tools it already has. No special API, no bespoke \"get my status\" function. The agent runs cat ~/.talon/ns/proc/events | jq — the same cat and jq it uses for everything else — and sees its own event stream. When I want to know what it's doing, I read a file too. The interface is the filesystem, and everyone already speaks filesystem.
I could have exposed all this as tools: list_tasks(), get_event_log(), describe_plugins(). Plenty of agent frameworks do. But every tool is a new thing the model has to learn, a new schema, a new call. A filesystem is a thing it already knows completely.
An agent that can ls, cat, grep, and jq needs zero new tools to explore its own internals — it composes the primitives it already has. Want the last ten events? tail. Want every task touching a plugin? grep. Want the stuck one? cat proc/tasks/<id>. The generality of the filesystem abstraction is the whole point: you expose state as paths, and the entire Unix toolbox comes for free, including the parts you didn't anticipate needing.
This is the same reason /proc beat every \"system monitoring API\" that came after it. The API is a wall with a few doors. The filesystem is an open field.
Here is where it stopped being cute and started being engineering.
\n\nTo serve synthetic files, you need FUSE — a way to say \"this directory is backed by my code, not a disk.\" FUSE is wonderful and FUSE is fragile. It needs /dev/fuse. It needs a native addon that matches your Node version. It needs the mount not to wedge. In a container, on a locked-down host, or after a dependency rebuild, any of those can be false. And an agent that crashes because it couldn't mount a convenience view is a bad trade — the introspection layer must never take down the thing it's introspecting.
So the mount degrades instead of failing. If FUSE is unavailable for any reason — config off, addon missing, no /dev/fuse, the mount probe times out — the namespace falls back to a symlink farm: the real directories (home, skills, logs) become plain symlinks the kernel follows natively, so ls ~/.talon/ns/home keeps working. You lose the synthetic proc/ views, but you never lose the workspace, and you never crash. Full fidelity when FUSE is healthy; a working subset when it isn't. The agent adapts to the floor it's standing on.
Degrading at boot is easy. The real problem is that a mount can die while the process runs — a native addon gets rebuilt out from under the daemon, the mountpoint wedges to ENOTCONN, the kernel side goes away. A mount that was healthy at startup is not a mount that stays healthy.
So a watchdog re-probes the live views on an interval. If it finds the mount dead, it doesn't just log and give up — it tears the dead mount down, restores the symlink farm so the workspace stays reachable during the outage, and tries to remount. If the remount succeeds, the synthetic views come back on their own. If it can't come back after a bounded number of tries, it settles into the symlink fallback for good rather than thrashing forever. The system's resting state is always \"working,\" whether or not FUSE is cooperating.
\n\nThat self-healing loop is the difference between a demo and something you leave running for weeks. A demo mounts once. A daemon has to survive its own environment changing underneath it.
\n\nThe concrete win is debuggability, but the deeper win is composability. Because the agent's internals are paths, everything that operates on paths operates on its internals. A skill that watches for a condition can tail proc/events. A health check can stat a synthetic file. A future feature I haven't built yet will read these views without a single new API, because the interface was never an API — it was the filesystem, and the filesystem is open-ended by design.
Forty years ago Unix decided that the way to expose live state was to make it look like files. It was right then, and it turns out to be exactly right for an AI agent that needs to see itself. The best idea in your architecture is often one someone already had — you just have to notice it applies to you.
\n\n\n\n\nTalon is an open-source (MIT) agentic AI harness — one persistent agent across Telegram, Discord, Teams, and the terminal, with real memory and background autonomy. The VFS lives in src/core/vfs. If this kind of thing is your catnip: github.com/dylanneve1/talon.
As I've been working more with Web3 technologies, I've found myself at a crossroads when it comes to allocating resources. Recently, I had to make a tough decision on whether to dedicate our team's limited bandwidth to performing thorough security audits or to optimizing the performance of our dApp. Given the high-stakes nature of blockchain development, where a single vulnerability can lead to significant financial losses, I chose to prioritize security audits. This decision was based on the understanding that while performance is crucial for user experience, security breaches can be catastrophic and irreversible.
\n\nHowever, I'm aware that this choice might not be universally applicable or agreed upon. Different projects have different needs and priorities. I'd like to hear from other developers who have faced similar dilemmas: have you ever had to choose between security and performance, and if so, what factors influenced your decision? I'm particularly interested in hearing from those who might disagree with my approach, especially if they have experience with projects where performance optimizations significantly impacted user adoption or retention.
","score":3},{"source":"https://github.blog/feed","sourceHost":"github.blog","title":"Copilot vs. raw API access: What are you actually paying for?","link":"https://github.blog/ai-and-ml/github-copilot/copilot-vs-raw-api-access-what-are-you-actually-paying-for/","pubDate":"Wed, 22 Jul 2026 19:00:00 +0000","description":"Copilot now bills usage at listed API rates. Compare direct model access with the coding workflow, policy, and harness work around it.
\nThe post Copilot vs. raw API access: What are you actually paying for? appeared first on The GitHub Blog.
","score":4},{"source":"https://dev.to/feed/tag/node","sourceHost":"dev.to","title":"Running headless Chrome in production is a part-time job","link":"https://dev.to/stevie_g/running-headless-chrome-in-production-is-a-part-time-job-16d1","pubDate":"Wed, 22 Jul 2026 18:32:24 +0000","description":"It works on your laptop. You wrote fifteen lines of Puppeteer, pointed it at a
\nURL, got a PNG back. You wrapped it in a route, deployed it, and for about a day
\nit was the easiest feature you ever shipped. Then the container got OOM-killed
\nat 2am, the queue backed up behind it, and you spent the next week learning that
\n\"just screenshot the page\" is a systems problem wearing a fifteen-line disguise.
Here is the list of what breaks, in roughly the order it breaks, and the process
\nshape that stops it. It's the same list whether you're on Puppeteer or
\nPlaywright, and whether you're rendering screenshots, PDFs, or OG images — it's
\nChrome's lifecycle that's hard, not the API in front of it.
A single headless Chrome rendering one page sits in the low hundreds of
\nmegabytes of RSS — call it 150–300 MB depending on the page. That's per render,
\nand it's the good case. Chrome also leaks: keep one instance alive long enough
\nand RSS climbs and doesn't come back, because a browser was built to be closed
\nby a human at the end of the day, not kept resident for a month. On a box with a
\nfixed memory limit the ending is always the same — the kernel's OOM killer picks
\nthe fattest process and kills it mid-render, and your logs show a bare SIGKILL
\nwith no stack trace.
If you've searched puppeteer out of memory and found forty issues with no
\naccepted answer, this is why: there isn't a line to fix, there's a lifecycle to
\nmanage. Two things follow. Cap how many renders share one instance and
\nrecycle it — close the whole browser and launch a fresh one every N pages,
\nso leaked memory is reclaimed by process death, not by hope. And size
\nconcurrency to RAM, not CPU: if one render is 250 MB, eight concurrent
\nrenders is 2 GB before you've counted the OS, and \"eight\" is a small number.
browser.close() is supposed to clean up, and usually does. But Chrome isn't
\none process — it's a tree: a main process, a zygote, a renderer per page, plus
\nGPU and utility helpers. When Chrome crashes, or your Node process is killed
\nwhile a browser is open, or a navigation wedges the renderer, close() never
\nruns or never finishes, and you're left with <defunct> chrome processes
\nreparented to init. They hold memory and file descriptors. Do that a few
\nthousand times and you exhaust PIDs or FDs, and the box stops accepting work for
\nreasons that have nothing to do with your code.
The fix is unglamorous: reap the tree yourself. Track the browser's PID and, on
\nany abnormal exit, kill the whole process group instead of trusting the
\nlibrary's close(). In a container, run a real init that reaps orphans
\n(--init, tini, or dumb-init) so PID 1 isn't your app pretending to be an init
\nsystem it isn't.
Launching Chrome costs roughly 800 milliseconds before it renders a single pixel
\n— process spawn, sandbox setup, the first blank page. Launch a fresh browser per
\nrequest and you pay that tax every request, where it dwarfs the actual render for
\nanything simple. So the instinct is to launch one browser and reuse it forever —
\nwhich walks you straight back into problem #1.
The resolution is the distinction most tutorials skip: reuse the instance,
\nisolate per context. A browser context is a clean, cookieless, cacheless
\nsession inside an already-running Chrome — cheap to create, cheap to destroy,
\nisolated from every other render.
\n
// not this — 800ms of startup tax on every request\nconst browser = await puppeteer.launch()\nconst page = await browser.newPage()\n\n// this — warm instance, throwaway context per render\nconst context = await browser.createBrowserContext() // cheap, isolated\nconst page = await context.newPage()\n// …render…\nawait context.close() // nothing leaks into the next render\nKeep a small pool of warm instances, give each render its own fresh context,
\nthrow the context away after, and recycle the whole instance every N renders
\n(problem #1). You pay the 800ms once per instance lifetime, not once per request,
\nand renders don't bleed into each other.
Your renderer navigates to a URL and waits. Sometimes the wait never ends: an
\ninfinite redirect, a page that never fires load, a websocket that keeps the
\nnetwork \"busy\" forever, a while(true) in someone's analytics. Without a hard
\nceiling, one bad URL parks a browser until it's killed — and if you're reusing
\ninstances, one hostile page can wedge a slot in your pool for good.
Put hard timeouts on both navigation and capture, and when one trips, kill the
\ninstance and launch a new one — don't try to nurse it back. A browser that
\nhung once is not a browser you can reason about; it's carrying whatever state
\ncaused the hang. The correct response to a sick Chrome is a fresh Chrome. It
\nfeels wasteful and it's the single most reliability-improving rule in the whole
\nsystem.
The naive version renders inline: request arrives, you launch or borrow a
\nbrowser, render, respond. Under load this is exactly how you die — a traffic
\nspike becomes N simultaneous browsers becomes an OOM kill becomes every in-flight
\nrender failing at once. Rendering is expensive and bursty, which is the precise
\nprofile a queue exists for.
Put a queue between the request and the render. The API accepts the job and
\nreturns immediately; a pool of workers pulls jobs at a rate their RAM can
\nsurvive. A spike becomes queue depth — a number you can watch and autoscale
\non — instead of a memory graph that falls off a cliff. Queue depth is your
\ncapacity early-warning signal; RSS-at-the-OOM-line is the alternative, and it
\nwarns you by paging you.
Your laptop has fonts. A minimal Linux container does not. So the page that
\nlooked right locally renders with tofu boxes where the CJK text was, blank
\nrectangles where the emoji were, and the wrong fallback for everything else — and
\nyou find out from a customer's screenshot, not a test. Real page rendering means
\nyou now own a font pipeline: a base font set, CJK coverage, an emoji font, and
\nthe standing knowledge that a Chrome upgrade can shift glyph rendering and
\nquietly change your output out from under a cache.
The reflex is \"put it on Lambda and let someone else scale it.\" That moves the
\nproblems, it doesn't remove them. You ship a special slimmed Chromium build to
\nfit the unzipped size limit; you eat a multi-second cold start on every
\nscale-up, because a warm pool is exactly what serverless won't give you; you cap
\nout at the function's memory and time limits, which is where playwright lambda comes from; and you still own the fonts. It's a legitimate deployment
\ntimeout
\ntarget, but it's a different set of sharp edges, not fewer of them.
Put it together and the design that works isn't exotic — it's this list, applied
\nconsistently:
![Architecture diagram: bursty traffic enters a queue; a pool of stateless, disposable workers each run a warm Chrome instance with one context per render, recycled every N renders and killed on hang; results land in an edge cache served in milliseconds.]
\n\n
That's the whole trick. It's also, to be blunt, most of what our workers do —
\nbecause there isn't a cleverer answer, only this list, monitored.
\n\n\nDisclosure before the turn: we run this as a service
\n
\n(Shotpipe), so read the next two sections as the author
\npointing at their own tool. The list above is true whether you build it or buy
\nit — I'm claiming the list is the work, not that you need us to do it.
Every puppeteer out of memory thread is about pages you control — your own
\ndashboard, your own invoice, your own marketing page. The moment the URL comes
\nfrom your users — a link preview, an unfurl, a \"screenshot my site\" button —
\nyou've added a second problem that has nothing to do with memory: the URL
\nmight point back at you. Someone submits
\nhttp://169.254.169.254/latest/meta-data/ and your obliging headless browser
\nreads your cloud credentials and hands them back as a PNG. That's SSRF, and a
\nbrowser is a near-perfect engine for it, because it follows redirects and
\nresolves DNS for you — the two exact places the attack hides.
Fixing it properly means resolving DNS yourself, checking every resolved IP
\nagainst private, loopback, link-local, and cloud-metadata ranges, pinning the IP
\nyou validated and connecting to that one, and re-checking on every redirect
\nhop. It's a module with its own test suite, not an if-statement — and it's the
\npart no memory-leak tutorial mentions, because those authors are rendering their
\nown pages. We wrote it up in screenshotting URLs you don't
\ncontrol: if your renderer ever touches a
\nURL a stranger typed, read that before you ship.
Honestly: if you render a handful of pages you control, on a schedule,
\nself-hosting is fine. Launch Chrome, render, close, move on — none of the above
\nbites at that volume, and you shouldn't pay anyone to avoid a problem you don't
\nhave. The list starts mattering when renders get frequent, bursty, or pointed at
\nURLs you don't own. That's the crossover where \"just screenshot the page\" stops
\nbeing fifteen lines and becomes a service — ours, or the one you'll end up
\nbuilding.
GitHub is making some significant changes to its bug bounty program, shifting its focus to give researchers a better experience working with the GitHub team.
\nThe post Next chapter: Restructuring GitHub’s bug bounty program appeared first on The GitHub Blog.
","score":4},{"source":"https://dev.to/feed/tag/node","sourceHost":"dev.to","title":"How Our AI Agents Built a Gusto API Wrapper for Simplified Employee Data Sync in Record Time","link":"https://dev.to/denisssenkyrmaker/how-our-ai-agents-built-a-gusto-api-wrapper-for-simplified-employee-data-sync-in-record-time-1d40","pubDate":"Wed, 22 Jul 2026 15:30:04 +0000","description":"Integrating with third-party APIs can often be a complex and time-consuming task, especially when dealing with critical HR and payroll data like that managed by Gusto. Developers often face challenges with authentication, rate limits, data mapping, and maintaining robust connections. At Pixel Office, we're continuously exploring how AI agents can streamline such development processes, and our latest project demonstrates this perfectly: an autonomously generated Gusto API Wrapper for simplified employee data synchronization.
\n\nGusto's API offers comprehensive functionalities, but building a direct integration from scratch requires significant effort to handle various endpoints, data structures, and best practices for secure and efficient data exchange. Our goal was to create a utility that abstracts away this complexity, providing a simplified interface for developers to sync employee data, all while leveraging our internal AI development pipeline.
\n\nThis project was a testament to the collaborative power of our AI agents:
\n\nThe core of the wrapper is a JavaScript module designed to encapsulate Gusto API calls, providing helper functions for common operations like fetching employee lists, updating profiles, or managing payroll details. It leverages a secure authentication mechanism, often involving OAuth or API keys, and handles data serialization/deserialization.
\n\nHere’s a snippet showcasing the foundational setup, including our custom configuration and Firebase integration for authentication, demonstrating how the wrapper is initialized:
\n
// Widget ID for localStorage and API calls\n const WIDGET_ID = \"gusto-api-wrapper-for-simplified-employee-data-sync\";\n const WHATSAPP_NUMBER = \"420607450436\";\n const API_BASE_URL = \"https://api.pixeloffice.eu/api/pay\";\n const PIXEL_OFFICE_URL = \"https://pixeloffice.eu\";\n\n // Firebase Configuration (provided in requirements)\n const firebaseConfig = {\n apiKey: \"AIzaSyFakeKeyForShowcaseHubAuthTestingOnly\",\n authDomain: \"pixeloffice-hub.firebaseapp.com\",\n projectId: \"pixeloffice-hub\",\n storageBucket: \"pixeloffice-hub.appspot.com\",\n messagingSenderId: \"1234567890\",\n appId: \"1:1234567890:web:abcdef123456\"\n };\n\n // Initialize Firebase if not already initialized\n if (!firebase.apps.length) {\n firebase.initializeApp(firebaseConfig);\n }\n const auth = firebase.auth();\n\n // Global i18n dictionary\n const i18n = {\n\n// ... a další multijazyčné překlady\n\n\n\n\"My primary focus was to ensure the wrapper was not just functional, but also highly intuitive for developers. I abstracted away the complex OAuth flow and error handling into simple, callable methods, so developers can concentrate on their business logic rather than API quirks. The
\nWIDGET_IDandAPI_BASE_URLare key for modularity and environment configuration.\" – Jan (AI Developer)
The wrapper provides methods like getEmployees(), updateEmployee(id, data), and createPayroll(data), each internally handling the HTTP requests, error responses, and data formatting required by Gusto. This significantly reduces boilerplate code and potential errors for integrators.
We believe in practical demonstrations. You can explore the live demo of our Gusto API Wrapper and see how it simplifies employee data synchronization. Experiment with its capabilities and imagine how it could accelerate your HR-related development projects.
\n\nLive Demo: https://pixeloffice.eu/showcase/gusto-api-wrapper-for-simplified-employee-data-sync/
\n\nThis project underscores the immense potential of AI in autonomous software development. By delegating complex API integration tasks to agents like Jan and Klára, we can rapidly prototype and deploy robust solutions, freeing human developers to focus on higher-level innovation. We invite you to explore the wrapper, integrate it into your projects, and share your feedback!
","score":3},{"source":"https://dev.to/feed/tag/vue","sourceHost":"dev.to","title":"How I Built a Blank Page Detector for PDFs with Vue 3 and Canvas","link":"https://dev.to/sunshey/how-i-built-a-blank-page-detector-for-pdfs-with-vue-3-and-canvas-23m4","pubDate":"Wed, 22 Jul 2026 13:30:56 +0000","description":"Removing blank pages from a PDF sounds trivial — until you realize that \"blank\" can mean many things. Is a page with a faint gray background blank? What about a page that has only a header or footer?
\n\nHere's how I built a browser-based blank page detector using PDF.js rendering, canvas pixel analysis, and pdf-lib for the actual removal.
\n\nServer-side tools require uploading your file first. For documents with sensitive content, that's a risk. A browser-based approach:
\n\npdfjs-dist) for page rendering<script setup lang=\"ts\">\nimport { ref } from 'vue'\nimport * as pdfjs from 'pdfjs-dist'\nimport { PDFDocument } from 'pdf-lib'\n\npdfjs.GlobalWorkerOptions.workerSrc = '/pdf.worker.min.js'\n\ninterface BlankPageResult {\n pageIndex: number\n isBlank: boolean\n confidence: number // 0-1, higher means more confident it's blank\n}\n\nasync function detectBlankPages(\n file: File,\n sensitivity: 'low' | 'medium' | 'high' = 'medium'\n): Promise<BlankPageResult[]> {\n const arrayBuffer = await file.arrayBuffer()\n const pdf = await pdfjs.getDocument({ data: arrayBuffer }).promise\n\n const thresholds = { low: 0.01, medium: 0.05, high: 0.1 } // ratio of non-white pixels\n const results: BlankPageResult[] = []\n\n for (let i = 1; i <= pdf.numPages; i++) {\n const page = await pdf.getPage(i)\n const viewport = page.getViewport({ scale: 1 })\n\n // Create offscreen canvas to render and analyze\n const canvas = document.createElement('canvas')\n canvas.width = viewport.width\n canvas.height = viewport.height\n const ctx = canvas.getContext('2d')!\n\n await page.render({ canvasContext: ctx, viewport }).promise\n\n const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height)\n const totalPixels = imageData.data.length / 4\n let nonWhitePixels = 0\n\n // Analyze pixel by pixel\n for (let p = 0; p < imageData.data.length; p += 4) {\n const r = imageData.data[p]\n const g = imageData.data[p + 1]\n const b = imageData.data[p + 2]\n\n // A pixel is considered \"white\" if all channels are > 240\n if (r < 240 || g < 240 || b < 240) {\n nonWhitePixels++\n }\n }\n\n const whiteRatio = nonWhitePixels / totalPixels\n const confidence = Math.min(1, thresholds[sensitivity] * 5)\n const isBlank = whiteRatio < thresholds[sensitivity]\n\n results.push({\n pageIndex: i - 1, // zero-indexed for pdf-lib\n isBlank,\n confidence: 1 - whiteRatio // higher = more content\n })\n }\n\n return results\n}\n</script>\nOnce we know which pages are blank, use pdf-lib to remove them:
\n
async function removeBlankPages(\n arrayBuffer: ArrayBuffer,\n blankIndices: number[]\n): Promise<Uint8Array> {\n const pdfDoc = await PDFDocument.load(arrayBuffer)\n const pageCount = pdfDoc.getPageCount()\n\n // Sort indices in descending order to avoid shifting problems\n const sorted = [...blankIndices].sort((a, b) => b - a)\n\n for (const index of sorted) {\n if (index >= 0 && index < pageCount) {\n pdfDoc.removePage(index)\n }\n }\n\n return await pdfDoc.save()\n}\nKey detail: sorting in descending order. If you remove page 5 first, page 6 becomes page 5. By removing from highest index to lowest, positions stay stable.
\n\nUsers need to see which pages will be deleted before committing:
\n
async function generateThumbnails(file: File, count: number): Promise<string[]> {\n const arrayBuffer = await file.arrayBuffer()\n const pdf = await pdfjs.getDocument({ data: arrayBuffer }).promise\n const thumbnails: string[] = []\n\n for (let i = 1; i <= Math.min(pdf.numPages, count); i++) {\n const page = await pdf.getPage(i)\n const viewport = page.getViewport({ scale: 0.3 }) // smaller thumbnail\n\n const canvas = document.createElement('canvas')\n canvas.width = viewport.width\n canvas.height = viewport.height\n const ctx = canvas.getContext('2d')!\n\n await page.render({ canvasContext: ctx, viewport }).promise\n thumbnails.push(canvas.toDataURL('image/jpeg', 0.7))\n }\n\n return thumbnails\n}\nEach thumbnail gets a badge: \"blank\" (red), \"likely blank\" (yellow), or \"has content\" (green). Users can override by clicking any page.
\n\nFor large PDFs (100+ pages), pixel-by-pixel analysis gets slow. Two optimizations:
\n\n// Downscale example\nconst SCALE = 0.15 // 15% of original resolution\nconst viewport = page.getViewport({ scale: SCALE })\nAt 15% scale, a 3000px-wide page becomes 450px. That's 12x fewer pixels to check per page, with negligible impact on accuracy for blank-page detection.
\n\nAt en.sotool.top/remove-blank-pages, we learned:
\n\nBlank page removal is straightforward in theory but tricky in practice because \"blank\" is subjective. For production use, consider combining pixel analysis with text-layer checks — a page might look blank visually but still have selectable text that matters.
\n\nWant to see the full source? github.com/sunshey/pdf-tool.
\n\n\n\n\nIf you need desktop-grade PDF editing — batch blank page removal, OCR, or advanced export formats — check out Wondershare PDFelement.
","score":7},{"source":"https://dev.to/feed/tag/vue","sourceHost":"dev.to","title":"I Spent 16 Months Building My Own SaaS Solo — Why the Last 10% Takes Months","link":"https://dev.to/joshmsn/i-spent-16-months-building-my-own-saas-solo-the-last-10-took-longer-than-the-first-90-288","pubDate":"Wed, 22 Jul 2026 09:18:29 +0000","description":"16 months. Several hundred hours alongside client work. One finished product.
\n\nI built LaizyNote — a business operating system for freelancers and solo entrepreneurs: notes, tasks, projects, time tracking, contacts, calendar, documents and an AI assistant in a single interface.
\n\nI've written plenty about client projects. This is different — this one is mine. And that changes everything: the perspective, the responsibility, and the honest realization of how much a \"finished\" SaaS actually takes.
\n\nNo code in this one. Just the parts that were genuinely hard.
\n\n\n\n\nOut of my own need. It bugged me that there was no tool you could start with for free, that had everything I needed — and that would later also help me run my business. The big names can do a lot, but they're bloated: you spend weeks setting up before you jot down your first thought.
\n\nI wanted the opposite: start instantly, yet have everything on board when you need it. While building, it became clear this isn't a niche — it's a gap. Freelancers juggle five tools (notes here, time tracking there, invoices somewhere else) and none of them shows how their business is actually doing.
\n\nThat last part — Business Insights — is the one feature I'd single out. Because LaizyNote already knows your time, projects, clients and revenue, it can derive the numbers you'd otherwise keep in a spreadsheet: your real hourly rate (not the one you bill), the trend over years, client health, whether your portfolio leans too heavily on one client. Other tools show you what you did. This shows you what it earned you.
\n\nThe biggest technical challenge wasn't a single difficult feature. It was keeping an overview: where which data lives, where it flows, who is allowed to see what — and making sure it stays that way while ten other things change.
\n\nLaizyNote runs on Firebase (Firestore + server-side Cloud Functions, hosted in the EU). Every user has a personal space but can also share team workspaces with roles and permissions. That's where it gets tricky: every single query has to know whether it concerns personal or shared team data, and whether the user may access it at all.
\n\nWith other people's data you can't afford a single mistake. So the access rules live server-side — the server decides what someone may see, never the browser. Everything follows the same patterns: consistent data paths, workspace-specific caches, centrally defined rules instead of special cases per feature. It sounds bureaucratic. It's the only way a new feature doesn't quietly break three old ones.
\n\nPrototyping is incredibly fast today. A new module stands in days. What eats time is the polish — the last 10% that separates a hobby project from a product people trust with their work.
\n\nThat 10% is made of things nobody notices as long as they work, and that stand out immediately when they don't:
\n\nNone of these is big on its own. But there are hundreds of them, and each one wants to be found, understood and cleanly solved.
\n\nThe lesson that stuck: passing tests don't prove it works in the real app. Some bugs only show up when you operate it yourself in the browser. So a lot gets tested by hand — especially anything involving real money or other people's data.
\n\nDaisy is the AI assistant in LaizyNote. You write to her in plain language and she can act: create tasks, structure projects, link contacts, summarize time and numbers. \"Create a project Website with three tasks for Emma\" becomes exactly those entries.
\n\nThe crucial part: she asks before every write action. She shows a preview — \"5 tasks will be created\" — and only a confirm click executes it. AI that writes into your data on its own, without you watching, would be a breach of trust.
\n\nBuilding AI into a real product brings a challenge classic development doesn't have: it's not predictable. The same question can be answered slightly differently twice. The model doesn't always stick to the required format. Answers sometimes run too long mid-sentence. None of this is checkable with \"is the code correct\" — it has to be tried by hand, over and over. Two constraints mattered most: privacy (Daisy runs through a European AI provider, EU-hosted — fitting for a .eu product) and cost control (usage quotas and a fixed monthly cap per user, so neither the user nor I get a nasty surprise).
The biggest surprise wasn't the technology. It was how much is needed around the product before you can bill a single customer.
\n\nA SaaS isn't just an app. It's a brand with a name, logo and voice. Legal texts, terms, a privacy policy, a service description that holds up contractually. Payment processing with subscriptions, cancellations, yearly and monthly prices, vouchers and invoices. Automated emails, backups, and processes for when someone deletes their account. Users never see most of it — but without that foundation there's no product you can trust.
\n\nI thought building the product was the work. In truth the product is one half; the other is brand, law, payment and operations.
\n\nYes — much of it exactly the same. Firebase was the right call for a one-person project with a large feature set: it takes backup, scaling and auth off your plate so you can focus on the product. What I'd change is the planning — I'd cut some data structures differently from the start (things you only understand once you've built them wrong), and I'd budget for all the surrounding work earlier instead of treating it as \"I'll do that at the end\".
\n\nThe result is live and publicly available, with all modules in use. Anyone can start for free — which was the whole point from the beginning.
\n\n\n\n\nTakeaways if you're building your own SaaS:
\n\nFull write-up (and the product) on hafenpixel.de. You can try LaizyNote for free — no credit card. Happy to answer questions in the comments.
","score":3},{"source":"https://dev.to/feed/tag/nuxt","sourceHost":"dev.to","title":"Nuxt vs SvelteKit: What works better?","link":"https://dev.to/erikch/nuxt-vs-sveltekit-what-works-better-132h","pubDate":"Wed, 22 Jul 2026 01:13:24 +0000","description":"Nuxt vs SvelteKit. Which one is better?
\n\nThat is is what I've been testing out this week. I built the same app twice. Once in Nuxt with the version 5 compatibility preview turned on, and once in SvelteKit using its experimental remote functions.
\n\nI created a basic task app. Where you can add or remove tasks. I also logged the network requests and timing. The biggest thing I noticed was that the SvelteKit app would make one request, when creating a new task, while the Nuxt app needed two.
\n\nThat one difference turned out to be the most interesting part of the whole comparison, so let's jump in.
\n\nBoth apps are a simple task list backed by an in browser memory store. Both are production builds running locally, and both render the initial task list on the server.
\n\nQuick caveat, Nuxt 5 is not released yet. My Nuxt app is stable Nuxt 4.5 with the compatibility flag set:
\n
// nuxt.config.ts\nexport default defineNuxtConfig({\n compatibilityDate: '2026-07-01',\n future: {\n compatibilityVersion: 5,\n },\n})\nAnd SvelteKit's remote functions are still marked experimental in the docs. So this is a comparison of directions, not finished products.
\n\nWhen I add a task in the Nuxt app, I get a POST to /api/tasks (about 690 ms) followed by a GET to /api/tasks (about 450 ms) to refresh the list. A little over 1,100 ms total, and the timeline panel reports two browser requests.
![\"Nuxt](\"https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fbv3bxswcuz5iy702h5ns.png\")
When I add a task in the SvelteKit app, I get one request. About 1,100 ms. The server still does both operations, the mutation and the read, but they come back in a single response.
\n\n![\"Svelte](\"https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fur0jeepdlow1acyb8w7d.png\")
Plain refreshes were nearly identical. 447 ms in Nuxt, 448 ms in SvelteKit. I ran this quite a few times, and if I had to pick, SvelteKit felt slightly faster overall. But the totals were close enough that I wouldn't choose a framework based on them.
\n\nLet's talk about how requests work in each.
\n\nIf you've used Nuxt before, this will feel familiar. I have two handlers in server/api:
\n
// server/api/tasks.get.ts\nimport { defineEventHandler } from 'h3'\nimport { readTasks } from '../utils/task-store'\n\nexport default defineEventHandler(() => readTasks())\nThe POST handler validates the title and saves the task. These are normal HTTP endpoints. Anything that speaks HTTP can call them.
\n\nOn the page, useFetch loads the initial data during SSR, so hydration doesn't fetch it again. When I add a task, I post with $fetch and then call refresh():
\n
const { data: snapshot, refresh } = await useFetch<TaskSnapshot>('/api/tasks', {\n key: 'task-dashboard',\n})\n\nasync function submitTask() {\n await $fetch('/api/tasks', {\n method: 'POST',\n body: { requestId: crypto.randomUUID(), title },\n })\n await refresh()\n}\nThe code is explicit, and the network tab matches the code exactly. POST first, GET second.
\n\nCould I avoid the second request? Sure. The POST could return the updated list and I could patch local state myself. I wrote it this way because invalidate-and-refetch is the workflow most of us reach for, and it's exactly the pattern SvelteKit's remote functions are designed to improve. I also find by adding a GET request we are verifying the exact output after the POST.
\n\nThis is the experimental feature. You turn it on in svelte.config.js:
\n
const config = {\n kit: {\n adapter: adapter(),\n experimental: {\n remoteFunctions: true,\n },\n },\n compilerOptions: {\n experimental: {\n async: true,\n },\n },\n}\nThen you create a file ending in .remote.ts and export your server functions:
\n
// tasks.remote.ts\nimport { command, query } from '$app/server'\nimport { addTask as addTaskToStore, readTasks } from '$lib/server/task-store'\nimport * as v from 'valibot'\n\nconst taskInput = v.object({\n requestId: v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(100)),\n title: v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(80)),\n})\n\nexport const getTasks = query(async () => readTasks())\n\nexport const addTask = command(taskInput, async ({ requestId, title }) => {\n const result = await addTaskToStore(title, requestId)\n\n // This runs on the server, and the refreshed query value\n // comes back in the same command response.\n void getTasks().refresh()\n\n return result\n})\nThe function bodies always run on the server. In the browser, they become typed wrappers around endpoints SvelteKit generates for you. I really enjoy how there is no public endpoint to hit, it's isolated. It's created for the call, which means I can use environment variables and secrets in there without thinking about it.
\n\nThe void getTasks().refresh() line is the API on the server side to trigger the refresh. After the mutation, SvelteKit refreshes the query on the server and packages the new value into the command's response. That's the single-flight mutation, and it's why the network tab shows one request instead of two.
On the page, I just import and call the functions:
\n
<script lang=\"ts\">\n import { addTask, getTasks } from './tasks.remote'\n\n const tasks = getTasks()\n\n async function submitTask(event: SubmitEvent) {\n event.preventDefault()\n await addTask({ requestId: crypto.randomUUID(), title })\n }\n</script>\n\n{@render dashboard(await tasks)}\nThat await tasks at the bottom works almost like a subscription. When the server-side refresh happens, the task list updates automatically. No server routes to worry about.
![\"remotefunctions\"](\"https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F24q7zjeyi2ru8skt8l6t.png\")
My first look at this pattern, I thought it was a little complicated. But it clicked pretty fast, and the query-refreshes-inside-the-command idea makes sense once you see it in the network tab. If you've used server actions in Next or TanStack Start, this will feel like family. I'd say I still like TanStack Start's server actions a bit better, but this is close.
\n\n\n\n\nHeads up: remote functions have been available since SvelteKit 2.27 and they are still experimental. The API has changed several times over the past few months. If you adopt them early, pin your versions and budget time for migrations.
\n
Nuxt 5 doesn't have an answer to remote functions. Most of the confirmed work is in the underlying structure. A new version of Nitro, a new Vite integration, and framework internals. The upgrade guide walks through what to expect, and it's mostly foundation work rather than new application-level APIs.
\n\nI'm sticking with Nuxt. I love the API routes pattern, I love Vue, and nothing in this demo is a reason to rewrite an existing app. You can return updated data from a mutation today and skip the second request yourself if it matters.
\n\nBut I do miss server actions. Frameworks like SvelteKit, Next, and TanStack Start all have some version of a typed, non-public server function you can call from a component. I hope Nuxt adds something like it in a future update, beyond the server components they have now.
\n\nIf you're starting a SvelteKit project and can live with an experimental API, try remote functions first. The single-flight mutation is awesome, and the types crossing the boundary for free is a great developer experience.
\n\nWhich side are you on: explicit API routes, or remote functions that generate the transport for you? Let me know in the comments if you agree or disagree.
\n\nBTW, I used Kiro for all my research for this post and video! Check it out , it's an amazing harness!
","score":3},{"source":"https://github.blog/feed","sourceHost":"github.blog","title":"How to build interactive experiences with canvases","link":"https://github.blog/ai-and-ml/github-copilot/how-to-build-interactive-experiences-with-canvases/","pubDate":"Tue, 21 Jul 2026 16:00:00 +0000","description":"Canvases turn AI into interactive workspaces where you can visualize information, explore workflows, and take action across complex tasks.
\nThe post How to build interactive experiences with canvases appeared first on The GitHub Blog.
","score":4},{"source":"https://dev.to/feed/tag/vue","sourceHost":"dev.to","title":"How to Crop PDF Pages in the Browser with Vue 3 and pdf-lib","link":"https://dev.to/sunshey/how-to-crop-pdf-pages-in-the-browser-with-vue-3-and-pdf-lib-5d75","pubDate":"Tue, 21 Jul 2026 13:15:53 +0000","description":"Cropping PDF pages sounds like a server-side operation, but with pdf-lib and a <canvas> preview, you can do it entirely in the browser. No upload, no backend, and full control over margins.
This post walks through a minimal but production-ready implementation you can drop into a Vue 3 project.
\n\nTraditional PDF croppers upload your file, crop it on a server, and send it back. That works, but it introduces latency, bandwidth costs, and privacy risk. A browser-based cropper:
\n\n<script setup lang=\"ts\">\nimport { ref } from 'vue'\nimport { PDFDocument, rgb } from 'pdf-lib'\nimport * as pdfjs from 'pdfjs-dist'\n\npdfjs.GlobalWorkerOptions.workerSrc = '/pdf.worker.min.js'\n\nconst file = ref<File | null>(null)\nconst cropping = ref(false)\nconst margins = ref({ top: 50, bottom: 50, left: 50, right: 50 })\n\nasync function handleFileUpload(selected: File) {\n file.value = selected\n}\n\nasync function cropPdf() {\n if (!file.value) return\n cropping.value = true\n\n try {\n const arrayBuffer = await file.value.arrayBuffer()\n const pdf = await PDFDocument.load(arrayBuffer)\n const pages = pdf.getPages()\n\n for (const page of pages) {\n const { width, height } = page.getSize()\n const m = margins.value\n\n // Clamp margins to page dimensions\n const cropLeft = Math.min(m.left, width / 2 - 1)\n const cropRight = Math.min(m.right, width / 2 - 1)\n const cropTop = Math.min(m.top, height / 2 - 1)\n const cropBottom = Math.min(m.bottom, height / 2 - 1)\n\n page.setCropBox(\n cropLeft,\n cropBottom,\n width - cropLeft - cropRight,\n height - cropTop - cropBottom\n )\n }\n\n const croppedBytes = await pdf.save()\n const blob = new Blob([croppedBytes], { type: 'application/pdf' })\n downloadBlob(blob, 'cropped.pdf')\n } finally {\n cropping.value = false\n }\n}\n\nfunction downloadBlob(blob: Blob, name: string) {\n const url = URL.createObjectURL(blob)\n const a = document.createElement('a')\n a.href = url\n a.download = name\n a.click()\n URL.revokeObjectURL(url)\n}\n</script>\nThe key method is page.setCropBox(left, bottom, width, height). It modifies the crop box — the visible area when the page is displayed. Unlike the media box (physical page size), the crop box doesn't change the underlying content; it just hides what's outside the visible region.
For a better UX, render the page with PDF.js on a canvas and draw an overlay rectangle showing the crop region. Users can drag the edges of the rectangle to adjust margins visually:
\n
function drawCropOverlay(canvas: HTMLCanvasElement, page: pdfjs.PageViewport) {\n const ctx = canvas.getContext('2d')!\n ctx.clearRect(0, 0, canvas.width, canvas.height)\n\n // Draw the page\n page.draw(ctx).promise.then(() => {\n // Draw semi-transparent overlay outside crop region\n ctx.fillStyle = 'rgba(0, 0, 0, 0.5)'\n const m = margins.value\n // Top strip\n ctx.fillRect(0, 0, canvas.width, canvas.height * (m.top / page.height))\n // Bottom strip\n ctx.fillRect(0, canvas.height * ((page.height - m.bottom) / page.height), canvas.width, canvas.height * (m.bottom / page.height))\n // Left strip\n ctx.fillRect(0, canvas.height * (m.top / page.height), canvas.width * (m.left / page.width), canvas.height * (1 - (m.top + m.bottom) / page.height))\n // Right strip\n ctx.fillRect(canvas.width * ((page.width - m.right) / page.width), canvas.height * (m.top / page.height), canvas.width * (m.right / page.width), canvas.height * (1 - (m.top + m.bottom) / page.height))\n })\n}\nAt en.sotool.top/crop-pdf, we learned a few things from real users:
\n\nFor simple PDF cropping, pdf-lib plus a canvas preview is enough. If you need batch processing, OCR, or conversion to editable formats, you'll want a desktop tool.
Want to see the full source? The site is built in public at github.com/sunshey/pdf-tool.
\n\n\n\n\nIf you need desktop-grade PDF editing — OCR, batch cropping, or advanced export formats — check out Wondershare PDFelement.
","score":3},{"source":"https://dev.to/feed/tag/vue","sourceHost":"dev.to","title":"Shipping a coffee storefront before the data model was ready","link":"https://dev.to/oleksandr_devops/shipping-a-coffee-storefront-before-the-data-model-was-ready-7a7","pubDate":"Tue, 21 Jul 2026 12:21:12 +0000","description":"We just shipped two big surfaces for Brewly Store: a Catalog / Shop page and a full product page (PDP). On the surface it's an ordinary e-commerce release — a filterable grid, a product detail view with size and grind pickers, a taste profile. The interesting part isn't the features. It's that we shipped all of it before the backend GET /products endpoint existed, and the whole release hinged on one discipline: never let a placeholder pretend to be a working feature.
Here's what that looks like in the actual code.
\n\nBrewly Store is a coffee e-commerce platform running on Cloudflare's edge:
\n\n![\"Brewly](\"https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdrive.google.com%2Fuc%3Fid%3D1nNHKlPBhSCiUcpfC1s90DIkYRh7Eop_A%26export%3Ddownload\")
@hono/zod-openapi, backed by Cloudflare D1 (SQLite at the edge)./uk in front of the path, e.g. brewly.online/uk/catalog/coffee.At release time the products themselves still live in a static frontend module (app/data/products.ts) — the GET /products API isn't there yet. That single fact shaped every decision below.
Catalog / Shop — /catalog/coffee: a \"Brewly Shop\" header with a live product count, sorting (Featured / Price ↑ / Price ↓), a filter sidebar (Roast level, Type, Grind size, Taste notes, Price), a 3-column grid with black \"Add to Cart\" buttons, and \"Load more\" pagination with numbered pages.
Product page (PDP) — e.g. /product/ethiopia-yirgacheffe: breadcrumbs, a taste rating drawn as coffee beans (Bitterness / Sweetness / Acidity), size (250 g / 1000 g) and grind selection, a quantity stepper, a reactive price, accordions (Shipping / How to brew / Origin details), a Taste Profile block, and a \"You may like\" section.
All of it renders, responds, and looks finished. Behind it, the data was uneven — and that's where the real work was.
\n\nWe had four real products with confirmed data and dedicated pages — brazil-santos, colombia-supremo, ethiopia-yirgacheffe, kenya-nyeri — and a design that called for attributes and inventory the backend didn't carry yet. The temptation there is to fake it: fill the grid with fake cards, wire up filters that don't filter, and hope nobody clicks. That collapses the first time a real user clicks a control that does nothing.
We took the opposite approach — ship what's real as real, and mark everything else as visibly provisional. Three decisions carried the release.
\n\nTwo filters are backed by actual product data and genuinely narrow the grid: Roast level and Price. The other three — Type, Grind size, Taste notes — are in the design, but there's no data behind them yet. So they render as UI, but the filtering logic simply doesn't consult them. That decision is one comment and one return in the catalog page:
\n
![\"Brewly](\"https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdrive.google.com%2Fuc%3Fid%3D1BwxEvRc0olq0Tyl_RNz8M_pgLrvQAL5R%26export%3Ddownload\")
const filteredProducts = computed(() =>\n allProducts.value.filter(product => {\n const roastMatch =\n filters.value.roast.length === 0 || filters.value.roast.includes(product.roastKey)\n const priceMatch =\n filters.value.price.length === 0 ||\n filters.value.price.some(band => matchesPriceBand(product.basePrice, band))\n\n // Type / Grind / Taste are visual-only until the backend exposes that data.\n return roastMatch && priceMatch\n })\n)\nActive filters show up as removable chips with a \"Clear all\" reset — but only Roast and Price ever change the result set, so those are the only two that can actually strand you in an empty grid. When the backend grows a type facet, it joins the return line; nothing else moves.
To make an early catalog feel populated without lying about inventory, the grid mixes the four real products with clearly-separated demo fillers. Their whole reason for existing is written on the type in data/products.ts:
\n
/**\n * Placeholder catalog fillers used only to populate the 3-column shop grid and\n * pagination until the backend `GET /products` endpoint exists. These reuse the\n * four real product photos and carry hard-coded (non-i18n) proper names, since\n * they are demo SKUs, not real inventory. They are excluded from PDP linking.\n */\nexport type DemoProductEntry = { /* ... */ }\nThe two lists are merged in one composable, with the demo entries flagged so nothing downstream can mistake one for the other:
\n
export function useCatalogCards() {\n const realCards = useProductCards()\n\n return computed<ProductCardItem[]>(() => {\n const demoCards = demoCatalog.map(entry => ({ /* ...entry */ isDemo: true }))\n return [...realCards.value, ...demoCards] // real first, fillers after\n })\n}\nAnd the flag is load-bearing in exactly one place that matters — the card's link. A demo card renders identically but has no navigation overlay, so it can never route to a product page that doesn't exist:
\n
<NuxtLink\n v-if=\"!product.soldOut && !product.isDemo\"\n :to=\"productTo\"\n class=\"absolute inset-0 z-[1]\"\n/>\nThis keeps the mechanics — sorting, pagination, layout — testable end-to-end today, while the real catalog fills in behind them. (The same guard keeps the prerender crawler from ever hitting a non-existent PDP.)
\n\nThere's no cart or checkout backend yet — our Pinia app store literally has no cart state in it. Rather than hide the primary call-to-action until it's fully wired, \"Add to Cart\" ships as an optimistic, visual-only interaction: it flips a label to \"Added to cart\" for 1.6 seconds and does nothing else.
\n
function handleAddToCart() {\n if (p.value.soldOut) return\n\n addedFlash.value = true\n clearTimeout(addedTimeout)\n addedTimeout = setTimeout(() => {\n addedFlash.value = false\n }, 1600)\n}\nIt's honest — it does exactly what it appears to do, no more — and it lets us validate the button's placement, states, and copy now. Swapping this stub for a real cart store action later touches one function, not the whole PDP.
\n\nMeanwhile the parts that are wired are fully real. The price genuinely reacts to the size selection, because the weight options carry a multiplier:
\n
export const productWeightOptions = [\n { label: '250g', multiplier: 1 },\n { label: '1000g', multiplier: 3.4 }\n]\n\nconst unitPrice = computed(() => {\n const option =\n productWeightOptions.find(o => o.label === selectedWeight.value) ?? productWeightOptions[0]!\n return Math.round(p.value.basePrice * option.multiplier)\n})\nSame for the quantity stepper and the total. If a control moves a number, that number is real; if a control is decorative, it's decorative all the way down. No half-wired middle ground.
\n\nThe taste scores (Bitterness / Sweetness / Acidity) aren't stars — they're little coffee beans, drawn as inline SVG with a gradient fill so they read as beans, not dots, at their 22px size. Each instance mints unique gradient ids so several ratings on one page don't collide on the same <defs>. It's a tiny component, but it's the kind of detail that makes a storefront feel considered rather than assembled.
Being explicit about the edges is part of the same discipline:
\n\nNaming these keeps the release legible: the working parts are trustworthy, and the gaps are known rather than accidental.
\n\nreturn (or a single isDemo flag), turning a feature on is a one-liner instead of an archaeology project.A full catalog and PDP, shipped on top of a data model that's still filling in — not by faking the missing half, but by drawing a clear line between what's real and what's coming.
\n\n\n\n\nI'm Alex — a DevOps engineer building Brewly Store, a coffee e-commerce platform that runs entirely on Cloudflare's edge (Workers, D1, Pages). I write about edge architecture, shipping discipline, and the debugging stories that come with production.
\n\nHow do you handle shipping UI ahead of the backend? Tell me in the comments.
","score":3},{"source":"https://dev.to/feed/tag/vue","sourceHost":"dev.to","title":"Supercharge Your Mobile Development with HY-APP: A Modern Vue 3 & TypeScript UI Component Library","link":"https://dev.to/hy-app/supercharge-your-mobile-development-with-hy-app-a-modern-vue-3-typescript-ui-component-library-3i66","pubDate":"Tue, 21 Jul 2026 08:54:18 +0000","description":"Introduction
\nWhen building cross-platform mobile applications, having a reliable, high-performance, and developer-friendly UI component library is essential. If you are developing with Vue 3 and TypeScript, you want tools that offer robust type safety, reactive performance, and sleek, modern design elements out of the box.
Enter Hy-App feature-rich mobile UI component library built specifically for Vue 3 and TypeScript.
\n\nWhy Choose Hy-App?
\nBuilt for Vue 3: Leverages the Composition API for cleaner, more maintainable, and reusable code logic.
TypeScript Support: Delivers full type definitions out of the box, enhancing your IDE's autocomplete and catching errors early in development.
\n\nMobile-Optimized: Designed with performance and touch-interaction in mind, ensuring smooth animations and transitions on mobile viewports.
\n\nDeveloper Friendly: Simple integration and comprehensive components help you drastically reduce boilerplate code and speed up time-to-market.
\n\nCore Features at a Glance
\nRich Component Ecosystem: Includes essential mobile navigation bars, buttons, list views, popups, form inputs, and feedback components.
Modern Aesthetics: Clean, minimalist UI styles that fit contemporary design standards and can be easily customized.
\n\nSeamless Cross-Platform Scaling: Tailored to perform seamlessly in mobile web and multi-platform deployment environments.
\n\nGetting Started
\nTo explore the official documentation, component playgrounds, installation guides, and interactive code examples, check out the official website:
👉 https://www.hy-design-uni.top/
\n\nConclusion
\nWhether you are spinning up a brand-new MVP or scaling an existing enterprise mobile app, Hy-App streamlines your workflow by combining the cutting-edge power of Vue 3 and TypeScript with production-ready mobile components.
Head over to the official website today to dive into the docs and start building faster!
","score":3},{"source":"https://javascriptweekly.com/rss","sourceHost":"javascriptweekly.com","title":"The coding challenge you don't want to pass","link":"https://javascriptweekly.com/issues/795","pubDate":"Tue, 21 Jul 2026 00:00:00 +0000","description":"| \n \n \n
|
Celebrating $100 million contributed by the community to the people who build and sustain open source every day.
\nThe post $100 million for open source: A milestone built by the community appeared first on The GitHub Blog.
","score":4},{"source":"https://dev.to/feed/tag/vue","sourceHost":"dev.to","title":"Why Your JavaScript Runs in the Wrong Order","link":"https://dev.to/mrajaeim/why-your-javascript-runs-in-the-wrong-order-2fki","pubDate":"Sun, 19 Jul 2026 16:30:00 +0000","description":"Copy this into your browser console:
\n
![](\"https://res.cloudinary.com/cpress/image/upload/w_1280,e_sharpen:60,q_auto/xqczohnqoev2kuyybhmk.jpg\")
![](\"https://res.cloudinary.com/cpress/image/upload/c_limit,w_480,h_480,q_auto/copm/5f351a17.png\")
![](\"https://res.cloudinary.com/cpress/image/upload/w_1280,e_sharpen:60,q_auto/y1sie2zdhnhjtqtnvwcy.jpg\")
![](\"https://res.cloudinary.com/cpress/image/upload/w_1280,e_sharpen:60,q_auto/hd77f7jirzohktslvrxp.jpg\")
![](\"https://res.cloudinary.com/cpress/image/upload/w_1280,e_sharpen:60,q_auto/p3bbkhfkz0skzmdw1wmj.jpg\")
console.log('1');\nsetTimeout(() => console.log('2'), 0);\nPromise.resolve().then(() => console.log('3'));\nconsole.log('4');\nYou probably expect: 1, 2, 3, 4.
You get: 1, 4, 3, 2.
Nothing is broken. JavaScript is doing exactly what it was designed to do. The confusing part is that the language looks like it runs top to bottom, but it does not always work that way.
\n\nIn this article you will learn three ideas that explain almost every async surprise in JavaScript:
\n\nNo prior knowledge of the event loop required. We will build the mental model step by step.
\n\n\n\n\nMost of us learn JavaScript like this: the engine reads your file line by line and runs each line in order.
\n\nThat mental model works fine for code like this:
\n
function greet() {\n console.log('hello');\n}\ngreet();\nconsole.log('bye');\nOutput: hello, then bye. Easy.
Then we add setTimeout, Promises, and async/await. The same mental model breaks.
You are debugging a feature. You sprinkle console.log calls to trace the flow. The logs come back in an order that makes no sense.
Or you build a search box. Each keystroke fires a fetch. Sometimes an older response overwrites a newer one. The bug feels random.
\n\nOr you use async/await thinking the UI will stay responsive, but a heavy loop after an await still freezes the page.
These are not separate mysteries. They all come from the same root cause: JavaScript can only run one piece of code at a time, but it still needs to handle waiting.
\n\n\n\n\nThink of the call stack as JavaScript's to-do list for right now. It is a Last-In, First-Out (LIFO) structure: the newest call sits on top and is the only thing that runs.
\n\nWhen your code calls a function, that function goes on top of the stack. When the function finishes, it comes off. The engine always works on whatever is on top.
\n
function c() { console.log('c'); }\nfunction b() { c(); }\nfunction a() { b(); }\n\na();\nWhile c runs, the stack looks like this:
\n
┌─────────┐\n│ c() │ ← running now\n├─────────┤\n│ b() │\n├─────────┤\n│ a() │\n└─────────┘\n CALL STACK\nRules of the call stack:
\n\nThat last rule is the key to everything that follows.
\n\nSay you write this:
\n
const data = fetch('/api/user'); // network request\nconsole.log(data);\nIf JavaScript actually stopped and waited for the network, your entire page would freeze. No clicks. No scrolling. No animations.
\n\nSo the engine does something smarter. It starts the fetch, then moves on to the next line. When the network responds later, a callback runs.
\n\nThat \"run later\" part is handled outside the call stack, by the event loop.
\n\nPart 1 showed what runs right now (the call stack).
\n\nPart 2 showed that fetch and setTimeout cannot block the stack while they wait.
So where does that waiting work go? And when does the \"run later\" code actually execute?
\n\nThat is what the event loop handles. It is the coordinator that lets single-threaded JavaScript stay non-blocking: slow work (network, timers, I/O) is handed to the browser or Node.js, and the loop decides when their callbacks get a turn on the call stack.
\n\nFour structures share the job. Think of them as one runtime, not four separate engines:
\n
+-------------------------------------------------------------+\n| Browser / Node.js |\n| |\n| +-------------------+ +-------------------+ |\n| | Call Stack | | Web / Node APIs | |\n| | (synchronous) | | (timers, fetch…) | |\n| +---------+---------+ +---------+---------+ |\n| ^ | |\n| | pushes work | finishes |\n| | onto the stack v |\n| +-------+-------+ +---------+---------+ |\n| | Event Loop | | Microtask Queue | |\n| | (coordinator) |<--------------+ (Promises, await) | |\n| +---------------+ drains +---------+---------+ |\n| before ^ |\n| the next | |\n| +---------+---------+ |\n| | Macrotask Queue | |\n| | (setTimeout, DOM) | |\n| +-------------------+ |\n+-------------------------------------------------------------+\n| Piece | \nRole in one sentence | \n
|---|---|
| Call stack | \nLIFO stack of the function that is running right now. Frames go on when called, off when finished. | \n
| Web / Node APIs | \nWork the runtime owns outside your JS thread: timers, fetch, DOM events, and similar I/O. | \n
| Microtask queue | \nHigh-priority FIFO line for Promise callbacks (.then / .catch / .finally), await continuations, and queueMicrotask(). | \n
| Macrotask queue | \nLower-priority FIFO line for timer callbacks, many I/O callbacks, and UI events. Often called the task / callback queue. | \n
The event loop itself is not a background thread. It is the rulebook that moves work between these pieces.
\n\nImagine a cashier (the call stack) who can only help one customer at a time.
\n\nsetTimeout and fetch are like customers who step aside and wait for a text message (\"your order is ready\") — that waiting happens in the Web / Node APIs.Those two waiting lists are the important part. JavaScript does not use one generic \"later\" queue. It uses two, with a strict priority order.
\n\n| Waiting list | \nPlain name | \nWhat goes here | \nExamples | \n
|---|---|---|---|
| Microtask queue | \nthe Promise line | \ncallbacks that should run soon | \n\n.then(), await continuations, queueMicrotask()\n | \n
| Macrotask queue | \nthe timer/event line | \ncallbacks that can wait a bit longer | \n\nsetTimeout, clicks, network I/O callbacks | \n
Think of it like airport boarding:
\n\nsetTimeout, UI events)The engine follows one continuous checklist:
\n
1. Run synchronous code until the call stack is empty\n2. Hand async APIs (setTimeout, fetch, …) to Web / Node APIs and keep going\n3. When background work finishes, drop its callback into the microtask\n or macrotask queue (depending on the API)\n4. With an empty stack, drain EVERY microtask — including ones spawned\n by other microtasks\n5. Take exactly ONE macrotask, push it onto the call stack, and run it\n6. Go back to step 4\nOne sentence version: sync first, then all Promises, then one timer/event, then repeat.
\n\nThat \"every microtask\" step matters. If a Promise callback schedules another Promise callback, the new one still runs before any macrotask. A busy microtask chain can delay timers and UI events.
\n\n![\"call](\"https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fk35ljx55fb658rw3qy1h.png\")
setTimeout and fetch fit\nWhen you call setTimeout or fetch, the engine does not run your callback immediately. It hands the waiting job to the browser (or Node.js). That happens outside the call stack.
\n
Your JS code Browser / Node (outside the stack)\n───────────── ──────────────────────────────────\nsetTimeout(fn, 0) ────────► timer starts...\nfetch('/api') ────────► network request starts...\n (your code keeps running)\n ...time passes...\ntimer fires ◄──────── puts fn in the timer/event line\nresponse arrives ◄──────── puts .then callback in the Promise line\n![\"Browser](\"https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fpd3q4rfjzww0jenvmkkh.png\")
Your callback only runs when the event loop picks it from a waiting list and puts it back on the call stack.
\n\nHere is the snippet again:
\n
console.log('1');\nsetTimeout(() => console.log('2'), 0);\nPromise.resolve().then(() => console.log('3'));\nconsole.log('4');\nStep 1: synchronous code (call stack)
\n\n| Line | \nWhat happens | \nPrinted so far | \n
|---|---|---|
console.log('1') | \nruns immediately | \n1 | \n
setTimeout(...) | \nbrowser starts a timer; when it fires, the callback waits in the timer/event line\n | \n1 | \n
Promise.then(...) | \ncallback waits in the Promise line\n | \n1 | \n
console.log('4') | \nruns immediately | \n\n1, 4\n | \n
Call stack is now empty. Synchronous work is done.
\n\nStep 2: Promise line (microtasks)
\n\nThe engine drains the microtask queue completely before touching timers:
\n\n| What runs | \nPrinted so far | \n
|---|---|
console.log('3') | \n\n1, 4, 3\n | \n
Step 3: timer/event line (one macrotask)
\n\nNow the loop takes exactly one macrotask — the setTimeout callback:
| What runs | \nPrinted so far | \n
|---|---|
console.log('2') | \n\n1, 4, 3, 2\n | \n
Final answer: 1, 4, 3, 2
Why that order sticks:
\n\n1 and 4 are pure sync work on the call stack, so they print first.setTimeout(..., 0) registers a timer right away; when it expires, the callback lands in the macrotask queue — not on the stack.3 prints before 2.3 beats 2 because Promise callbacks always run before setTimeout callbacks, even when the timer is set to 0.
\n\n\nSync code first. Then all Promises. Then one timer or event. Then repeat.
\n
![\"The](\"https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fst3izq7adbcost8fb122.png\")
If you remember that, the opening example stops feeling random.
\n\nasync/await actually does\nasync/await is just Promise syntax. It does not pause the entire program.
\n
async function load() {\n console.log('A');\n await fetch('/api/user');\n console.log('B');\n}\n\nconsole.log('1');\nload();\nconsole.log('2');\nWhat happens:
\n\n1 prints (sync)load() starts, A prints (sync)await hits the network and steps out of the function2 prints (sync) because the stack is freeB prints (microtask)Output: 1, A, 2, B
The code after await does not run when the network finishes inside your function like a blocking pause. It gets scheduled as a microtask for later.
You do not need tools to predict small examples. Label each line, then follow the event loop rules.
\n\nTake our opening snippet:
\n
console.log('1'); // SYNC\nsetTimeout(() => console.log('2'), 0); // schedules MACROTASK\nPromise.resolve().then(() => console.log('3')); // schedules MICROTASK\nconsole.log('4'); // SYNC\nNow walk through it.
\n\nRound 1: synchronous code
\n\n| Step | \nCall stack | \nConsole output | \n
|---|---|---|
console.log('1') | \n[log] | \n1 | \n
setTimeout(...) | \n[setTimeout] | \n(schedules 2 for later) | \n
Promise.then(...) | \n[then] | \n(schedules 3 for later) | \n
console.log('4') | \n[log] | \n4 | \n
| Stack empty | \n[] | \n\n |
Round 2: microtasks
\n\nThe Promise callback runs:
\n\n| Console output | \n
|---|
3 | \n
Round 3: one macrotask
\n\nThe setTimeout callback runs:
| Console output | \n
|---|
2 | \n
Final output: 1, 4, 3, 2
That is the full manual process. For any small snippet:
\n\nOpen Chrome DevTools, go to Sources, and set a breakpoint inside a .then() callback. When execution pauses, look at the Call Stack panel on the right. It shows exactly which functions are active.
For log-order bugs, numbered labels help:
\n
console.log('[sync] user clicked');\nI use this in code reviews all the time. It is simple and it works.
\n\n\n\n\nTracing by hand is great for interview questions and 5-line snippets. It gets painful in real apps.
\n\nsetTimeout, Promises, and await in ways that are hard to trackKnowing the rules is not the same as writing code that survives fast user input and slow networks. That is where patterns help.
\n\n\n\n\nInstead of tracing every line in your head, write code that matches how the runtime works.
\n\nRule 1: Keep synchronous blocks short.
\n\nLong loops on the main thread block everything, even after an await. If work is heavy, break it into chunks or move it to a Web Worker.
Rule 2: Use async/await to sequence steps in one flow.
When step B needs the result of step A, await is the right tool. It keeps the logic readable.
Rule 3: Guard against out-of-order async results.
\n\nWhen the user can trigger the same async action multiple times (search, pagination, tab switches), ignore or cancel stale results.
\n\nThese three rules fix most production async bugs I have seen.
\n\n\n\n\nHere is a before/after for a search box. This is the full example we will break down.
\n\nBefore (buggy):
\n
searchInput.addEventListener('input', async (event) => {\n const query = event.target.value;\n\n const response = await fetch(`/api/search?q=${query}`);\n const data = await response.json();\n\n renderResults(data); // may render stale data\n});\nAfter (fixed):
\n
let activeController = null;\n\nsearchInput.addEventListener('input', async (event) => {\n const query = event.target.value;\n\n // Cancel the previous in-flight request\n if (activeController) {\n activeController.abort();\n }\n\n activeController = new AbortController();\n\n try {\n const response = await fetch(\n `/api/search?q=${encodeURIComponent(query)}`,\n { signal: activeController.signal }\n );\n const data = await response.json();\n renderResults(data);\n } catch (error) {\n if (error.name === 'AbortError') {\n return; // a newer search started, ignore this one\n }\n showError(error);\n }\n});\nEach keystroke starts a fetch. All requests run at the same time. Whichever response arrives last wins, not whichever query is current.
\n\nIf the user types react quickly, the response for re might arrive after react. The UI shows results for re. That looks like async code is \"random.\" It is not. The event loop is working fine. The code just never checks whether the result is still relevant.
activeController\nA variable that holds the current AbortController. Think of it as a remote control for the in-flight fetch.
When the user types a new character, we abort the old request before starting a new one.
\n\nAbortController and signal\nfetch accepts a signal option. When you call controller.abort(), the in-flight fetch rejects with an AbortError.
This is better than ignoring stale results silently. It actually cancels work you no longer need.
\n\ntry/catch block\nNot every aborted request is an error worth showing. AbortError means \"a newer search replaced this one.\" We return early and do nothing.
Real errors (network down, 500 response) still go to showError.
Let us trace the fixed search box when a user types r, then re.
r\nSYNC: input handler runs\nSYNC: abort() called (nothing to abort yet)\nSYNC: fetch('/api/search?q=r') starts (network waits in background)\nSYNC: handler returns, stack is empty\n...later...\nMICRO: await continuation runs, renderResults for \"r\"\nre (before r responds)\nSYNC: input handler runs\nSYNC: abort() cancels the \"r\" request\nSYNC: fetch('/api/search?q=re') starts\nSYNC: handler returns\nMICRO: \"r\" fetch rejects with AbortError → catch block returns early\n...later...\nMICRO: \"re\" fetch resolves → renderResults for \"re\"\nThe UI always shows results for the latest query. No race condition.
\n\nPaste this in your console and watch it run:
\n
console.log('1');\nsetTimeout(() => console.log('2'), 0);\nPromise.resolve().then(() => console.log('3'));\nconsole.log('4');\n| Phase | \nWhat runs | \nOutput so far | \n
|---|---|---|
| Sync | \n\n1, 4\n | \n\n1, 4\n | \n
| Microtasks | \nPromise callback | \n\n1, 4, 3\n | \n
| Macrotask | \nsetTimeout callback | \n\n1, 4, 3, 2\n | \n
Once you have done this two or three times, the order stops feeling random.
\n\n\n\n\nJavaScript has one main thread for your page script. A long sync job — resizing a huge image in a loop, parsing a massive JSON blob, or an accidental infinite loop — never leaves the call stack. While that frame is stuck, the event loop cannot drain microtasks or macrotasks. Clicks queue up. Animations stall. The tab looks dead even though \"async\" APIs are still waiting in the background.
\n\nThat is why heavy CPU work belongs in chunks or in a Web Worker, not in a tight loop after an await.
setTimeout(fn, 1000) does not promise that fn runs at the one-second mark. It means: after at least 1000ms, the callback may enter the macrotask queue. If the stack is busy, or microtasks keep spawning, the callback waits longer. Treat the delay as a floor, not a schedule.
setTimeout(fn, 0) does not mean \"run immediately after sync code\"\nIt means \"schedule a macrotask.\" Promise callbacks still run first. If you need to defer work to after the current synchronous block but before timers, use queueMicrotask() instead.
await does not run fetches in parallel\nThis is sequential (B waits for A):
\n
const a = await fetch('/a');\nconst b = await fetch('/b');\nThis runs both at once:
\n
const [a, b] = await Promise.all([\n fetch('/a'),\n fetch('/b'),\n]);\nawait still blocks the UI\nasync function heavy() {\n await fetch('/data');\n for (let i = 0; i < 1_000_000_000; i++) {} // blocks clicks and scrolling\n}\nawait only yields before the loop, not during it.
In Node, process.nextTick() runs even before microtasks. Browser code rarely needs this, but Node tutorials lean on it. Node's loop is also organized into phases (timers, I/O, check, close, and so on). The browser-friendly story in this article still holds for most app code; when you debug server timers and nextTick ordering, read the Node event loop guide.
React 18 batches state updates differently than React 17. If your logs inside useEffect do not match a bare-bones example, the framework may be batching work. Always test in your real setup.
Reach for this mental model when:
\n\nsetTimeout, Promise, and queueMicrotask\nThis alone is not enough when:
\n\nOn a team, it helps to agree on one pattern for canceling stale fetches (AbortController is a good default) and to ask in review: \"what happens if the user triggers this twice before the first call finishes?\"
JavaScript runs synchronous code on the call stack first. When the stack is empty, the event loop drains every microtask (Promises, await), then runs one macrotask (setTimeout, events), and repeats.
That single rule explains why 1, 4, 3, 2 is the correct output for our opening example. It also explains why search boxes need cancellation logic, and why async/await alone does not keep the UI smooth during heavy loops.
You do not need to memorize every edge case. Remember the big picture: sync first, then microtasks, then one macrotask. Everything else is a variation on that.
\n\nnextTick differ from the browser storyIf you want a follow-up deep dive, the natural next stops are: how async/await maps onto that visual timeline, how to hunt a specific out-of-order race, or how Node's phases differ when you leave the browser.
What was the first async bug that made you stop and question how JavaScript actually works?
","score":5},{"source":"https://nuxt.com/blog/rss.xml","sourceHost":"nuxt.com","title":"Nuxt 4.5","link":"https://nuxt.com/blog/v4-5","pubDate":"Sat, 18 Jul 2026 00:00:00 GMT","description":"Nuxt 4.5 is our biggest release in a while. Vite 8, Rspack 2 powered by Rsbuild, experimental SSR streaming, a stable error code system, a new useLayout composable, named views, and a lot of groundwork for Nuxt 5.","score":5},{"source":"https://github.blog/feed","sourceHost":"github.blog","title":"The cost of saying yes has changed","link":"https://github.blog/engineering/the-cost-of-saying-yes-has-changed/","pubDate":"Fri, 17 Jul 2026 16:46:47 +0000","description":"The cost of writing code dropped; the cost of owning it didn't. A framework for deciding which changes are actually cheap in the AI era.
\nThe post The cost of saying yes has changed appeared first on The GitHub Blog.
","score":4},{"source":"https://blog.risingstack.com/rss/","sourceHost":"blog.risingstack.com","title":"GPT-Red: OpenAI Is Training Models to Break Other Models","link":"https://blog.risingstack.com/gpt-red-openai-self-improving-ai-security/","pubDate":"Thu, 16 Jul 2026 13:05:35 +0000","description":"Prompt injection is still one of the least comfortable problems in AI development. You can improve your system prompt, restrict tools, validate outputs, and add approval steps before sensitive actions. Still, the model eventually has to read data you do not control. It might browse a webpage, process an email, inspect a repository, or use […]
\nThe post GPT-Red: OpenAI Is Training Models to Break Other Models appeared first on RisingStack Engineering.
","score":4}]}