I’ve released Cross Post for Dev.to , a WordPress plugin that mirrors a post to Dev.to the moment you publish it on your own site. The plugin itself is simple: one hook, one API call, one published mirror. The interesting part of this release isn’t the feature. It’s what had to be true for a zero-dependency plugin to stay trustworthy over time without me babysitting it. The problem Most small WordPress plugins rot over time. They’re built against whatever WordPress version happens to be current, they lean on a third-party library or two to save time, and neither the plugin nor the library gets revisited until something breaks. Usually a major WordPress release, sometimes a PHP version bump. At that point the maintainer generally abandons the project and so many of these lesser used plugins become useless for users. Cross-Post for Dev.to needed to cross-post reliably from WordPress to Dev.to without letting that happen so easily. No bundled third-party SDKs, no external service sitting between the plugin and the Dev.to API, no dependency that could go unmaintained while the plugin using it kept shipping. Why zero-dependency isn’t the whole answer Removing dependencies fixes one kind of rot but not the other. A plugin with no third-party packages can still quietly break against a new WordPress release; deprecated hooks, changed REST behaviour, PHP version drift. Zero dependencies means less that can fail underneath you; it says nothing about whether the plugin still works today. Those are two different guarantees, and conflating them is how “lightweight” plugins end up just as unmaintained as heavy ones, only with fewer visible warning signs. So the actual problem wasn’t “avoid dependencies.” It was “know, continuously and automatically, whether this plugin still works”. Which is a validation problem, not a packaging problem. The validation loop Two layers of the same idea, one local and one continuous. Locally , a pre-push hook runs before any commit leaves my machin

LangGraph isn't cheaper than LangChain — unless you opt out of its defaults Cost-audit series, episode 4. This series began with an AI agent that burned 136M tokens overnight → . When LangChain deprecated ConversationBufferMemory (the subject of episode 1 in this series), the official migration path was LangGraph. The pitch: explicit state management, you control exactly what flows where. More expressive, more controllable. It is — but only if you reach for the controls. The default state model in LangGraph has the same unbounded-growth problem as the memory it replaced. Teams migrating to escape ConversationBufferMemory's cost curve often land on an identical curve, with new graph complexity on top. This audit shows exactly where the default grows, what it costs, and what opt-outs exist. The default: MessagesState + add_messages The quickstart in LangGraph's own docs uses this pattern: from langgraph.graph import StateGraph , MessagesState def my_node ( state : MessagesState ): messages = state [ " messages " ] response = llm . invoke ( messages ) # sends ALL messages to the LLM return { " messages " : [ response ]} graph = StateGraph ( MessagesState ) graph . add_node ( " agent " , my_node ) MessagesState is a TypedDict with a single key, messages , backed by the add_messages reducer. Here's what that reducer does: # langgraph/graph/message.py — add_messages (def at line 18; merge loop below) def add_messages ( left : Messages , right : Messages ) -> Messages : # ... (coerces left/right to lists of BaseMessage) ... left_idx_by_id = { m . id : i for i , m in enumerate ( left )} merged = left . copy () ids_to_remove = set () for m in right : if ( existing_idx : = left_idx_by_id . get ( m . id )) is not None : if isinstance ( m , RemoveMessage ): ids_to_remove . add ( m . id ) else : merged [ existing_idx ] = m # same id → update in place else : merged . append ( m ) # new id → APPEND (the list grows) merged = [ m for m in merged if m . id not in ids_to_remove ] retu

If you run more than a handful of OpenTelemetry Collectors, you already know the pain: a config change means SSHing into boxes, redeploying DaemonSets, or babysitting a Git pipeline per cluster, and you never quite trust that every agent is running the config you think it is. OpAMP fixes exactly that. It is a protocol that lets a central server push configuration to a fleet of Collectors, watch their health, and roll changes out in stages, without you touching each host. This post walks through how OpAMP works, the two ways a Collector can speak it, and the config you need to wire one up. The problem OpAMP solves A single Collector is easy. A hundred of them, spread across clusters, VMs, and edge nodes, is a fleet-management problem that has nothing to do with telemetry itself. Every observability team eventually builds some version of the same thing: a way to ship a new pipeline config, confirm it actually applied, and back it out when a processor starts dropping spans. Without a management protocol you end up gluing that together from ConfigMaps, Ansible runs, and dashboards that only tell you an agent is alive, not what config it is actually running. Config drift creeps in. One node keeps an old sampling rate for months because its rollout quietly failed and nobody noticed. OpAMP, the Open Agent Management Protocol, is the OpenTelemetry answer to this. Splunk donated it to the project in 2022, and it has since become the standard control channel for the Collector. It is worth pairing with a clear-eyed view of what a Collector actually is versus lighter agents; the OpenTelemetry Collector vs Grafana Alloy comparison covers that trade-off if you are still choosing a data plane. What OpAMP actually is OpAMP is a client/server network protocol for remote management of large fleets of data-collection agents. It is transport-flexible: agents connect to the server over either plain HTTP or a WebSocket, and the WebSocket path gives you a persistent bidirectional channel

We're Byte Me , a software agency from Alkmaar, the Netherlands. The most valuable advice we give clients is usually not "Let's build something new"; it's "Let's not touch the thing that works." Here's why and how. The rebuild reflex Every company running a 15-year-old ERP has had this meeting. Someone opens the ancient interface on the big screen, everyone groans, and a decision crystallizes: "We need to replace this." We understand the reflex. The UI looks like Windows XP. The one person who understands the database retired. Adding a field takes a change request and three weeks. Every new hire asks why orders live in a system older than they are. And yet, when companies come to us with "We want to replace our legacy system," our first answer is almost always: you probably don't. Not because rebuilds are impossible but because the odds are terrible. Big-bang legacy replacements are among the highest-risk projects in software. They take longer than planned, cost more than planned, and the scariest part isn't the code: it's the twenty years of business rules buried in that old system that nobody documented. The weird discount logic for that one big customer. The field that means something different depending on which decade the record was created in. The nightly job everyone forgets exists until you turn it off. That old system isn't just software. It's your company's institutional memory, compiled. Ugly ≠ broken Here's the reframe that changes these conversations: most legacy systems don't have a functionality problem. They have an access problem. The ERP still processes orders correctly. It's been doing so, reliably, for fifteen years, a track record your rebuild won't have on day one. What's actually painful: Customers can't see their own orders, so they email and call Sales can't check stock from the road Data has to be retyped into the accounting tool, the webshop, the planning board Reporting means exporting to Excel and praying None of those problems require r

I gave Claude one prompt. Claude wrote a web page and published it. The page is live at a permanent URL. I did not open a dashboard. I did not run a build. This article shows the full procedure. You can complete it in less than five minutes. Disclosure: I run Nippy , the hosting service in this article. What makes this possible MCP (Model Context Protocol) is an open standard. It lets an AI assistant call external tools. A tool can read data. A tool can also do work in the real world. Nippy is a static hosting service. You give it files. It gives you a live URL that does not expire. Nippy has an MCP server. When you connect it, Claude gets one new ability: it can publish websites. The result is a very short path from an idea to a live page: prompt → Claude writes the files → one tool call → live URL Set up the connector There are two paths. Use the one that matches your setup. Path A: claude.ai in the browser Open claude.ai. Go to Settings → Connectors . Add Nippy as a connector. Approve the connection. Path B: Claude Desktop, Claude Code or Cursor Run the MCP server with one command: npx nippy-mcp Add it to your client configuration. For Claude Desktop, the entry looks like this: { "mcpServers" : { "nippy" : { "command" : "npx" , "args" : [ "nippy-mcp" ] } } } Restart the client. The Nippy tools are now available. The Nippy help center has a full guide for each client. Publish a page Give Claude a prompt. This is the prompt I used: Make a small demo page and publish it with Nippy. Claude then does three things: Claude writes the HTML file. Claude calls the Nippy MCP server with the file. Nippy returns a live URL. The tool call is simple. This is its shape: { "name" : "published-by-claude" , "files" : [ { "path" : "index.html" , "content" : "<!DOCTYPE html>..." } ] } The response came back in a few seconds: { "url" : "https://published-by-claude.nippy.site" , "status" : "live" , "note" : "Live now. The link does not expire." } That page is real. Claude published it

⚡ What makes MoilStack .md different? 1. Bring Your Own AI (100% Local or Cloud) Connect any provider without vendor lock-in or middleman servers: Local & Offline: Direct integration with Ollama so your data never touches the internet. Cloud API Support: Works with OpenAI, Anthropic Claude, Google Gemini, Groq, Mistral AI, OpenRouter, Together AI, and Cerebras. Your API keys stay stored locally, and requests go straight from your machine to the provider. Zero telemetry, zero cloud accounts. 2. Native Inline AI Editing Forget copying and pasting between a chatbot window and your file. Highlight any section and ask the AI to rewrite, shorten, expand, or explain it. Edits stream directly into your document. 3. Safety Net: Reversible Edits & Auto Backups AI modifications shouldn't destroy your hard work: Instant Revert: Press Ctrl + Z to instantly undo any AI rewrite and restore your exact document state. Automatic Snapshots: MoilStack .md automatically creates a local snapshot before every AI action, keeping the last 10 versions per file in a local backup directory. 4. Focused Desktop Experience Minimalist UI: Clean writing view with toggle preview and right-click formatting — no clunky toolbars taking up screen space. Local Workspaces: Open any local folder as a workspace to create, rename, and edit .md files directly. One-Click PDF Export: Export your drafts into clean, beautifully formatted PDFs with standard margins and readable typography. Multi-Instance: Double-click any file in your file explorer or open multiple side-by-side windows independently. 🛠️ Tech Stack & Availability MoilStack .md is open source under the MIT License . Stack: Electron, Modern Web Technologies Platforms: Windows ( .exe / Microsoft Store) & Linux ( .deb / AppImage ) (macOS coming soon) 🚀 Check It Out 🌐 Website: moilstack.com/moilstack-md 🐙 GitHub: github.com/moilstack/moilstack-md 🛒 Microsoft Store: Available for Windows I'd love to hear your thoughts! What does your current Markdown set

I was tired of outdated UIs and performance of similar tools. Nor did I want to write ImageMagick scripts every time I needed to resize/convert/watermark a folder with a few thousand images. It's a native desktop app built with C++23, Skia for rendering, libvips for image processing and my own cross-platform UI toolkit - no Electron/Qt. It allows building reusable pipelines: resize, convert, compress, watermark, sharpen, blur, rotate, flip, rename, and metadata (EXIF/IPTC/XMP) editing, chained i

Modern electrical grids increasingly rely on distributed sensors installed across conductors, towers, poles, substations, and remote line sections. These devices can measure: Conductor temperature Current and voltage Mechanical tension Line sag Vibration Weather conditions Fault passage Switch and recloser states Collecting these measurements is relatively straightforward. Building a reliable data pipeline around them is much harder. Power infrastructure often operates in locations with unstable connectivity, limited bandwidth, and strict requirements for alarm delivery. A useful architecture must therefore do more than move telemetry from sensors to a cloud database. It must determine which data is urgent, validate measurements, preserve event order, survive network outages, and integrate the results with operational utility systems. This article explores how to design that pipeline. The Basic Architecture A practical grid-monitoring data flow may look like this: Field Sensors | v Protocol Adapters | v Edge Data Model | +----> Local Rules and Fault Detection | +----> Local Time-Series Buffer | +----> Event Queue | v Central IoT or Utility Platform | +----> SCADA +----> GIS +----> OMS +----> Analytics +----> Maintenance Systems The edge gateway sits between field equipment and central applications. Its job is not limited to protocol conversion. It also acts as a local data-processing and reliability layer. Why Cloud-Only Processing Is Risky Imagine a utility operating 5,000 field sensors. Each device reports one measurement every second. That produces: 5,000 measurements per second 300,000 measurements per minute 18,000,000 measurements per hour Most of those measurements will describe normal operating conditions. Sending every individual value to a central platform creates unnecessary: Bandwidth consumption Storage growth Processing overhead Communication costs Dependence on network availability More importantly, cloud-only logic can stop working when the connectio

Two years ago, we made a change that cut our deployment failures by 80%. It wasn't a fancy new architecture. It wasn't a microservices overhaul. It was a simple switch from npm install to npm ci --omit=dev in our production Docker containers. That single change saved us from 4 dependency-related incidents in the first year alone. Here's why it matters, how it works, and why your team should make the switch today. The Problem: npm install is a Liability in Production Let's be honest—npm install is great for local development. It's flexible, forgiving, and gets the job done. But in production? It's a ticking time bomb. Here's what can (and did) go wrong: The Package Lock That Wasn't npm install doesn't respect your package-lock.json the way you think it does. If your lock file is out of sync with your package.json, npm will update dependencies behind your back. We once had a patch release of a logging library introduce a breaking change that crashed our entire API fleet. The lock file said one version. The container installed another. The "It Works On My Machine" Nightmare Local installs, CI installs, and production installs can all yield different dependency trees. Different npm versions, different registry responses, different caching behavior—it's chaos. We spent 3 days debugging a staging vs. production discrepancy that turned out to be a transitive dependency with a slightly different semantic versioning resolution. The Time Tax npm install is slow. It checks versions, resolves conflicts, and installs development dependencies you'll never use in production. Every minute spent installing is a minute your deployment is vulnerable. The Solution: npm ci + --omit=dev The npm team gave us a production-ready alternative years ago, yet so many teams still sleep on it. What npm ci Does Strictly respects package-lock.json: If the lock file doesn't match package.json, npm throws an error and fails the build. No silent updates. Installs from the lock file only: It skips depe

Video streaming has become a normal part of everyday life. Whether you are watching a live sports event, attending an online class, listening to internet radio, or enjoying a movie on a streaming platform, a complex technology system is working behind the scenes to deliver content smoothly. Most viewers simply press Play and start watching. They do not see the technology that makes videos load quickly, reduce buffering, and automatically adjust quality when internet conditions change. One of the most important technologies behind modern streaming is HTTP Live Streaming (HLS) . HLS is a widely used video streaming protocol that delivers high-quality audio and video across different devices and network conditions. Instead of sending one large video file, HLS divides content into smaller pieces called media segments and delivers them continuously while the viewer watches. For example, when a video automatically changes from 1080p to 720p during a slow internet connection without stopping completely, that experience is powered by Adaptive Bitrate Streaming (ABR) , one of the main features of HLS. In this guide, you will learn: What HLS Streaming is How HTTP Live Streaming works Why Apple created the HLS protocol How M3U8 playlists control video delivery How media segments are created How Adaptive Bitrate Streaming improves playback Where HLS is commonly used How HLS compares with other streaming technologies Whether you are a beginner learning about video technology or a developer exploring streaming protocols, this guide explains HLS step by step. What Is HLS Streaming? HTTP Live Streaming (HLS) is a video streaming protocol created by Apple that delivers audio and video content through standard HTTP and HTTPS connections. Unlike traditional video downloads, HLS does not send a complete video file at once. Instead, it breaks the content into many smaller parts called media segments and sends them one by one while the viewer is watching. This approach provides several a

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

The opioid-like compound, which is found in kratom, can cause brutal withdrawal symptoms and will soon be a controlled substance. Some users tell WIRED it has relieved their pain and anxiety.

Lee, an engineer at Samsung’s semiconductor division, clocks out when his shift ends. He used to work longer hours, going the extra mile to excel at his projects. But lately, he’s been coming straight home to work on his job application for the chipmaker’s South Korean rival SK Hynix, sharing tips with his coworkers on…

Hugging Face is being used to make nonconsensual deepfakes, and the popular open-source AI model repository is doing very little to prevent it. That's according to a new report published by the European nonprofit AI Forensics, which found that seven out of the top nine image editing models hosted by Hugging Face readily complied with […]

ChatGPT has been refusing to imitate the writing of famous authors, both living and dead.