标签：#p

submitted by /u/Independent-Use-6761 [link] [留言]

Should you splurge on the new Series 11, or will the SE 3 do? Let us help you figure out which version to get (and which to avoid).

Let them pick out their own hiking boots. Instead, try gifting a useful blade or a nature journal to delight your outdoorsy friend.

Duplicate message processing is something every event-driven system eventually faces. With at-least-once delivery, retries and redeliveries are expected. The challenge is making sure processing the same message twice does not create side effects. I've been looking into the Inbox Pattern as a consumer-side solution: track processed messages keep message tracking and business changes in the same transaction scope the idempotency check per consumer One approach is using a MassTransit pipeline filter so the idempotency logic stays outside the consumers. How do you usually handle this? Do you use Inbox Pattern, custom middleware, database constraints, or something else? submitted by /u/DotDeveloper [link] [留言]

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...

Your Twitter bookmarks organized to make you read them Discussion | Link

In 2023, the Times sued OpenAI and Microsoft for copyright infringement. They’ve since spent more than $20 million on the case, and publisher A.G. Sulzberger has no plans to stop fighting it.

Free voice coding for Claude Code, Codex and more Discussion | Link

As it promised last year, Baidu has started testing its robotaxis in London along with partners Lyft and Freenow.

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

Anthropic and OpenAI employees are expected to give generously after their companies go public. “It’s going to be a wild ride,” says one nonprofit leader.

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

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