找到 9510 篇相关文章
It's been a good few weeks for games on rails. Nintendo's Star Fox remake wisely kept the tightly scripted, action-packed levels from Star Fox 64 largely the same, and they're still fun to fly through nearly 20 years later. Denshattack!, a new game from Undercoders, similarly features levels packed with carefully orchestrated sequences to great […]
Enjoy our weekend guide to the best indie games worth checking out.
Our remote team clocked serious hours walking, working, and sometimes jogging to find the best under-desk treadmills for home offices and small spaces.
If you prefer not to have cameras in and around your home, try one of these more private, WIRED-tested security devices.
Why some records should be created by your system, not your users, and how to do it safely in .NET. A support ticket lands on your desk: "The Teams page is empty. I added a member, but no team shows up." You check the API. It's behaving exactly as written: { "items" : [], "totalCount" : 0 } Nothing is broken. And that's the problem. The system is faithfully returning nothing, because the row that the page reads from was never created. Somewhere in your design, you assumed a human would create it first. This article is about a small, recurring design decision that quietly causes empty dashboards, confused users, and "is this a bug?" tickets: who is responsible for creating derived records the user, or the system? and how to let the system do it without introducing duplicate rows or race conditions. The problem Let's use a fictional product: a collaboration tool called Loop . In Loop, the important entities are: An Organization (a paying customer). A Member (a person invited into an organization under a plan). A Team a grouping that members belong to, keyed by (OrganizationId, PlanCode) . The admin dashboard lists Teams . Each team card shows a member count. Here's the catch in the original design: creating a Member wrote a member row. Creating a Team was a separate, manual step an admin was expected to do first. If an admin invited members without first creating the matching team, the dashboard showed nothing even though the members clearly existed. From the user's point of view, they did everything right. From the system's point of view, a required row simply didn't exist. Why it matters The Team record isn't independent information. It is fully derivable from the first member invited under a plan. When one entity's existence is implied by another, forcing a human to create it manually is a design smell. It leads to: Empty states that look like outages. Users can't tell "no data" from "misconfigured." Support load. Every skipped step becomes a ticket. Silent data dr
The Architectural Shift: Client-Side vs Server-Side For years, the standard for building modern React applications was the Single Page Application (SPA). Vite revolutionized this space by providing an incredibly fast developer experience (DX) and an optimized build process. However, as applications grow, many teams find themselves hitting the performance ceiling of client-side rendering. When we talk about migrating from a Vite-based SPA to Next.js, we aren't just changing build tools; we are moving from a model where the browser does all the work to a model where the server shares the load. In this article, we'll look at the benchmarks of a mid-sized e-commerce dashboard before and after migration. Understanding the Core Metrics To measure the impact truly, we focus on three Core Web Vitals: LCP (Largest Contentful Paint): How quickly the main content is visible. FID (First Input Delay): How responsive the page is to the first interaction. CLS (Cumulative Layout Shift): How stable the visual elements are during loading. Vite SPA Performance (The Baseline) In a Vite SPA, the initial HTML request returns a nearly empty <body> tag with a <script> bundle. The browser must: Download the HTML. Download the JavaScript bundle. Parse and execute the React code. Fetch data from an API. Finally, render the UI. Benchmark Results: LCP: 2.4s (on 4G connection) FID: 45ms TBT (Total Blocking Time): 320ms While the DX is lightning fast, the user experience suffers from the "white screen of death" during the initial bundle download. Next.js SSR/ISR Performance (The Post-Migration Result) Next.js changes this via Server-Side Rendering (SSR) or Incremental Static Regeneration (ISR). The server fetches data and pre-renders the HTML. The browser receives a fully formed UI immediately. Benchmark Results: LCP: 0.8s (on 4G connection) FID: 55ms TBT: 180ms There is a slight increase in FID because the browser's main thread is busy "hydrating" the static HTML into an interactive React app, b
This year’s World Cup has faced sweltering heat and humidity. Now it may need to deal with wildfire smoke.
Before a young Athenian took his full place in the city, he spent two years in the ephebeia. Training happened in the gymnasion, organized by tribe, the same tribes that would later send him to represent them in the Boule itself. Nobody handed him full standing first and hoped the judgment would follow. This should have been post seven. It’s showing up as sixteen because the gap only became visible once the room was real enough to test against. The Agora described what a Spec Session does. It never asked whether everyone walking into that room shares an accurate picture of what the agent can actually do. Most rooms don’t. Someone watched a demo and thinks the agent can do anything. Someone else got burned by a bad output three weeks ago and doesn’t trust it with anything real. Nobody’s intuition has been tested against the same tasks, and the spec that comes out of that room ends up too ambitious or too conservative depending on whose untested belief happened to speak first. That gap has a name in Athens. The gymnasion existed because nobody was handed a place in the city first and expected to develop judgment on the job. The ephebeia ran two years, training built around a specific fact. Physical readiness and civic judgment weren’t taught in separate places. They happened in the same space, under the same supervisors, organized by the same tribal groupings that would later structure how the city actually governed itself. The same word, gymnasion, ended up naming both the training ground for eighteen-year-olds and the buildings where Plato and Aristotle did their most serious thinking. Academy and Lyceum were gymnasia first. Nobody separated the trial from the reflection. The trial was how the reflection got earned. That’s the part worth taking seriously. Testing a tool and understanding a tool were never two different activities. The testing is how the understanding gets built. A team that reads documentation about what an agent can do has a description. A team tha
Week 0 of my DevOps Micro Internship was about the foundations—the parts of the internet you use every day without thinking about them. The exercise that made it click was a simple scenario: a friend launches an online bookstore called EpicReads, hosted on a server in Finland, and asks how people anywhere in the world can open it. The answer is a short chain of technologies working together. The Chain of Technologies Packet Switching: When someone opens the site, their request does not travel as one big lump. Packet switching breaks the data into small packets that each take the best available path across the network and get reassembled at the other end. This is what keeps the internet fast and resilient even across continents. IP Addresses & TCP/IP: Every device on the way has a unique IP address, like a postal address, so the user's computer and the Finland server can actually find each other. The TCP/IP suite runs the conversation: IP handles addressing and routing, while TCP makes sure the packets arrive complete and in the right order, asking again for anything that went missing. HTTP & HTTPS: On top of that sits HTTP and HTTPS, which define how the browser and server actually exchange the web pages. HTTPS adds encryption, so a customer's details and payment stay private. DNS: The last piece is DNS. Nobody wants to type an IP address, so DNS acts as the internet's phonebook, translating epicreads.com into the server's IP. To point a domain at an IPv4 address, you use an A record . The Biggest Takeaway The biggest lesson for me was not any single term. It was seeing how these layers hand off to each other so cleanly that the whole thing feels instant to a user. Understanding that chain is the groundwork for everything else in DevOps, because once you know how a request really travels, troubleshooting stops being guesswork. P.S. This post is part of the DevOps Micro Internship with Agentic AI Cohort 3 by Pravin Mishra. You can begin your DevOps journey by joining
Balmuda has engineered a remarkably pleasant breeze with its new NatureWind Studio, but is it worth hundreds more than its competition?
A subscription audit should survive contact with a real app. So I started with mine. TurnTalk is a live iOS travel translator with in-app purchases. I operate the app and its RevenueCat implementation. That makes it a useful public example, but not a customer case study. I will not claim a conversion lift I have not measured. Here is the first finding I would put at the top of its audit. Evidence: the store page introduces several different jobs The subtitle makes a focused promise: Understand Any Guide, Live But the first screenshot sequence spreads attention across: AI travel translation Voice translation Photo translation Instant translation Each feature may be useful. The issue is not feature quality. The issue is that a visitor has to decide which product TurnTalk is before deciding whether to download it. A traveler who wants to understand a live tour guide is evaluating a specific job. A visitor comparing general translator apps is evaluating a much broader category. Those users arrive with different intent. Why I would rank this before a paywall redesign The paywall cannot repair ambiguous acquisition intent. If the store page attracts people for four different jobs, aggregate trial and purchase rates become difficult to interpret. A low conversion rate could mean: The paywall is weak The first session does not prove the promised value The visitor downloaded for photo translation but reached a live-translation flow The listing attracted broad curiosity instead of durable travel intent Changing the paywall first would alter one screen while leaving those explanations mixed together. That is not a clean experiment. P0 action: make the first three screenshots tell one story I would test a narrower opening sequence: Situation: You joined a tour, but cannot understand the guide Mechanism: Put in your existing earphones and start live translation Outcome: Hear the guide in your language without staring at the screen Photo translation and secondary conversation mod
Hot take 👀 The hardest part of React isn't hooks. It's knowing how to structure an app so it stays maintainable as it grows. Clean architecture beats clever code every time. What's been the biggest challenge in your React projects?
DoltHub has recently released Dolt 2.0, a major update to the open source version-controlled SQL database. The latest major version adds automatic storage optimization, including garbage collection and compression, along with improved support for large and vector data types. By Renato Losio
A few months ago, I noticed something interesting about Bluesky. The people who were growing weren't necessarily posting the most brilliant content. They were simply consistent. They showed up every day, joined conversations, experimented with ideas, and stayed visible. I wanted to do the same. The problem was that I also had code to write, bugs to fix, blog posts to publish, and projects to maintain. Opening Bluesky every couple of hours just to post something or reply to notifications quickly became another distraction. I knew I needed automation. Not because I wanted to spam the platform, but because I wanted consistency without sacrificing my development time. The obvious solution would have been renting a VPS or deploying another cloud service. But honestly, I didn't want another monthly bill. I started asking myself a different question: Could I build a Bluesky AI bot that runs entirely on free services? That question eventually led me to GitHub Actions. Why GitHub Actions? Most automation tutorials immediately recommend a VPS, Docker container, or cloud function. Those work well. But for a personal automation project, they felt like overkill. GitHub Actions already gives developers something incredibly useful: Scheduled workflows Secure secret storage Python support Free minutes for public repositories Instead of paying for infrastructure, I could let GitHub execute my script several times a day. No servers. No maintenance. No SSH. No uptime monitoring. Just commit the code and let GitHub handle the rest. The Architecture The entire workflow is surprisingly small. GitHub Actions (Cron Schedule) │ ▼ Python Script │ Generates Prompt │ ▼ Gemini API │ Returns AI Post │ ▼ Bluesky API │ ▼ Publish Content Every scheduled run follows the same sequence. GitHub wakes up the workflow. The Python script builds a prompt. Gemini generates a post. The script authenticates using a Bluesky App Password. The post gets published automatically. After that, GitHub shuts everythin
Zero-Touch Customer Onboarding My AI agent hosting service has exactly zero manual steps between payment and deployment. Here is how: The Pipeline Customer pays via PayPal subscription Webhook fires to our server within seconds Python script validates the webhook signature Docker container spins up with Hermes Agent pre-installed API key generated via New-API Email sent to customer with credentials Customer logs in and starts using their agent Total time: ~90 seconds . No human touches anything. The Code Architecture PayPal Webhooks → Python Flask endpoint Docker API → Container creation with resource limits New-API → Token generation and quota management Gmail SMTP → Automated email delivery Caddy → Automatic HTTPS and routing Key Design Decisions Docker over VMs : Containers are faster (90s vs 5min) and cheaper. Each customer gets 0.5 CPU and 256MB RAM. New-API over custom billing : Battle-tested token management instead of rolling my own. AI over human support : The support agent is also AI. No humans in the loop at all. What Could Break PayPal webhook failures → Implement retry logic Docker daemon issues → Health checks and auto-restart Email deliverability → Fallback to backup SMTP The Result A customer can discover the site, pay, and have a working AI agent before their coffee gets cold. That is the power of full automation. Try it: AgentChip — $23.99/month, 100M API tokens included.
The Problem with GPT-4 Pricing When I started building my AI agent hosting service, I initially planned to use OpenAI GPT-4. Then I did the math: GPT-4: ~$30 per million tokens (input) + $60 per million (output) DeepSeek Flash: ~$0.14 per million tokens That is a 200x cost difference . But Is DeepSeek Good Enough? Short answer: for most use cases, yes. I ran both models side-by-side for customer support, content generation, and code assistance. DeepSeek Flash handled 90% of tasks just as well as GPT-4. The remaining 10% (complex reasoning, nuanced writing) barely mattered for my use case. The Cache Hit Rate Secret Here is what most people miss: DeepSeek caches repeated context. With a 90% cache hit rate, the effective cost drops to ~$0.014 per million tokens. That means 100 million tokens costs about $1.40. Let that sink in. Real Numbers from My Business 24.8 billion tokens processed Total cost: ~$20 Average: $0.008 per million tokens At this rate, I can offer 100M tokens/month for $23.99 and still have 89% margin. When to Use GPT-4 Instead Be honest with yourself: Complex multi-step reasoning? GPT-4 Creative writing with specific voice? GPT-4 Everything else? DeepSeek Flash is fine The Bottom Line Do not pay 200x more for marginal quality improvement. Use DeepSeek Flash for production workloads. Save GPT-4 for the rare cases that truly need it. I run AgentChip — managed AI agent hosting powered by DeepSeek. $23.99/month with 100M tokens included.
SEO Automation for Small Businesses Can Work — But Only If You Automate the Right Things Running a small business and keeping up with SEO at the same time is genuinely exhausting, and most owners either ignore SEO entirely or throw money at agencies that deliver reports without rankings. SEO automation for small businesses offers a middle path: systematic, repeatable processes that handle the mechanical parts of search optimization without requiring you to be an expert or hire one full-time. The short version — automating keyword tracking, technical audits, internal linking, and content scheduling will save you real time; automating content creation wholesale, without human review, will almost certainly hurt you. The rest of this article is about making that distinction practically useful. The Tasks That Actually Benefit From Automation Most of SEO is repetitive in ways that humans are bad at — checking 200 pages for broken links, making sure title tags aren't duplicated, tracking keyword rankings week over week. These are tasks where consistency matters more than judgment, which makes them exactly what automation tools are built for. A local landscaping company I know of was spending roughly 4-5 hours a week on manual rank checking across about 60 target keywords. After setting up automated tracking through a tool like Semrush or AccuRanker, that time dropped to under 30 minutes — just reviewing a dashboard. The monitoring didn't change their rankings, but it changed how quickly they spotted a drop and responded. That gap between noticing and acting is where small businesses tend to lose ground quietly. Technical SEO audits are another area where automation earns its keep. Tools like Screaming Frog or Sitebulb will crawl your site and surface issues — missing alt text, redirect chains, slow page load times — that you'd never catch manually unless you happened to stumble across them. According to a Semrush industry report, sites with automated audit schedules fix te
અમદાવાદમાં કાયદો અને વ્યવસ્થાના લીરેલીરા: ભાડજમાં શ્રીનિવાસ વણઝારાએ ખુલ્લેઆમ રિવોલ્વર લહેરાવી, લોકોમાં એટલો ખોફ કે કોઈ સાક્ષી આપવા કે સામે ઊભા રહેવા તૈયાર નથી! મધરાતે ધરપકડ બાદ રાતોરાત જામીન મળતા લોકોનો પોલીસ પરથી વિશ્વાસ ડગ્યો અમદાવાદ : શહેરમાં ગુનાખોરીની પ્રવૃત્તિઓ ડામવા માટે પોલીસ એક્શન મોડમાં હોવાના દાવાઓ વચ્ચે અમદાવાદના ભાડજ વિસ્તારમાંથી રૂવાડા ઊભા કરી દે તેવી ચોંકાવનારી ઘટના સામે આવી છે. મોડી રાત્રે 3 વાગ્યે શ્રીનિવાસ વણઝારાની સગીર મિત્ર સાથે અટકાયત અને ગણતરીના કલાકોમાં જ રાતોરાત પોલીસ સ્ટેશનથી મળેલા જામીન બાદ હવે આ કેસમાં વધુ એક ભયાનક વળાંક આવ્યો છે. ભાડજમાં ખુલ્લેઆમ રિવોલ્વર લહેરાવી મળતી માહિતી અને સૂત્રોના જણાવ્યા અનુસાર, જૂની અદાવતના મામલામાં શ્રીનિવાસ વણઝારાએ ભાડજ વિસ્તારમાં કાયદાનો કોઈ જ ડર રાખ્યા વિના ખુલ્લેઆમ પોતાની રિવોલ્વર લહેરાવી હતી. હાથમાં હથિયાર લઈને ફરતા અને રિવોલ્વર ફેરવતા શ્રીનિવાસ વણઝારાને જોઈને આસપાસના લોકોમાં ભારે નાસભાગ અને ફફડાટ મચી ગયો હતો. જાહેરમાં હથિયારના પ્રદર્શનથી આખા વિસ્તારમાં ગભરાટનો માહોલ છવાઈ ગયો હતો. લોકોમાં એટલો ડર કે કોઈ સાક્ષી આપવા તૈયાર નથી આ ઘટના બાદ ભાડજ વિસ્તારમાં રહેતા લોકોમાં શ્રીનિવાસ વણઝારાનો એટલો ભારે ખોફ બેસી ગયો છે કે કોઈ પણ વ્યક્તિ તેની સામે ઊભા રહીને સાક્ષી આપવા કે પોલીસને પુરાવા આપવા તૈયાર નથી. પોલીસ પૂછપરછમાં પણ સ્થાનિક લોકો ડરના માર્યા મૌન સેવી રહ્યા છે. "શ્રીનિવાસ વણઝારા જ ત્યાં હતા અને તેમણે જ રિવોલ્વરથી આતંક મચાવ્યો હતો" તેવી સાબિતી આપવા માટે વિસ્તારનો એક પણ વ્યક્તિ આગળ આવવાની હિંમત દાખવી રહ્યો નથી. સાક્ષીઓના અભાવે કેસ વધુ પેચીદો બની રહ્યો છે. પોલીસની કામગીરી અને જામીન પ્રક્રિયા પર સવાલો એક તરફ જૂની અદાવતમાં મારામારી અને ત્યારબાદ જાહેરમાં રિવોલ્વર સાથે ડર ફેલાવવાની ઘટના, અને બીજી તરફ 3 વાગ્યે થયેલી અટકાયત બાદ રાતોરાત પોલીસ સ્ટેશનમાંથી જામીન મળી જવા! આ સમગ્ર ઘટનાક્રમે પોલીસની કામગીરી સામે મોટા સવાલો ઊભા કર્યા છે. જ્યારે સામાન્ય જનતા સાક્ષી આપવા જ ડરી રહી હોય, ત્યારે કાયદાના રક્ષકો આ સમગ્ર મામલે કેવી રીતે દાખલો બેસાડશે તે એક મોટો પ્રશ્ન છે. હાલ તો ભાડજ વિસ્તારમાં ભારેલા અગ્નિ જેવી શાંતિ અને લોકોમાં ડરનો માહોલ સ્પષ્ટ જોવા મળી રહ્યો છે.
footnote-mcp is a Python MCP server installable via pip, Docker, or pipx. No API keys required — it falls back to scraped Bing + DuckDuckGo search and automatic headless Chromium for JavaScript-heavy pages. The Verification Pipeline The core tool is evidence_entailment . It takes a claim and a source text, and returns whether the claim is supported, unsupported, or contradicted. The heuristic backend extracts numeric and named-entity tokens from both the claim and source, then checks for exact matches and contradictions. On its design domain — numeric and factual data claims — it achieves 100% accuracy on a labeled benchmark set. For semantic cases (negation, paraphrase), the ollama backend uses a local LLM as a judge. Three tools build on this: corroborate_claim triangulates a claim across multiple sources, locate_claim_span finds the exact supporting sentence with character offsets, and build_research_debug_report produces a compact report of queries, URLs, and verification gaps. The Fetch Ladder web_read fetches pages through a 5-tier escalation ladder: HTTP (curl_cffi) to rotating proxy to headless Chromium to Chromium through proxy to hosted scrape API (Firecrawl/ScrapingBee). A block/quality detector decides when to escalate, and per-domain rate limiting, circuit breakers, and negative cache keep it polite. Search Backends web_search supports Tavily, Brave, Google, or scraped Bing + DuckDuckGo as fallback. Pass semantic: true to reorder results by meaning using local Ollama embeddings. Structured Data and Browser Tools Beyond text, the server handles tables, CSV/XLSX/PDF/JSON, date validation, unit resolution, and time series reconciliation. For JavaScript-heavy pages, 10 browser tools let you drive a headless Chromium session. When generic parsers fail, the server can synthesize sandboxed extraction code through a controlled recipe system. Benchmark Results The heuristic backend achieves 100% accuracy on numeric and factual data claims (n=15). Overall accurac
When I built the MCP server for this project — it combines GitHub and DEV.to into a set of tools an agent can call — I had a decision to make before writing a single tool: talk to the low-level MCP protocol directly, or use FastMCP 's decorator API. I've seen a few "your first MCP server" writeups lately walk through the low-level path because it's more "honest" about what MCP actually is under the hood — JSON-RPC over stdio, a capabilities handshake, typed request/response schemas. That's true, and it's a reasonable thing to want to understand. But I want to write about the other side: what it actually costs you in practice once you have more than one or two tools, because I went through both and the difference showed up fast. what the low-level path actually asks you to write Strip away the decorator and MCP is a JSON-RPC server. For every tool you add, you're responsible for: Registering the tool's name, description, and a JSON Schema for its inputs in a list_tools handler Writing a call_tool dispatcher that matches on tool name and unpacks arguments by hand Serializing the return value into the TextContent / ImageContent wrapper types MCP expects Keeping the schema you wrote in step 1 in sync with the arguments you actually read in step 2, by hand, forever None of that is hard in isolation. The problem is it's boilerplate that scales linearly with tool count and has zero connection to the actual logic of the tool. My server has 8 tools. Hand-rolled, that's 8 schema blocks plus a dispatcher if/elif chain plus 8 response-wrapping calls, all of which exist purely to satisfy the protocol, not to do anything a GitHub or DEV.to API call needs. what it looks like with FastMCP Here's an actual tool from server.py , unedited: @mcp.tool () def get_repo_stats ( repo : str ) -> dict : """ Get stars, forks, watchers, open issues for enjoykumawat/<repo>. """ r = _gh ( f " /repos/ { GITHUB_USERNAME } / { repo } " ) return { " name " : r [ " name " ], " stars " : r [ " stargaze