标签：#m

Ben Greene discusses how software engineers can adapt and thrive in an era of rapid AI code automation. Drawing on his startup experience, he explains key mindsets like starting simple, maintaining code comprehension, attacking hard problems first, and focusing on customer impact. He shares why human empathy, agency, and practical problem-solving remain irreplaceable when code is automated. By Ben Greene

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

Governments are switching, but I’m not sure it makes a difference : …some municipalities, including Denver, Colorado, are ditching their Flock arrays. But keep in mind that if they’re only switching from Flock to another brand of license-plate readers, like Axon, it’s like a gambling addict trying to kick the habit by switching from FanDuel to DraftKings. […] Despite what you may read on the Flock website, Axon cameras are pretty effective when it comes to hoovering up personal details that can go far beyond your license plate numbers. That means a municipality that opts for Axon cameras instead of Flock units won’t necessarily reduce the amount privacy its citizens lose through their use...

A scraping job usually fails in boring ways: the browser hangs, a selector starts returning empty strings, a login expires, or the target site returns a captcha halfway through the run. The awkward part is that many platforms still bill you for the work done before the failure. If you run enough jobs, that difference shows up both in your invoice and in the amount of defensive code you need around the scraper. Billing by compute time changes how you build A lot of scraping platforms charge for runtime. Apify, for example, uses compute units: memory multiplied by time. A browser-heavy actor running for ten minutes with 2 GB of RAM consumes roughly a third of a compute unit before any actor-specific result fees. That model is reasonable from the provider side. Chromium processes are expensive. Proxies cost money. Retries use resources. But as the caller, you care about a different unit: did I get the rows I needed? The hard part is that runtime billing makes cost hard to know before execution. A job that normally takes 30 seconds might take 8 minutes when a site slows down. A job that returns malformed data can still count as successful from the platform's point of view. A job that fails after rendering 200 pages still consumed browser time. If your pipeline runs once a day, that may be fine. If it runs continuously, you probably want a local cost model that tracks outcomes, not just requests. type ScrapeRun = { jobId : string ; target : string ; startedAt : string ; finishedAt ?: string ; status : " queued " | " running " | " succeeded " | " failed " ; rowsExpected ?: number ; rowsReceived ?: number ; billedUnits ?: number ; }; function isUsefulResult ( run : ScrapeRun ) { if ( run . status !== " succeeded " ) return false ; if ( run . rowsExpected && ( run . rowsReceived ?? 0 ) < run . rowsExpected * 0.9 ) { return false ; } return ( run . rowsReceived ?? 0 ) > 0 ; } function costPerUsefulRow ( run : ScrapeRun ) { if ( ! isUsefulResult ( run )) return Infinity ; ret

Every tool in the East Africa coordination infrastructure stack started from the same scaffold. Here's exactly how to build and publish one yourself. What You're Building An MCP server is a Python package that exposes tools to AI assistants. When a user installs it and connects it to Claude, the AI can call your tools as naturally as answering a question. pip install your-mcp-server # Then Claude can: # "Check NHIF coverage for outpatient surgery" → calls your tool → returns structured result Step 1: Set Up the Project (2 min) your-mcp-server/ ├── src/ │ └── your_package/ │ ├── __init__.py │ └── main.py ├── pyproject.toml ├── README.md └── .github/ └── workflows/ └── publish.yml mkdir your-mcp-server && cd your-mcp-server mkdir -p src/your_package touch src/your_package/__init__.py src/your_package/main.py Step 2: Write Your Tool (10 min) # src/your_package/main.py from __future__ import annotations from typing import Annotated from fastmcp import FastMCP mcp = FastMCP ( name = " your-mcp-server " , instructions = " Describe what your server does in one paragraph. " , ) @mcp.tool ( description = ( " What this tool does in plain language. " " Include the Western parallel if applicable. " " Note if it uses DEMO data. " ) ) def your_tool ( param1 : Annotated [ str , " Description of param1 " ], param2 : Annotated [ int , " Description of param2 " ] = 0 , ) -> dict : # Your logic here return { " result " : f " Processed { param1 } " , " note " : " DEMO — replace with real data source in production " , " source " : " your-mcp-server " , } def main (): mcp . run () if __name__ == " __main__ " : main () Step 3: Configure pyproject.toml (3 min) [build-system] requires = ["setuptools> = 61.0 "] build-backend = "setuptools.build_meta" # ← exact string, no variation [project] name = "your-mcp-server" version = "0.1.0" description = "One-line description" authors = [{name = "Your Name" , email = "you@example.com" }] license = { text = "MIT" } readme = "README.md" requires-pytho

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

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

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

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…

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

Scientists have long assumed that there’s an upper limit to the intensity of the solar winds that reach Earth. New research suggests there’s not—and the implications are alarming.

A payroll and HR software team rebuilt three monoliths into over 120 smaller services over five years, with no dedicated migration budget. Every new feature was built as its own service instead of changing the old ones. The article covers the pull-based migration, the tools that made this possible, how costs were kept down, and the problems the team ran into along the way. By Prashanth Pasham

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

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

AWS released a public preview of the GuardDuty investigation agent, which correlates findings, 90-day activity logs, and resource topologies into structured reports with risk ratings, confidence scores, and MITRE ATT&CK classification. It is reachable through the AWS MCP Server, so investigations can run from agentic tooling. Preview quotas cap usage at 10 investigations per account per day. By Steef-Jan Wiggers

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