标签：#m

NVIDIA claims the new RTX Spark chip for PCs will offer 1 petaflop of AI computing power.

Without revealing too much information, what were the circumstances? submitted by /u/XTXinverseXTY [link] [留言]

Once upon a time, Microsoft had to write off $900 million betting an Arm-based Nvidia chip could power its first flagship Windows portable, the original Microsoft Surface. But today, it's trying again. Microsoft and Nvidia have just announced the Surface Laptop Ultra, a computer with a new Arm-based Nvidia chip at its core. There's a […]

This fall, Nvidia will officially become a consumer PC chipmaker like Intel, AMD, Apple, and Qualcomm, putting a complete computing chip - not just graphics - into the very heart of laptops and mini-PCs. After many months of leaks, it's finally announcing the RTX Spark, the first in a family of chips that will meet […]

The row looked perfect. rating: 7 . Valid JSON, right type, no nulls, no missing keys. My schema check waved it through. The page had returned HTTP 200. The selectors hadn't moved. Everything green. A rating of 7 on a 5-star site is impossible. The model invented it, formatted it correctly, and handed it to me with total confidence. That's the failure I want to talk about. Not the scraper that breaks loudly. The one that hands you a clean-looking row that is quietly, plausibly false — and sails past every check you have, because your checks are all looking at the shape of the data, and the lie is in the value . TL;DR HTTP 200, intact selectors, and valid JSON tell you the form is fine. They say nothing about whether the value is true. When an LLM extracts from messy free-text, structured-output mode guarantees you get valid JSON. It does not guarantee the content is real. The model fills uncertain fields rather than leaving them empty — because the schema demands a complete row. A ~60-line value-level sanity gate (ranges, dates, cross-field, reference, language) catches the obvious lies before they hit your database. Real code and real output below. The honest catch: this gate catches rule violations , not plausible lies inside the allowed range . A rating: 4 where the truth is 2 slides right through. I'll be specific about where the gate stops. Two different ways a scraper lies to you I wrote about source drift last week — the case where the page changes underneath you and a 30-line schema check catches the structure shifting. That's an input problem. The source mutated; your agreement with the page broke; you detect it by watching the shape. This is the other end of the pipe. The source is fine. The page is intact, the selectors are correct, the structure is exactly what you expected. The thing that lied to you is the model , on the extraction step, when you asked it to pull structured fields out of a paragraph of human prose. Those two failures feel similar and t

I spent way too long staring at this error. If you're here, you probably are too. Your requirements could not be resolved to an installable set of packages. Problem 1 - Root composer.json requires php ^8.3 but your php version (8.2.30) does not satisfy that requirement. My Laravel 13 app needed PHP 8.3. My Hostinger server was running 8.2. composer install refused to budge. Here's exactly what happened and the one-liner that fixed it. The Setup I was deploying a Laravel 13 + Inertia + React app to Hostinger shared hosting. Laravel 13 requires PHP 8.3 minimum — and so do its locked Symfony 8.x and PHPUnit 12.x dependencies. My composer.lock had been generated on a local machine with PHP 8.3, but Hostinger's CLI was defaulting to 8.2. The hPanel showed PHP 8.3 selected under PHP Configuration . The website itself was running fine on 8.3. But SSH? Still on 8.2. $ php -v PHP 8.2.30 ( cli ) That disconnect — hPanel vs. CLI — is the trap. What I Tried First composer update My first instinct was to just let Composer resolve newer compatible versions: composer update No luck. The root composer.json itself declared "php": "^8.3" , so Composer refused before even touching the lock file. The PHP constraint wasn't just in dependencies — it was in my own project requirements. composer install --ignore-platform-reqs This flag skips platform checks and forces the install anyway. It works , but it's a lie — you end up with packages that may behave incorrectly or fail at runtime because they genuinely require PHP 8.3 features. Not a real fix. Changing PHP in hPanel Hostinger's control panel has a PHP version switcher under Hosting → Manage → PHP Configuration . I had already set this to 8.3. This controls the web server / FPM version — what runs your .php files in the browser. It does not change what php points to in your SSH terminal. That's the key distinction most tutorials miss. What Actually Fixed It Hostinger installs multiple PHP versions in parallel. They live in /opt/alt/ph

Based on real system architecture decisions. About a $660K AI platform, three AI agents that kept the dashboard green, and a P0 incident that cost $3.15M over one weekend. Act 1 · The All-Hands Meeting Wang Lei, VP of Product, stood in front of the big screen, a smile on his face. Behind him, a dashboard rolled data from the "Axon AI Client Engineering Platform — Q1 Performance Report." Numbers cascaded across the wall: Metric Axon Platform Human Team (Last Q1) Improvement Avg daily tickets processed 847 312 +171% Avg first response time 12s 4h 17m ↓ 99.92% Customer satisfaction 4.8/5 4.1/5 +17% Monthly operating cost $52K $133K −61% Twelve department heads sat in the room. Dead silence. Wang Lei planted both hands on the table and scanned the room. His eyes landed on me. "Alex. Your team processed 312 tickets last Q1. Axon processed more than that in a single day last month." He smiled. Not a friendly smile. A sentencing smile. "And Axon costs less than a third of your team's operating expense." "We invested $660K in the whole platform. At current operating costs, it pays for itself in eighteen months." "After management review — the Client Engineering technical liaison function is being fully transitioned to the Axon platform." He clicked to the next slide. "Employees in replaced roles will complete exit interviews within the week." Someone inhaled sharply. I didn't. I opened my notebook to page 37. "Wang, what dimensions are these numbers from?" "What do you mean, 'what dimensions'?" His smile tightened. "Of those 847 daily tickets — how many are auto-tagging and routing, and how many are actual technical resolutions?" The room went quiet for about five seconds. Wang Lei looked at me. "Axon's ticket closure rate is ninety-three percent." "What's the reopen rate?" He paused. "What?" "After Axon replies — how many customers reopen the same ticket within twenty-four hours?" "We're still collecting that —" "Let me save you the trouble." I turned my notebook toward th

[Paper Notes] JEPA: Self-Supervised Learning from Images with a Joint-Embedding Predictive Architecture 🔗 TL;DR: JEPA learns a a generalized semantic representation with less data pairs by predicting missing information in the embedding space , which helps it disregard unnecessary noisy from input(pixel)-level details and learns at a higher abstraction level with good semantic generalization. 1. Innovation & Significance The Bottleneck: Image-text data pair labels are hard to find Pixel level pre-training paired & data augmentation are strongly biased towards trained data distribution, hard to determine proper generalization and level of abstraction. JEA's (Joint Embedding Architecture) collapse probelm: encoder & decoder attempts to cheat by always landing on trivial constant when predicting itself (reconstruction) and gets away with an easy Error=0. The Solution: > Chain-of-thought ⭕ Mask pre-training to reduce data & generalize↓❌ Bad/lower semantic representation without semantic target, could be learning noisy local pixel correlation↓⭕ Learn at the embedding level to omit pixel input and generalize⭕ Adds context encoder & positional encoding to inject context and force model to pick up image inherent structure from reconstructing multiple masked patches with one target.↓❌ JEAs wants to cheat: if I always map all pixels to a constant for both the predictor and end target encoder then the reconstruction error is always collapsed to zero! Hehe~ ↓ ⭕ EMA (Exponential moving avg.): Update target encoder parameters from the EMA of context encoders. This 'delays' the target encoder to prevent collapsing (a trick from the BYOL paper[2020], proven essential to training JEAs with ViT). 2. Model & High-Level Intuitions 2.1 Model Architecture Input: randomly samples block masks from original image within certain aspect ratio changes, and apply mask for context image 2.1.2 Context Context Encoder: ViT encodes context image to embedding SxS_x S x ​ Mask Token : an [1,D] random

Introduction to AWS certifications First things first, lets understand what the AWS Security Specialty certification is and where it fits in the AWS certification ecosystem. AWS certifications are divided into levels, each one targeting a different stage of your journey: Practitioner Associate Professional Specialty The practitioner level is where most people start. It focuses on foundational cloud concepts and basic AWS knowledge. As of today, there are two certifications at this level: AWS Cloud Practitioner AWS AI Practitioner The Cloud Practitioner covers core concepts like IAM, security, availability, pricing, and general cloud architecture. The AI Practitioner follows a similar structure, but focused on AI concepts and AWS AI services. The associate level is where things start to get more practical. At this level, you are expected to understand how to design and build solutions using AWS services. Some well-known certifications here are: Solutions Architect Associate Developer Associate SysOps Administrator The professional level goes much deeper. Here, you are expected to design complex architectures, handle trade offs, and make decisions based on real world constraints. The main certifications are: Solutions Architect Professional DevOps Engineer Professional Finally, we have the specialty certifications. These are focused on specific domains and require deep knowledge in a particular area. Examples include: Security Specialty Machine Learning Specialty (Retired) Advanced Networking Specialty And this is exactly where things start to get serious. At this level, AWS is no longer testing if you understand the services. It's testing if you can actually apply them in complex, real world scenarios. What it is and who this certification is for The AWS Security Specialty is one of the most difficult certifications in your AWS journey. This exam expects that you already know the basics and are comfortable with complex and long detailed scenarios that you often come

This is a submission for the Hermes Agent Challenge Agentic Web3: Automating Blockchain Workflows with Hermes Tags: #hermesagentchallenge , #web3 , #agents , #solana The blockchain industry has spent the last decade building decentralized, permissionless infrastructure. However, the user experience layer interacting with this infrastructure remains overwhelmingly manual. Decentralized applications (dApps) require users to constantly monitor markets, parse complex data, and manually sign every transaction. The next evolution of Web3 isn't just about faster blockchains; it is about autonomous execution. By integrating large language models and agentic frameworks with smart contracts, we can transition from a paradigm of manual execution to intent-based autonomy . In this article, we will explore how to bridge the gap between AI and decentralized networks by automating blockchain workflows using the Hermes Agent framework. We will look at the architecture of an on-chain agent, how it reads and writes to a network, and how high-performance environments like Solana are making these agentic experiences viable. The Paradigm Shift: From Passive Wallets to Active Agents Currently, most AI in Web3 is limited to read-only analytical tools—chatbots that can summarize a smart contract or pull token prices from an API. While useful, these are fundamentally passive systems. An active agent is different. Powered by a framework like Hermes Agent, an active agent can: Observe: Continuously monitor on-chain events via RPC nodes or webhooks. Reason: Use its LLM core to interpret those events against a set of user-defined goals or risk parameters. Act: Formulate a transaction, sign it via a secure wallet environment, and broadcast it to the network. This opens up massive possibilities. Imagine an agent that automatically manages your decentralized finance (DeFi) positions, rebalancing a portfolio based on yield changes across different protocols. Or consider fully on-chain gaming, where

This isn't a tutorial. It's real experience. Most articles about making money with Python are vague: "Learn Python to make money" (then what?) "Do data analysis freelancing" (how to get clients?) "Write web scrapers" (legal gray area) I'll share my actual path: building an Excel template generator with Python, listing it for sale, and earning my first dollar. Why This Direction My background: Know Python, but not expert Made some automation scripts No product design experience Want products (scalable) not services (time-for-money) The opportunity: Huge Excel template market (many 10k+ sales on Gumroad) Templates are static, hard to customize I can make a "template generator" for customization Technical feasibility: Python's openpyxl generates Excel programmatically JSON config is user-friendly ~300 lines of code The Product Not an Excel file. A Python script that generates Excel files . Users get: generator.py - generator code config.json - configuration README.md - documentation Workflow: Edit config.json → Run python generator.py → Get customized Excel Technical Implementation Core code is simple: from openpyxl import Workbook from openpyxl.styles import Font , PatternFill wb = Workbook () ws = wb . active # Header style header_fill = PatternFill ( start_color = ' 6366F1 ' , fill_type = ' solid ' ) header_font = Font ( bold = True , color = ' FFFFFF ' ) # Write header ws [ ' A1 ' ] = ' Project Name ' ws [ ' A1 ' ]. fill = header_fill ws [ ' A1 ' ]. font = header_font # Add dropdown from openpyxl.worksheet.datavalidation import DataValidation dv = DataValidation ( type = ' list ' , formula1 = '" In Progress,Completed,Paused "' ) ws . add_data_validation ( dv ) dv . add ( ' B2:B100 ' ) wb . save ( ' output.xlsx ' ) Loop to create sheets, set styles, add validation. Productization Process Step 1: MVP One module only (knowledge base) Test generation Use myself for a week Step 2: Expand Add 6 modules Add JavaScript version (using exceljs ) Improve docs Step 3: Package

Introduction Understanding how to find prime numbers is one of the best ways to develop logical thinking in programming. It looks simple on the surface, but it teaches you how to break a problem into smaller steps, build a solution gradually, and then improve it into a clean and reusable structure. In this blog, we will not jump directly into code. Instead, we will start from basic thinking, slowly convert that thinking into logic, and finally refine it into a proper Python program using functions and loops. The goal is not just to find prime numbers, but to understand how programming logic is actually built in real development. 1. Understanding the Problem First Before writing anything in Python, we need to understand what a prime number actually means. A prime number is a number that: is greater than 1 has exactly two divisors: 1 and itself So the real question becomes: How do we check whether a number has any divisors other than 1 and itself? That is the core problem we are trying to solve. 2. Thinking Like a Human Before Coding Let’s take a number, for example 13. To check if 13 is prime, we naturally try dividing it by smaller numbers: 2 → does not divide 13 3 → does not divide 13 4 → does not divide 13 5 → does not divide 13 and so on If none of these numbers divide 13 completely, then 13 is prime. So the logic is simple: Try dividing the number by possible candidates and see if any divide it perfectly. 3. Turning Thinking into a Basic Algorithm From the above idea, we can form a basic structure: We need: a number to test a variable that moves through possible divisors a way to detect whether a divisor exists We start checking from 2 because every number is divisible by 1 anyway. We also do not need to check beyond half of the number, because a number cannot have a divisor greater than half (except itself). So the idea becomes: Start divisor from 2 Go up to number // 2 If any number divides it evenly, it is not prime 4. First Working Logic (Direct Implementati

Hey everyone, I'm trying to get back into the loop on world models. The last time I followed SSL closely, the buzz was all about Barlow Twins and DINO, but now everything just looks like scaled-up video generation from big industry labs. What is the actual academic research community stressing over right now? submitted by /u/nat-abhishek [link] [留言]

The Logging Nightmare Deploying microservices across Multi-Cloud environments using tools like Terraform is an exhilarating milestone. But the moment something breaks, that excitement quickly turns into a nightmare. The SSH Grind : If you find yourself SSH-ing into disparate instances just to run tail -f and grep through scattered log files, you're doing it wrong. The Agnostic Approach : The industry standard demands Centralized Logging, but chaining your application to vendor-specific solutions like AWS CloudWatch or GCP Cloud Logging limits your architectural freedom. Implementing a true "Cloud-Agnostic" ELK stack gives you back control over your observability data. Clean Architecture & The Non-Blocking Logger Factory Building this robust observability pipeline requires adhering to Clean Architecture principles, specifically through a Non-Blocking Logger Factory. Standardized Interface : By wrapping modern logging libraries like Winston or Pino , we standardize our application's logging interface. The Secret Sauce : The winston-elasticsearch transport module buffers your logs and pushes them directly to your Elasticsearch cluster in the background. Non-Blocking : This architectural choice is crucial: it ensures that high-volume log streaming happens without blocking the Node.js event loop . Here is how the data flows through the system: Resilience Fallback (The Failsafe) A centralized system introduces a dangerous dependency. Your logging infrastructure must never be the reason your application crashes. The Threat : If the remote Elasticsearch cluster is unreachable due to network partitions or rate limits, a poorly configured logger will throw uncaught exceptions, bringing down the app. The Solution : We implement a strict Resilience Fallback (Failsafe) mechanism. The transport module safely catches the connection errors and seamlessly falls back to standard output (console), guaranteeing continuous operation. The 512MB Local-Test Challenge While this setup is a

There is a specific failure mode in AI-assisted QA work that most tooling discussions skip entirely, and it shows up earliest when you are working solo on a real engagement. Every new chat session is stateless. You paste the ticket, describe the feature, explain your severity logic, set up the context, and by the time the AI is actually useful, you have rebuilt your methodology from scratch for the third time that week. That is not a workflow problem you fix with better prompts. It is an architecture problem, and the fix is a skill file. QAJourney has a full breakdown of this system at qajourney.net/ai-qa-workflow-for-real-projects, including the actual skill files as free downloads. The short version: a skill file is a context document you load as a system prompt. It carries your test surface tiers, your three-path testing framework, your bug report format, your severity and priority logic, your Playwright conventions, and an explicit definition of what the AI does and does not get to call. Load it once per session. The AI operates inside your methodology from the first message instead of a blank slate. The local LLM layer solves a different problem. On a freelance or retainer engagement, tickets contain real product logic and real client data. Sending that to a cloud API on every session is a data exposure question whether or not it rises to a compliance issue. Running Ollama locally with the same skill file as system context keeps the engagement data on the machine. For the output quality required on QA tasks, current 7B to 14B models are sufficient. The cost at zero marginal per token makes it infrastructure rather than a service you pay by the session. The three-role setup in the workflow: engineer as judgment layer, cloud AI loaded with the skill file for complex reasoning and active session output, local LLM for lightweight tasks and client data work. The skill file is the constant across all three. The part that took time to internalize: AI dev teams already

RecursiveMAS (arXiv 2604.25917) showed that agents sharing internal reasoning state outperform agents that share only final outputs. The average accuracy gain across benchmarks was 8.3 points. The mechanism: each agent passes not just its answer but the latent embeddings from its own reasoning process, and the next agent conditions on both. The paper is a good result. The catch is access. RecursiveMAS requires open-weight models with hidden states exposed at inference time. That rules out Claude, GPT-4o, and Gemini. I built a Claude-native version using the Anthropic extended thinking API. The core idea transfers: instead of passing latent vectors, pass the full thinking text. The paper calls it internal state sharing; the Claude version calls it thinking-block relay. The architecture problem Claude's extended thinking blocks carry an encrypted signature tied to the originating conversation. You cannot pass a signed thinking block into a different agent's messages array. The API rejects it. The workaround: extract the text from the thinking block and inject it as a regular user message. # Extract thinking text from Agent 1 thinking_text = next ( ( b . thinking for b in response . content if b . type == " thinking " ), "" ) # Inject into Agent 2 as regular context, not as a thinking block context = f " Prior agent reasoning: \n { thinking_text } " The signature does not transfer. The reasoning does. relay-structured: what I built first The first architecture was a Planner > Critic > Solver loop where each agent emits a compact mental model JSON instead of raw thinking text. Raw thinking at a 1024-token budget is often compressed and fragmented. The hypothesis was that 150 tokens of structured signal carries more information per token than 1024 tokens of compressed prose. The schema each agent emits: { "interpretation" : "how the agent read the problem" , "key_steps" : [ "step 1" , "step 2" ], "rejected_approaches" : [ "approach tried and discarded" ], "confidence" :

A flanged pipe joint looks simple: two raised faces, a gasket between them, a ring of bolts pulling them together. Yet the gasketed bolted flange is one of the most common sources of leaks in process plants, and the reason is almost always the same — the bolts were not tightened to the right load. Too little and the joint weeps; too much and the gasket is crushed. The number that sits between those failures is the bolt preload, and it is not the same as the pressure load. This article explains how a bolted flange actually carries internal pressure, why the bolts must be preloaded well above the pressure end force, works a concrete example, and lists the mistakes that turn a sound joint into a leaking one. Why this calculation matters Bolted flange joints appear wherever a pipe or vessel has to be opened for maintenance: pump connections, valve bodies, heat exchanger shells, instrument tappings, and reactor manways. Unlike a welded joint, a flange is meant to be taken apart and reassembled, and every reassembly depends on the fitter applying the correct bolt load. The stakes are real. A leaking flange on a hazardous service can release flammable or toxic fluid. Even a benign leak wastes product and forces an unplanned shutdown. Design codes such as ASME Section VIII Appendix 2 set out a full method for sizing flange bolts, and at its heart is a comparison: the load the bolts can supply versus the load the joint demands in two distinct conditions — seating the gasket, and holding pressure. Understand the pressure end force and you understand the floor that the bolt load must clear. The core method When the line is pressurised, internal pressure acts on the fluid inside the flange and pushes the two flanges apart. The total separating force is the hydrostatic end force , the pressure acting over the area enclosed by the gasket sealing circle: H = p * (pi / 4) * G^2 Here p is the internal pressure and G is the gasket reaction (sealing) diameter — the effective circle on

System-prompt caching alone cut repeat-call costs by half Tool definitions cache separately, perfect for agent loops Conversation history caching pays off after turn three 1-hour TTL beats the default 5 minutes for batch jobs My Anthropic API bill dropped 70 percent last month and I did not change a single model. I changed where the cache breakpoints went. Here are the five patterns I now use on every Claude integration I ship. Pattern 1: Cache The System Prompt First The system prompt is the cheapest win and most people skip it. My agents run with a 4,000 token system prompt that explains the role, the output format, the safety rules, and a few examples. That prompt never changes inside a session. Before caching, I paid full input price for those 4,000 tokens on every single call. With an agent that loops 30 times to finish a task, that is 120,000 tokens of pure repetition. The fix is one parameter. I add a cache_control block with type: "ephemeral" to the last content item in the system prompt array. The first call writes the cache and costs slightly more (cache writes carry a small premium). Every call after that reads the cache at roughly one tenth the input price. Here is the rule I follow: the cached block has to be at least 1,024 tokens for Claude Sonnet, or it gets ignored silently. My 4,000 token prompt clears that easily. If your system prompt is short, this pattern does nothing, so do not bother adding the breakpoint to a 200 token instruction. The order matters more than people expect. The cache works as a prefix. Everything before the breakpoint gets stored. Everything after it is read fresh. So I put the stable stuff (role, rules, examples) up top and the volatile stuff (user query, current date) down below the breakpoint. Reorder this wrong and your cache hit rate collapses because the prefix changes on every call. One real number from my logs: a document-classification job that runs 2,000 times a day. The system prompt is 3,800 tokens. Caching it sav

The Radeon RX 9070 GRE is finally available outside of China

AMD has some new gaming-focused chips for the economy we all live in.