标签：#m

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

From how galaxies form to the beginnings of the universe, the images from the space telescope are giving cosmologists new data to explore—and theories to build out.

These portable vacuums make quick work of snack crumbs, tracked-in dirt, pet hair, and the mysterious debris beneath your seats.

As more big companies invest in glasses that record audio and video and pack AI on board, privacy concerns are only getting louder.

Hello Devs 👋 AI coding assistants have dramatically accelerated code generation. Whether you're using Cursor, GitHub Copilot, Claude Code, or Windsurf, writing code is faster than ever. The challenge is that code review hasn't improved at the same pace. Teams are shipping larger pull requests, reviewing more AI-generated code, and spending increasing amounts of time validating whether changes are actually correct, maintainable, and aligned with existing architecture. That's exactly why AI code review tools have become a key part of modern GitHub workflows. The problem is that not all AI review tools solve the same problem. Some generate pull request summaries. Some focus on security and compliance. Some extend traditional static analysis. Others attempt to understand repository-wide context and review changes the way an experienced teammate would. If you're evaluating AI code review tools for GitHub, here's a practical comparison of the most widely discussed options in 2026. ⚡ Quick Verdict Qodo stands out for teams that need automated pull request reviews with repository-wide context, not just diff analysis. The GitHub integration is straightforward, reviews run automatically on pull requests, and the platform focuses on understanding dependencies, related files, and existing code patterns across the repository. For small projects, lightweight review tools may be sufficient. For larger codebases, AI-generated code, and complex pull requests, context-aware review becomes significantly more valuable. What Makes a Good GitHub AI Review Tool? Before comparing tools, it's worth defining what actually matters. For most engineering teams, four factors determine whether an AI review tool provides real value. 1. Integration Reviews should appear where developers already work, directly inside GitHub pull requests. Nobody wants another dashboard, notification stream, or workflow to manage. 2. Review Quality Useful reviews surface meaningful issues, not just more comments. The

Welcome back to the React Mastery Series ! In the previous article, we explored Custom Hooks in React and learned how reusable logic helps developers build scalable and maintainable applications. Today, we will explore one of the most important concepts in modern frontend development: React Routing Almost every real-world React application contains multiple screens: Login Dashboard Profile Settings Reports Transactions Admin panels But React applications are usually built as: Single Page Applications (SPA) So how do we navigate between different pages without refreshing the browser? The answer is React Router What is Client-Side Routing? Traditional websites work like this: User Clicks Link | ↓ Browser Requests New HTML Page | ↓ Server Sends Page | ↓ Browser Reloads Every navigation causes a full page refresh. React Single Page Applications work differently: User Clicks Link | ↓ React Router Intercepts Request | ↓ URL Changes | ↓ React Loads Component | ↓ No Page Refresh This creates a smooth application experience. What is React Router? React Router is a library that enables navigation between different components based on the URL. Example: /login /dashboard /profile /settings Each URL maps to a React component. Example: /login | ↓ Login Component /dashboard | ↓ Dashboard Component Installing React Router For a React application: npm install react-router-dom The package provides: BrowserRouter Routes Route Link Navigate useNavigate useParams Setting Up BrowserRouter The first step is wrapping your application. Example: import { BrowserRouter } from " react-router-dom " ; import App from " ./App " ; ReactDOM . createRoot ( document . getElementById ( " root " )). render ( < BrowserRouter > < App /> </ BrowserRouter >, ); Now React can manage browser navigation. Creating Routes Routes define which component should display for a URL. Example: import { Routes , Route } from " react-router-dom " ; function App () { return ( < Routes > < Route path = "/" element = { < Ho

🕉️ Devlog — गुरु-दीक्षा: Teaching Karma Without Breaking Immersion "गुरु बिना ज्ञान नहीं।" Without a Guru, there is no knowledge. The Problem Moksha is a game rooted in Sanatan Shastra — Vedic Karma mechanics, Sanskrit concepts, rebirth cycles. It's intentionally deep. And that depth was quietly becoming its biggest barrier. New players would start the game and immediately face naama-jaap, vairaagya, prarabdha, chetana-jagriti — all at once, with no guidance. Within the first 30 seconds, most had no idea what they were doing or why. The game needed a tutorial. But it needed one that didn't betray what Moksha is. Why a Normal Tutorial Wouldn't Work The obvious solution — pause the game, show a tooltip, unpause — felt completely wrong for Moksha. Spiritually, a hard pause breaks the flow of consciousness. Mechanically, isPaused = true is deeply wired into audio ducking, gamepad state, and ambient layers. Hijacking it for tutorial logic would have introduced subtle bugs across every system. An earlier attempt at a tutorial (Issue #30) tried to live inside engine.js itself. That was worse — the engine is already the heaviest file in the codebase, and embedding tutorial step state there violated the entire modular architecture we'd been building toward. So I scrapped both approaches and started over. The Solution: गुरु-दीक्षा (Guru's Initiation) The new system is built around one philosophical reframe: a Guru doesn't stop the world to teach. They walk alongside you. This became the technical foundation too. A New Module — src/tutorial.js TutorialManager is a self-contained ES6 class. It doesn't import from engine.js or touch any game state directly. Instead, main.js passes it an engine state snapshot every frame via checkCompletion(state) . The tutorial reads — never writes. engine.js ──(no connection)──> tutorial.js main.js ──(snapshot feed)──> tutorial.js Zero coupling. Zero risk to existing systems. Slow Motion, Not Hard Pause When a tutorial card is visible, the game

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

When I published v2.0.0 , I thought the hard part was over. The CLI could turn Claude artifacts into native Windows applications in a single command. It worked on my machine, the demos looked great, and I was excited to share it. Then people started using it. That's when I realized the difference between building software and shipping software . The bugs only users can find Most of the problems weren't visible in a five-minute demo. Some applications worked perfectly. Others silently lost all of their data after being closed. Some builds succeeded exactly once. The second build failed unless the runtime cache was manually deleted. Everything looked correct... until someone actually tried using it. The rabbit hole What I thought would be a quick patch became a deep dive into things I'd never touched before. Over the course of v3 I ended up learning far more than I expected: Git branching and release workflows Semantic versioning GitHub Actions npm packaging npm pack Runtime integrity verification SHA-256 checksums Neutralino runtime management JavaScript debugging Integration testing None of those were part of the original project idea. Persistent storage finally works This was the biggest challenge. Artifacts using localStorage behaved differently depending on where they were running. Inside Claude everything worked. Inside the generated desktop application... not always. Tracking this down took far longer than writing the original feature. The result is that applications now persist their data correctly across launches without requiring any code changes. If your artifact uses localStorage , it should simply work. Runtime improvements The runtime layer also received a major overhaul. Version 3 now handles: automatic runtime downloads integrity verification cache recovery consecutive builds without manual cleanup Those aren't exciting features to demo, but they're exactly the kinds of improvements that make a tool feel dependable. Better testing I also spent a lot mo

How do you actually test an AI agent? Not "does it respond," but: does it route to the right tool, chain calls correctly, recover from failure, resist prompt injection, and stay within cost/latency budget? I spent weeks working through this on a running agent, and open-sourced the entire methodology — framework-agnostic , so it applies regardless of your language, runtime, or toolset. What's inside •⁠ ⁠ 61-source benchmark map — BFCL, GAIA, τ-bench, SWE-bench, WebArena, AgentDojo, LongMemEval and more, categorized by what they actually measure •⁠ ⁠ 58 universal test blocks across 7 tiers (L1–L4, Error Recovery, Multi-Turn, Security). Each block = a tool-agnostic capability definition + a concrete reference implementation •⁠ ⁠ Full OWASP Top 10 for Agentic Applications 2026 (ASI01–ASI10) mapped to 6 universal security test blocks •⁠ ⁠ Evaluation methodology — LLM-as-Judge biases, pass@k vs pass^k, trajectory vs end-state, observability (OpenTelemetry GenAI), automated red-teaming (garak, PyRIT, DeepTeam) •⁠ ⁠ Regulatory alignment — NIST AI RMF, MITRE ATLAS, EU AI Act, ISO/IEC 42001 How to use it Take Part II, replace the reference-implementation fields with your own agent's tool names and expected outputs. The universal capability definitions need no changes. Blank templates are included. PheronAgent (a macOS agent with 50+ native/MCP tools) is included as a real reference case study — but the methodology is the product, not the agent. No marketing narrative: ⁠ STORY.md ⁠ documents the real bugs, real test runs, and real corrections that shaped each version. Docs are CC BY 4.0, templates are MIT. Issues and PRs welcome. 👉 https://github.com/trgysvc/AgentTestMethodology

AboFlah talks about his new goals, streaming for charity, and when it’s time to log off.

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

I wrote this after noticing a recurring pattern across interfaces, component systems, ECS, domain entities, and distributed systems: an object’s state, capabilities, and implementation can change while its identity remains stable. I’d be interested to hear how others model identity separately from representation and where this distinction stops being useful. submitted by /u/CoronatedOrange [link] [留言]

The Quest Begins (The "Why") I still remember my first technical interview like it was yesterday. The recruiter slid a whiteboard marker across the table, smiled, and said, “Here’s a classic: given an array of integers and a target sum, return the indices of the two numbers that add up to the target.” My heart started racing. I could feel the sweat forming on my palms as I stared at the empty board, my mind looping over the same terrible idea: check every pair . I started scribbling a nested loop, O(n²) time, and immediately realized that if the array had even a few thousand elements, I’d be stuck there forever. The interviewer’s eyes flicked to the clock, and I could almost hear the Imperial March playing in my head— the pressure was real . I needed a way to cut through the noise, fast, or I’d be that candidate who “just didn’t get it”. That moment sparked a question that’s haunted me ever since: how do top coders stay calm, spot the shortcut, and turn a seemingly impossible problem into a few lines of clean code under pressure? The Revelation (The Insight) After that interview (and a few too many late‑night debugging sessions), I dove into the mental toolkit that separates the “just‑get‑it‑done” crowd from the folks who seem to solve puzzles while sipping coffee. The breakthrough wasn’t a new library or a fancy language feature—it was a simple shift in perspective: Instead of asking “how can I compare every element to every other element?” ask “what do I need to know about each element to instantly know if its partner exists?” In the Two‑Sum problem, the partner of a number x is simply target – x . If I could remember, in O(1) time, whether I’ve already seen that partner, I could solve the whole thing in a single pass. That’s the “aha!” moment: store what you’ve seen so far in a hash map (or set) and look for the complement as you go . It feels like discovering the One Ring in a junkyard—once you see it, everything else falls into place. The beauty is that this pa

How a single contiguous allocation — and a type system that won't let you feed strings to a scaler — is the real reason datarust fits in 2.3 megabytes. In the last post I showed you the whole datarust workflow: impute, scale, one-hot, train a logistic regression, evaluate, and save it as JSON — all without a Python runtime in sight. The Docker image shrank from ~900 MB to ~8 MB, and the binary was 2.3 MB. But I skimmed over something important. I kept saying "the flat memory layout" as if it were a detail. It isn't. It's the whole bet. Every scaler, every encoder, every model, every metric in datarust runs on top of one data structure. If you understand that structure — why it looks the way it does and what it refuses to let you do — the rest of the library stops being magic. So let's zoom in. Meet Matrix . Two containers, on purpose Real data is mixed. Numbers in one column, strings in the next. In Python, everything flows through one giant numpy.ndarray or a pandas.DataFrame , and the type system just... shrugs. A string column next to a float column gets coerced into object dtype. You'll find out at training time, in the form of an error message three frames deep. datarust does the opposite. It splits your data into two types at the source: use datarust :: Matrix ; use datarust :: matrix :: StrMatrix ; let numeric = Matrix :: new ( vec! [ vec! [ 3.0 , 85.0 , 24.0 ], vec! [ 12.0 , 70.0 , 31.0 ], vec! [ f64 :: NAN , 95.0 , 45.0 ], ]) ? ; let categorical = StrMatrix :: from_strings ( vec! [ vec! [ "MonthToMonth" ], vec! [ "OneYear" ], vec! [ "MonthToMonth" ], ]) ? ; Matrix is f64 only. StrMatrix is strings only. They are different types , and the compiler will refuse to compile a program that hands a string column to a scaler. Not at runtime — at compile time. In the last post I called this "putting on glasses for the first time." Let me show you what it actually buys you. The ColumnTransformer API is built on that split: ct .add_numeric ( "scaled" , vec! [ 0 , 1 ],

I maintain a non-custodial escrow protocol that runs on two blockchains: Base, an Ethereum L2, and TON, the chain behind Telegram. Same product, same core logic on paper: lock funds, deliver work, release on approval, handle disputes. I expected the second implementation to be a port. It wasn't. The two chains disagree so fundamentally about how a contract should be structured that writing the same feature twice forced me to rethink what "the same" even means. This post is about those differences, the design decisions each model pushed me toward, and what I'd tell anyone about to make the same jump. Light on code, heavy on the reasoning. The interesting part was never the syntax. The two mental models The single most important difference is not the language. It's the execution model underneath. On Base , a contract is an object with shared state. You write Solidity, and it behaves like a class instance sitting in memory that everyone calls into. A user calls a function, the function reads and writes contract storage synchronously, and either the whole thing succeeds or it reverts atomically. All my escrows live in one contract, in one big mapping, and every call reaches straight into that shared state. On TON , a contract is an actor that receives messages. You write Tact, and it behaves like an isolated process with a mailbox. You don't call a function; you send a message, and the contract handles it in its own turn. There is no synchronous cross-contract call in the EVM sense. Interaction between contracts is asynchronous message passing, and you design around that or you fight it the whole way. The shape of the entry point tells the whole story. On Base, an external caller invokes a named function: function approveWork(uint256 _contractId) external validContract(_contractId) nonReentrant whenNotPaused { // reads and writes shared contract storage, synchronously } On TON, nothing "calls" the contract. A message arrives, and a handler consumes it in the actor's own

Cloudflare recently introduced Meerkat, an internal globally consistent control-plane service based on the QuePaxa consensus algorithm. Unlike Raft, it allows leaderless writes while preserving strong consistency, improving availability across Cloudflare's global network. By Renato Losio

Originally published on tamiz.pro . The prevailing narrative in artificial intelligence has been dominated by cloud-based, API-driven models. While this approach offers scalability, it introduces critical latency, dependency on external services, and significant privacy concerns regarding data exfiltration. For mission-critical applications, financial analysis, or healthcare systems, the inability to guarantee data residency and offline operation is a non-starter. The solution lies in a "Local-First" architecture, where the AI assistant runs entirely on-premise or on-device. However, building such systems requires more than just downloading an LLM weights file; it demands a robust infrastructure layer capable of managing state, memory safety, and real-time concurrency. This article explores how to construct this infrastructure using two powerhouse languages: Go for its superior concurrency primitives and developer velocity in orchestration, and Rust for its memory safety, zero-cost abstractions, and performance-critical inference execution. We will dissect the architecture of a secure, local-first AI agent, moving from the conceptual model to the implementation details, focusing on the boundary between the orchestration layer (Go) and the execution layer (Rust). 1. The Architectural Paradigm: Separation of Concerns Building a local-first AI assistant is not merely a software engineering challenge; it is a systems architecture problem. The core tension lies between flexibility (the ability to swap models, adjust prompts, and handle complex workflows) and performance/security (minimizing latency and preventing memory corruption or data leaks). To resolve this, we adopt a micro-kernel architecture : The Orchestrator (Go): Handles the user interface, API gateway, session management, tool calling, and high-level logic. Go’s goroutines allow it to manage thousands of concurrent agent sessions with minimal memory overhead. The Engine (Rust): Handles the heavy lifting: mode

Claude Code in CI: Running Agentic Code Review, Test Generation, and Auto-Fix on Every Pull Request This article was written with the assistance of AI, under human supervision and review. Why Agentic Code Review in CI Changes Everything Most CI failures waste hours on manual intervention because traditional bots flag problems but never fix them. Developers open a pull request, the linter fails, tests break, and someone must context-switch from their current work to diagnose and patch the issue. This context-switching compounds across teams until the cost of maintaining CI hygiene exceeds the value it provides. Claude Code running in auto mode solves this by operating as an autonomous agent inside the CI pipeline. When a pull request triggers the workflow, Claude Code reviews the diff, generates missing tests, attempts to fix failures, and posts structured feedback as review comments—all without human intervention. The developer receives actionable fixes instead of error logs. This distinction is critical. Traditional CI bots detect and report. Agentic CI detects, repairs, and documents. The ROI appears in two places: reduced time-to-merge for routine issues and preserved cognitive capacity for architectural decisions that actually require human judgment. Key Takeaways Claude Code in auto mode runs unattended in CI pipelines with a safety classifier blocking dangerous commands before execution. Agentic CI performs code review, test generation, and auto-fix in a single workflow—eliminating the manual context-switch loop. Production deployments require cost controls (token budgets per PR), scoped file permissions, and exit conditions to prevent runaway execution. GitHub Actions, GitLab CI, and Azure DevOps all support Claude Code integration through environment variables and secrets management. The pattern that works now is scoped, single-responsibility agents—one for review, one for test generation, one for auto-fix—not a single agent attempting all tasks. Claude Code

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