标签：#ev

Dyson’s new stick vacuum can vacuum and mop in a single cordless device—if you’re willing to really splurge.

Remix 3 is a full-stack web framework that moves away from React, focusing on web platform primitives. It integrates routes, request handlers, and UI components into a single structure, utilizing a forked Preact for the frontend. Unlike previous versions, it emphasizes server ownership of the request lifecycle. Migration from Remix 2 is not straightforward, as it requires changes to existing apps. By Daniel Curtis

We kicked off DEV's Big Summer Bug Smash on July 14, and I've been waiting to write this post since...

Uber's "Zero Growth Stack" focuses on scalable infrastructure that separates capacity growth from business demand, reducing hardware needs while enhancing service scaling. Central to this is garbage collection optimisation. Additionally, generative AI is integrated into development, elevating developer productivity while introducing cost management measures to maintain economic efficiency. By Olimpiu Pop

I was showing ChefExtract to some friends when it started returning error 404 for specific operations linked to AI. After some embarrassment, I went home to figure out the problem: The model I used for those specific operations had been deprecated. And just like that, my app was failing. But I learned my lesson: relying entirely on one API creates a single point of failure (not rocket science). The easiest fallback mechanism would be to rely on a backup model. But these increase maintenance, and it doesn’t scale well. A better fix relies on AI gateways. What is an AI gateway? An AI gateway is a middleware layer that sits between your application and the LLM providers. Instead of your code calling OpenAI or Anthropic directly, it calls the gateway, and the gateway forwards the request. Concretely, a gateway buys you four things: One API for many providers. Write your code once, switch between GPT, Claude, Gemini, or a local model without rewriting anything. Automatic failover. If your primary provider fails or deprecates your model (as it happened to me), requests reroute to a backup. Users never see a 404. Cost control and caching. Budgets, rate limits, and cached responses for repeated queries, enforced in one place instead of scattered across your codebase. This is especially useful when relying on models from different providers. Observability. Every request is logged, timed, and priced, so “why is our AI bill so high?” becomes a query instead of an investigation. Once again, this is especially useful when dealing with multiple models from different providers. This is exactly what my app needed. Failover alone would have turned my deprecated-model incident into a non-event. Enter Bifrost There are many AI gateways, but eventually I explored one called Bifrost because it is open source and you can see how it operates under the hood. Bifrost is an open-source AI gateway built by Maxim AI and written in Go. Bifrost bridges your app to more than 20 providers: OpenAI,

Performance optimization in React is often surrounded by myths. Developers routinely wrap every single component in React.memo , wrap every function in useCallback , and wonder why their application is still sluggish or memory-heavy. Premature optimization can actually degrade app performance and clutter your codebase. To build fast React applications, you need techniques that address actual bottlenecks: unnecessary re-renders, unoptimized state placement, oversized bundles, and main-thread blocking. Here are five practical React performance optimization techniques that deliver measurable results in production. 1. Push State Down (Fix Rerender Cascades) Before reaching for useMemo or React.memo , evaluate your state placement . When state lives too high up in the component tree, every state update forces the entire sub-tree to re-render. ❌ The Anti-Pattern: State at the Root // Changing `color` forces <HeavyChartComponent/> and <ComplexTable/> to re-render! export default function App () { const [ color , setColor ] = useState ( ' #6366f1 ' ); return ( < div > < input type = "color" value = { color } onChange = { ( e ) => setColor ( e . target . value ) } /> < p style = { { color } } > Sample Text </ p > < HeavyChartComponent /> < ComplexTable /> </ div > ); } ✅ The Fix: Component Isolation Move the isolated state and its control into its own dedicated child component: Javascript function ColorPicker () { const [ color , setColor ] = useState ( ' #6366f1 ' ); return ( < div > < input type = "color" value = { color } onChange = { ( e ) => setColor ( e . target . value ) } /> < p style = { { color } } > Sample Text </ p > </ div > ); } export default function App () { return ( < div > < ColorPicker /> { /* These components are no longer impacted by color state changes */ } < HeavyChartComponent /> < ComplexTable /> </ div > ); } 2. Pass Components as Children (Component Composition) Sometimes state must remain in a parent component, but you don't want child components

I have been building VoxelDraft , a voxel editor that runs entirely in the browser without an account or installation. The editor supports block painting, layers, keyframe animation, GIF recording, local projects, and exports for OBJ/MTL, GLB, VOX, Minecraft Schematic, and Roblox RBXL. This post covers the architecture choices that kept those features manageable. Keep edit data serializable The editable model is an array of plain voxel records rather than a collection of Three.js objects: type VoxelData = { position : [ number , number , number ] color : string layerId ?: string } That decision makes JSON backups, local persistence, undo/redo snapshots, sharing, and format conversion much simpler. Three.js objects are derived render state, not the source of truth. Render repeated cubes with InstancedMesh Creating one mesh and one React component per cube becomes expensive as a model grows. VoxelDraft uses THREE.InstancedMesh where geometry and material can be shared. Each voxel contributes a transform matrix. Pointer intersections return the instanced mesh and instance ID, which can be mapped back to the editable voxel record. There are tradeoffs. Per-voxel colors need instance colors or grouping by material, and changing a single block still requires carefully updating the instance buffers. The reduction in draw calls is worth that complexity. Make exporters independent from UI The format exporters accept voxel records and produce a Blob . The UI is only responsible for validation and triggering a download. const blob = exportToVOX ( voxels ) const url = URL . createObjectURL ( blob ) VOX, Minecraft Schematic, and RBXL are generated directly. For GLB, the app builds a temporary Three.js scene and sends it to GLTFExporter from three-stdlib . Keeping binary generation separate from React event handlers makes exporters easier to test and reuse. Move GIF encoding off the main thread VoxelDraft records both animation output and modeling timelapses. GIF encoding can easi

Building a modern Customer Relationship Management (CRM) platform requires more than just displaying raw database records. Users expect interactive analytics, clear data visualization, responsive layouts, and lightning-fast UI updates . In this guide, we'll walk through architecting a sleek, responsive CRM analytics dashboard using React , Tailwind CSS , and Recharts . 1. Dashboard Architecture & Component Hierarchy To keep our CRM modular and easy to maintain, we break down the UI into specialized components: src/ ├── components/ │ ├── layout/ │ │ ├── Sidebar.jsx │ │ └── Header.jsx │ ├── dashboard/ │ │ ├── MetricCard.jsx │ │ ├── RevenueChart.jsx │ │ └── RecentDealsTable.jsx └── pages/ └── Dashboard.jsx 2. Key Performance Metric Cards KPI cards sit at the top of the dashboard to give team leaders instant insight into active pipeline value, customer acquisition, and conversion rates. Here is a clean, reusable MetricCard component built with Tailwind CSS: import React from ' react ' ; import { TrendingUp , TrendingDown } from ' lucide-react ' ; export const MetricCard = ({ title , value , change , isPositive , icon : Icon }) => { return ( < div className = "bg-white dark:bg-slate-900 p-6 rounded-2xl border border-slate-200 dark:border-slate-800 shadow-sm transition-all hover:shadow-md" > < div className = "flex items-center justify-between" > < span className = "text-sm font-medium text-slate-500 dark:text-slate-400" > { title } </ span > < div className = "p-2.5 rounded-xl bg-indigo-50 text-indigo-600 dark:bg-indigo-950/50 dark:text-indigo-400" > < Icon className = "w-5 h-5" /> </ div > </ div > < div className = "mt-4 flex items-baseline justify-between" > < h3 className = "text-2xl font-bold text-slate-900 dark:text-white" > { value } </ h3 > < span className = { `inline-flex items-center text-xs font-semibold px-2 py-0.5 rounded-full ${ isPositive ? ' bg-emerald-50 text-emerald-600 dark:bg-emerald-950/50 dark:text-emerald-400 ' : ' bg-rose-50 text-rose-600 dark:bg

One word broke into a private repository this month. Not a zero-day. Not stolen credentials. Not...

Neander has no exceptions. No try , no catch , no finally . A call to one of the host application's APIs returns something closer to Rust's Result : either the answer, or the reason there is no answer. In place of a catch block there is one type marker, three operators, and a guarantee that every submission comes back in the same shape no matter what happened. Last time the foundational series closed with isolation. This is the first of two encores, and it takes the subject that came up in nearly every entry without ever being laid out in full: what happens when something goes wrong. There are two answers, because there are two audiences. An error is a value while the program runs, and a verdict once it has stopped. The two are made of the same parts, on purpose. The failable type Every call returns a failable type, written T! . It carries either a value of type T or an error with a code, a message, and the name of the function that produced it. T! is the mirror of the nullable type T? . Same shape, different question: one asks whether a value is there at all, the other asks whether obtaining it worked. The mirroring runs deeper than the notation, because the same three operators serve both types. A failure gets no unwrapping vocabulary of its own. Those three are =? , ?? and is : // narrow, or throw the error out of the enclosing block let order : Order =? call orders .get ( id : 42 ) // or substitute a default let order : Order = call orders .get ( id : 42 ) ?? emptyOrder // or inspect it and decide let result : Order! = call orders .get ( id : 42 ) if result is error { if errorCode ( result ) != 404 { throw result } return emptyOrder } A standalone call statement, one without a let , narrows implicitly: the error is thrown and the success value is discarded. One property does the heavy lifting throughout the rest of this post: T! originates only from a call . No expression picks up a ! along the way, and no widening rule introduces one. The marker means exactly o

I never set out to build VentureTwin AI as just another chatbot. The idea was much bigger than answering questions. I wanted to build a digital twin that could understand a student's entire journey—their projects, certifications, technical skills, academics, achievements, and career interests—and use all of that to provide meaningful career guidance. Instead of simply recommending jobs based on keywords or certificate counts, I wanted the system to answer a much harder question: What is this student actually good at, and where are they most likely to succeed? To make that possible, I designed the platform as a collection of independent intelligence modules. The Certificate Intelligence module retrieved and verified certifications. Resume Intelligence evaluated technical skills and experience. Project Intelligence analyzed project metadata such as technology stack, complexity, implementation, and impact. Each module produced its own output, which was then passed to a scoring engine that generated a Career Readiness Score. Individually, every module worked exactly as expected. Then I compared two student profiles. The first student had completed more than 20 online certifications but had only a couple of basic projects. The second student had fewer certifications, but had built full-stack applications, worked with AI models, contributed to open-source projects, and actively participated in hackathons and technical competitions. I expected the second profile to receive stronger recommendations. It didn't. Instead, the student with the larger collection of certificates consistently received the higher Career Readiness Score. At first, I assumed something was broken. I traced every stage of the scoring pipeline, inspected API responses from every module, verified the PostgreSQL records, and even recalculated the scores manually. Every value matched. Every API response was correct. The database contained exactly what it should. The scoring engine was behaving exactly as I

Originally published on 2022-07-04. Published on July 3rd, 2022 We have a ll been there.. We all have that long list of unfinished side projects that we hope to complete some day.. If you're anything like me, that 'some day' is always eluding you and never getting here.. Ripping up the bandaid Today I have decided to finally go ahead and finish one of my long list of unfinished tutorial projects. I recently read a long Twitter thread that gave me a lot of food for thought. To paraphrase my understanding of one tweet, 'success is a combination of all the small wins'. Therefore, by finishing and publishing one unfinished project today, I set myself up to finishing another one tomorrow. Small, consistent gains I just need to make it a habit of finishing what I have started so that they do not get out of hands. After all, my Github account has about 126 repositories, but my portfolio website only has a dozen completed and published projects. Almost Done I have finished up the tutorial project. My next step is to rebuild the project from scratch without the handholding of the tutorial. One of the mental blocks that prevented me from finishing up the project in the first place seems insignificant now. Next time that mental block tries me, I will be better prepared! The project we're talking about! Published Link: https://blockchain.tioye.dev

I Built Flowstate Because We Somehow Made Productivity More Complicated Than The Actual Work Live: https://flowstate.chromitedev.xyz/ GitHub: https://github.com/ChromiteDev/flowstate We have a strange problem. Humans built some of the most advanced technology in history. We created: Computers that fit in our pockets Instant communication across the planet Machines that explore space Software that can do incredible things And somehow... We still struggle with: "What should I actually focus on today?" That is the problem I wanted to solve. So I built Flowstate . The productivity paradox We have never had more productivity tools. Seriously. Think about it. There are apps for: Tasks Notes Calendars Habits Goals Projects Time tracking Team management There is probably an app to help you organize the apps that organize your life. At some point we stopped being productive and started managing productivity. The funniest part? Sometimes creating the perfect productivity system becomes the biggest productivity project. You spend two hours making a beautiful workspace... Then realize: You have done absolutely nothing. A masterpiece of organization. Zero progress. The moment I realized something was wrong I noticed a pattern. People were not struggling because they were lazy. They were struggling because their attention was constantly being divided. Every day we fight: Notifications Endless information Too many choices Too many responsibilities Too many things competing for our attention The internet gave us unlimited access to information. But our attention? That is still limited. The question behind Flowstate I kept coming back to one question: "What actually deserves my attention right now?" Not: "What are all the possible things I could do?" Not: "How can I create the most complicated workflow imaginable?" Not: "Should I reorganize my folders for the fifth time?" (We have all been there.) The goal was simple: Create a tool that helps people find clarity. Introducing Flowsta

May 2026 There's a touchscreen mounted in my kitchen — I call it the WallScreen. It runs recipes, the chore board, a calendar, the usual smart-home clutter. One day I decided it should also pull in free over-the-air television. No subscription, no streaming app, just the local broadcast towers that have been beaming HD into the air for free this whole time. I had a Raspberry Pi 5, a $30 USB tuner, and what I assumed would be a boring afternoon. It was not a boring afternoon. The tuner that didn't want to work The tuner I grabbed was a MyGica A681 — a tidy little USB TV stick. Plug it into Windows, install the bundled software, done. Plug it into a Raspberry Pi running a current Linux kernel and you get… nothing. The computer notices a device is there and otherwise shrugs. Here's why, in two sentences: Linux has no built-in driver for the chips inside this particular stick. The manufacturer's driver only works on regular PC processors — and even then, only as a sealed, prebuilt file with no source code. A Raspberry Pi uses a different kind of chip entirely, so that driver is a non-starter. That's the whole problem. The hardware is great. It's just that on a Pi, this tuner is a paperweight — and you can't buy or download your way out of it. The only way out was to write the driver myself. What writing the driver actually involved A USB TV tuner isn't one chip — it's a little team of them working together. One chip is the "translator" that lets the computer talk to the device over USB. Another tunes to a channel, like turning a radio dial. A third converts the broadcast signal into video data the computer can use. The good news: for the parts that handle tuning and decoding the signal, I was able to build on existing open-source work from the broader Linux TV community — code other people had already written and shared for the chips inside this stick. (It's all credited in the project.) The missing piece — the part nobody had written — was the translator layer : the co

Every form I ever shipped before React 19 needed the same three pieces of state, and I wired them up...

With plenty of range and stellar ride quality, the new C-Class is a brilliant EV with a dashboard that's a little too in your face.

TL;DR Modern web applications change constantly. Components are re-rendered, generated...

I have been building an open source tool called Agentic Ledger and it just reached the point where I need more eyes on it than my own. This post is an introduction and an ask. The problem AI agents run unattended. They call LLMs in loops, use tools, spawn sub-agents, and spend real money, and most of that happens where you cannot see it. When an overnight coding loop burns $40 getting stuck on the same failing test, or a multi-agent crew quietly retries itself into a huge bill, you usually find out from the invoice. The observability tools that exist mostly want you to instrument your code with an SDK, and each one speaks one framework. I wanted the opposite: something that watches everything, requires changing nothing, and keeps the data on my machine. What it is Agentic Ledger is a transparent proxy that sits between your agent and the LLM provider. You point your agent's base_url at it, and it records every request and response, assigns each call an action id, works out what it cost, and passes the response through untouched. Your agent never knows it is there. Your Agent -> Agentic Ledger Proxy -> OpenAI / Anthropic / any gateway | SQLite or Postgres | Live dashboard + API No SDK, no decorators, no monkey patching. It works with any framework and any provider because it operates at the only layer they all share: the HTTP call. Everything is local-first. Your prompts stay in a SQLite file on your machine (or your own Postgres). MIT licensed. Try it in two minutes pip install -U agentic-ledger AGENTICLEDGER_UPSTREAM_URL = https://api.openai.com python -m agenticledger.proxy Or with Docker (multi-arch, non-root, Sigstore-signed): docker run -p 8000:8000 \ -e AGENTICLEDGER_UPSTREAM_URL = https://api.openai.com \ -v $( pwd ) /data:/data \ ghcr.io/shekharbhardwaj/agentic-ledger:latest Then point your agent at it: client = OpenAI ( base_url = " http://localhost:8000/v1 " , default_headers = { " x-agenticledger-session-id " : " run-1 " }, ) For coding agents like Claude

We've all had the same experience. You ask your coding agent to integrate with a new platform. It confidently writes code. It references endpoints that don't exist anymore. It misses required headers. It mixes API versions. It hallucinates authentication flows. None of this is surprising. Large language models don't "know" an API. They know about an API from their training data. Even when you hand them documentation, they're still trying to reconstruct a mental model from hundreds or thousands of pages of text. The problem isn't writing code. It's building context. Understanding an API is still mostly manual Every integration starts the same way. Read the authentication docs. Figure out the important entities. Learn the object relationships. Understand the common workflows. Find the endpoints that matter. Jump between documentation tabs for an hour. Only then do you actually start building. Ironically, AI made writing code dramatically faster while leaving this entire process mostly unchanged. Documentation wasn't designed for AI Most documentation is optimized for humans. OpenAPI specifications are optimized for machines. Neither tells the complete story on its own. The spec explains what exists. The documentation explains why it exists. Neither builds a coherent mental model. I wanted a better starting point That's why I built Scout. Scout takes an OpenAPI specification and the accompanying documentation, then synthesizes them into a grounded understanding of the platform. Instead of asking: "Can Claude figure this out?" The workflow becomes: import the API crawl the documentation build an understanding ask questions against grounded context generate integration code expose the same understanding to coding agents through MCP Everything runs locally. No hosted backend. No accounts. No telemetry. The interesting part isn't the AI The AI chat isn't the product. The generated code isn't the product. The MCP server isn't even the product. The product is the context tho

When an application starts using more than one language model provider, the hard part is rarely the first API call. The hard part is everything that follows: separate credentials, different request shapes, provider-specific errors, billing dashboards, and model migrations scattered across the codebase. A useful way to reduce that surface area is to keep one OpenAI-compatible client contract and move provider choice into configuration. This guide shows the smallest working setup with Routara , plus the production checks I recommend before sending real traffic. 1. Keep the SDK, change the endpoint If your project already uses the OpenAI Python SDK, the client initialization is the only part that needs to change: import os from openai import OpenAI client = OpenAI ( api_key = os . environ [ " ROUTARA_API_KEY " ], base_url = " https://api.routara.ai/v1 " , ) response = client . chat . completions . create ( model = " deepseek-chat " , messages = [ { " role " : " user " , " content " : " Explain idempotency in two sentences. " } ], ) print ( response . choices [ 0 ]. message . content ) Store the key in an environment variable. Do not put it in browser code, a public repository, screenshots, or support messages. The same pattern works in Node.js: import OpenAI from " openai " ; const client = new OpenAI ({ apiKey : process . env . ROUTARA_API_KEY , baseURL : " https://api.routara.ai/v1 " , }); const result = await client . chat . completions . create ({ model : " deepseek-chat " , messages : [{ role : " user " , content : " Return one short test sentence. " }], }); console . log ( result . choices [ 0 ]. message . content ); 2. Treat model IDs as configuration Do not spread model names throughout the application. Put them in environment variables or a typed configuration object: model_id = os . environ . get ( " ROUTARA_MODEL " , " deepseek-chat " ) That makes model evaluation and rollback much safer. Routara's live model catalog is the source of truth for current availa