标签：#p

TL;DR — Claude Code sends its requests wherever one environment variable points. Aim that at a small local translator and it runs on the Kiro plan you already pay for. Full setup below, plus the two snags worth knowing about. Claude Code and Kiro have something funny in common: underneath, they're powered by the same Claude models. Same brain. They just grew up speaking different dialects, so out of the box they can't hold a conversation. I noticed this right as I was about to start a second subscription for Claude Code. My Kiro plan was already renewing every month, already serving the exact models Claude Code wanted to charge me for again. Paying twice to talk to the same thing felt absurd. So instead of buying a second seat, I hired an interpreter. One small program that sits between them, listens to Claude Code, and relays everything to Kiro in a dialect it understands. Here's how to set it up, and what I learned doing it. Why they can't just talk Claude Code is more open-minded than people assume. It doesn't hard-code where it sends requests. It reads one environment variable, ANTHROPIC_BASE_URL , and ships everything to that address. Normally that's the official endpoint, but it'll happily send its requests anywhere you tell it to. That's the opening. Point it somewhere local and the whole thing becomes possible. Meet the interpreter The catch is that Claude Code and Kiro phrase things differently. You can't just redirect one at the other and expect them to understand each other. You need a translator fluent in both. That's kiro-gateway-next : a tiny proxy that runs on your own machine. A request arrives phrased one way and leaves phrased another: Claude Code (phrases it for Anthropic) ──▶ kiro-gateway (rephrases it for Kiro) ──▶ your Kiro account Claude Code gets a reply in the format it expects. Kiro receives a request it recognizes. The interpreter does the rephrasing in the middle, and the conversation just flows. Setting it up, step by step Six steps. Abo

You submitted your extension, waited days for review, and got back a rejection with a violation called "Purple Potassium." Your extension looks fine to you, so what does it even mean? Here is what it is, why it happens, and how to catch it before you ever hit submit. What "Purple Potassium" actually means "Purple Potassium" is Google's internal tag for excessive or unused permissions . Your manifest requests access to something your code does not actually use, and the reviewer flags it. It is one of the most common reasons a Chrome extension gets rejected, and it is frustrating precisely because the extension works fine in testing. Review is checking something testing never does: whether every permission you ask for is justified by your code. The usual causes 1. API permissions you declared but never call. You added tabs , bookmarks , or cookies to your manifest at some point, but there is no chrome.bookmarks.* call anywhere in your code. 2. Host access that is too broad. You requested <all_urls> when your extension only touches one site: // Flagged "host_permissions" : [ "<all_urls>" ] // Better "host_permissions" : [ "https://*.example.com/*" ] Leftover permissions after removing a feature. You shipped a feature that needed downloads, later removed the feature, and forgot to remove the permission. The tabs misunderstanding. The tabs permission does not grant access to the tabs API. Basic methods like chrome.tabs.create() work without it. It only grants four sensitive Tab properties: url, pendingUrl, title, and favIconUrl. If you declare tabs but never read those, it counts as unused. How to fix it by hand List everything in permissions, optional_permissions, and host_permissions. For each one, search your code for the matching chrome. call. Remove any permission with no usage. Narrow and other broad patterns to the specific hosts you need. In your reviewer notes, write one plain sentence per sensitive permission explaining why you need it. Reviewers often lack con

I recently completed an exploratory data analysis project on the NHANES (National Health and Nutrition Examination Survey) dataset from Kaggle. It's a real-world health survey collected by the CDC covering body measurements, lifestyle habits, and demographic data from thousands of US adults. In this article I'll walk you through exactly what I did — from loading and cleaning the data all the way to running statistical tests — and share what I found along the way. The Dataset The dataset has 5,735 rows and 28 columns , but for this project I focused on 8 columns that were relevant to the questions I wanted to answer: Column Description smoking Has the person smoked at least 100 cigarettes? gender Male or Female age Age in years education Highest level of education weight Weight in kg height Height in cm bmi Body Mass Index Step 1 — Loading and Selecting Columns import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns db = pd . read_csv ( ' NHANES.csv ' ) data = db . loc [:, ( ' SEQN ' , ' SMQ020 ' , ' RIAGENDR ' , ' RIDAGEYR ' , ' DMDEDUC2 ' , ' BMXWT ' , ' BMXHT ' , ' BMXBMI ' )] data = data . rename ( columns = { ' SEQN ' : ' id ' , ' SMQ020 ' : ' smoking ' , ' RIAGENDR ' : ' gender ' , ' RIDAGEYR ' : ' age ' , ' DMDEDUC2 ' : ' education ' , ' BMXWT ' : ' weight ' , ' BMXHT ' : ' height ' , ' BMXBMI ' : ' bmi ' }) One thing worth knowing about NHANES: all the columns come in as numeric codes. 1 means Male, 2 means Female. 1 means the person smoked, 2 means they didn't. You have to map these to readable labels before doing any analysis, otherwise your charts are meaningless. Step 2 — Cleaning the Data Drop the ID column and remove nulls data . drop ( ' id ' , axis = 1 , inplace = True ) data . dropna ( inplace = True ) This brought us from 5,735 rows down to 5,406 — about 6% lost, which is acceptable. Remove outliers using the IQR method The IQR (Interquartile Range) method flags values that fall too far outside the middle 50% of

For the last 3 months I recorded every session I had with Claude Code. Not screenshots, not memory. Every prompt I typed and everything it did, saved to a small database I own. I did it because I kept losing my own work. I would finish a week, someone would ask what I shipped, and I genuinely could not remember. The work was real. It just lived in terminal scrollback I would never scroll through again. So I set up a chain of small agents to remember it for me. Every night, while I sleep, one agent reads that day's raw sessions and writes a single clear note: what I built, the decisions I made, what is still open. Plain language, the way I would write it in a journal, not a wall of logs. Once a week, a second agent reads all seven daily notes and updates a profile of me: the projects I am moving, the skills I have actually used, the things I learned. After a few months this turned into a more honest picture of my work than my resume. Then a third agent reads all of that and drafts posts for LinkedIn and X about what I actually worked on that week. Building in public, without me having to remember or sit down and write. The part I like most: none of it runs on my machine. It is all scheduled cloud routines. My laptop can be off. I wake up and the notes, the profile, and the draft posts are already waiting. I have started open-sourcing this as Pulse. The capture and the nightly daily-note agent are out now. You point it at your own database and your own notes repo, and it writes your day for you, in plain English, in files you own. The weekly profile agent and the post-writer are the pieces I am extracting next. It is early and rough in places. The honest caveat: the writing is only as good as the model behind it, and a quiet day still makes a quiet note. But after 3 months, I no longer guess what I did. I just open the vault. The graph at the top is 3 months of my own notes, each day linked to the projects it touched. Repo: https://github.com/muhammademanaftab/pulse

A few months ago, if someone had asked me to build a mobile app, I would've had absolutely no idea where to start. Today, an app I built is on the Google Play Store. It's called Stulo, and it's currently in closed testing. The funny part? I'm not a software engineer. I'm just a college student who got tired of missing opportunities. Internships were on LinkedIn, hackathons were buried somewhere on Instagram, college events lived inside WhatsApp groups, and competitions were scattered across random websites. If the algorithm didn't like you that day, you simply never found them. That felt... ridiculous. So I asked myself, "Why isn't there one place where students can find everything?" That simple question eventually became Stulo. Today, students can discover internships, hackathons, competitions, campus events, connect with other students, and share updates through a campus feed—all in one app. The biggest lie I believed was that building the app would be the hard part. It wasn't. Understanding why it wasn't working was. I built the first version using Emergent because, honestly, I didn't know enough to start from scratch. It got me surprisingly far. As the project became more serious, I moved development to Google AI Studio (Antigravity). That's when I learned something every AI-generated YouTube thumbnail forgets to mention: AI doesn't build products. It generates code. There's a huge difference. AI happily writes hundreds of lines of code, but it doesn't explain why your images randomly stop rendering after ten minutes, why scrolling suddenly feels like you're using a phone from 2013, or why fixing one bug somehow creates three completely unrelated bugs. Most days followed the exact same routine: generate code, run the app, watch something break, Google the error, ask AI, read Stack Overflow, realize the problem was my own code, and repeat. Some bugs took ten minutes to fix, while others stole an entire weekend. Looking back, one of the biggest things I learned wa

Prediction markets just hit $3.6B in volume. I wanted to know what the biggest traders were betting on — in real time. So I built WhaleTrack. Here's how it works under the hood. The Problem Polymarket has a public leaderboard. But it only shows P&L totals — not what whales are currently betting on, not their recent activity, not their win rate. If you want to follow smart money, you're flying blind. I wanted something that answered: what are the top traders doing right now? The Stack Vanilla JS frontend (no framework, keeps it fast) Vercel serverless function as a backend proxy (avoids CORS issues) Polymarket's public data API — no auth required Step 1: Finding the Whales Polymarket exposes a leaderboard endpoint: https://data-api.polymarket.com/v1/leaderboard?limit=20 This returns traders ranked by P&L. I pull the top 10, grab their wallet addresses, and that's my whale list. Step 2: Fetching Live Activity For each whale wallet, I hit: https://data-api.polymarket.com/activity?user={address}&limit=20 This returns their recent trades — market name, size in USDC, timestamp. Refreshes every 60 seconds. Step 3: Calculating Win Rate (the tricky part) The key is the redeemable flag — redeemable: true means they won, currentValue: 0 + redeemable: false means they lost. Took a few wrong attempts with cashPnl (always negative, not useful). Step 4: The Whale Alert Banner Every 60 seconds I check for trades over $5,000 placed in the last 10 minutes. When it fires, a green banner slides down with the whale name, market, and amount. Auto-dismisses after 12 seconds. First time I saw it fire live with a $28K bet — genuinely exciting. Results 129+ users in the first few days Zero ad spend Traffic from Twitter, Reddit, Quora What's Next More whale wallets (suggestions welcome) Click-through to open the same market on Polymarket directly Email/push alerts for big trades Check it out: whaletrack.app All feedback welcome — especially if you spot a whale I'm missing.

C is over 50 years old. Yet it still powers: Linux Embedded Systems Compilers Databases Device Drivers Why? Because it offers something very few languages do: Speed + Control + Portability 1. Fast Execution C compiles directly into machine code. That means very little runtime overhead and excellent performance. 2. Portability Well-written C code can be recompiled on Windows, Linux, and macOS with minimal changes. 3. Direct Memory Access Pointers allow precise control over memory. That's one reason C is used for operating systems and embedded software. 4. Structured Programming Functions and modular design make large programs easier to organize. 5. Small Language Core The language itself is relatively small, making it easier to learn the fundamentals. 6. Standard Library Useful libraries exist for: Input/Output Strings Files Memory Mathematics 7. Hardware Interaction Few languages communicate with hardware as naturally as C. That's why C remains the dominant language for firmware and drivers. What About the Downsides? C also has limitations. Manual memory management No garbage collection No built-in OOP Limited runtime safety These make C harder to master but also teach concepts that many higher-level languages hide. Simple Example #include <stdio.h> int main () { printf ( "Hello, World! \n " ); return 0 ; } Even this tiny program demonstrates: Header files The main() function Standard library usage Program execution Final Thoughts Learning C isn't about writing every future application in C. It's about understanding how software works beneath modern frameworks. Once you understand C, many other programming languages become much easier to learn. Full beginner guide with diagrams and explanations: [Feature and Application C Programming](# 7 Features of C Programming Every Developer Should Know C is over 50 years old. Yet it still powers: Linux Embedded Systems Compilers Databases Device Drivers Why? Because it offers something very few languages do: Speed + Control +

Apple's newest on-device model carries about 20 billion parameters, and on any given request it fires maybe one to four billion of them. That gap — 20B stored, roughly 3B running — is the whole story of 2026. The model that now ships inside the latest iPhone is no longer a shrunken, lobotomized cousin of the cloud model. It's a different kind of object: large in flash, small in motion, and it never phones home. For three years the on-device pitch was mostly aspirational. Demos ran, latency was rough, quality trailed the API by a generation, and every serious AI feature still resolved to a per-token bill in someone's datacenter. In mid-2026 that stopped being true. Two releases — Apple's third-generation Foundation Models at WWDC on June 8, and Google's Gemma 4 family on April 2 — quietly moved the floor. Genuinely useful agents now run on hardware you already own, offline, for free. The economics nobody priced in Forget benchmarks for a second; the load-bearing fact here is accounting. When the model lives in the cloud, every inference is a metered event — input tokens, output tokens, a line item that scales linearly with usage and explodes the moment you wrap the model in an agent loop. Agentic workloads are the worst case for the token meter: a single "go do this task" can fan out into dozens of model calls as the agent plans, calls tools, retries, and re-reads its own output. The bill grows with your ambition. Move the model onto the device and the marginal cost of an inference is approximately $0 . No API key, no rate limit, no usage dashboard. You paid for the silicon once; every token after that is free in the only sense a product manager cares about — it doesn't show up on a monthly invoice that grows with your success. That single change rewrites which features are worth building. A background task that re-summarizes your inbox every five minutes is insane on a per-token plan and trivial on-device. So is an agent that quietly loops a hundred times to get one

Lightweight PDF & EPUB reader in your browser Discussion | Link

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

So for learning purposes I was reading a few research papers on the topic of databases. I read through a few papers like gfs, cockroachdb, dynamodb, raft etc.. DynamoDb uses consistent hashing for the key distribution. It also uses virtual nodes for reducing the rebalancing problem when a node dies. So I had an idea of using the resource(disk, cpu, ram, network) of server to determine how much data/load it should handle. We can't determine the capacity of a server just with its hardware specs like ram & disk, if the latency is high or has frequent network issue then it makes that particular node not very reliable to hold the data. So incorporating the network details will help us get better resource scores of a node. Keys are mapped to slot using CRC16 and there will be a fixed number of slots 16384. Since I used a storage engine called pebble(similar to rocksdb) I was able to avoid the headache of writing the storage layer. I greatly underestimated the process of writing a database. So coming back to the topic I want to know if this resource based ranging splitting is already implemented and more information on it. I developed a architecture on this topic called irisdb and it implements this resource scores mechanism to determine which node to take the slot range to split. this is a learning project and I gladly accept any feedback I could get submitted by /u/wizard_zen [link] [留言]

HP Inc. scales its OpenAI Frontier partnership to deploy AI across customer experiences, software development, and enterprise operations.

The new models will launch with the M5 Pro and M5 Max, according to Mark Gurman.

Welcome back to TechCrunch Mobility, your hub for the future of transportation and now, more than ever, how AI is playing a part.

A scheduled post fires. The request to publish it goes out. The network hangs. After 30 seconds, our client times out. We retry. The tweet publishes. Then the original request completes too — and a second, identical tweet goes out. That's a double-post. On a personal account it's embarrassing. On a client account at an agency it's a support ticket and a credibility hit. Either way, it's the single most visible failure mode in any posting system, and it's caused by one of the most common conditions in distributed systems: ambiguous outcomes under timeout. At HelperX , we ship scheduled posts, replies, and DMs across hundreds of accounts. Every one of those actions can time out, retry, and double-execute. This article is about how we prevent that with idempotency keys — the same pattern payment systems use to prevent double-charges, applied to social actions. The problem, precisely A timeout is ambiguous. When a publish request times out, the action is in one of three states: Never reached the server. The post didn't publish. Safe to retry. Reached the server, failed there. The post didn't publish. Safe to retry. Reached the server, succeeded, response lost. The post did publish. Retrying publishes it again. The client cannot distinguish states 1 and 2 from state 3. They all look identical: "I sent a request and didn't get a response." Naive retry logic treats all three the same and retries — which is correct for 1 and 2 but catastrophic for 3. This is the classic "exactly-once is impossible" problem. You can't guarantee an action executes exactly once over an unreliable network. But you can guarantee it takes effect exactly once, using idempotency. The idempotency key idea An idempotency key is a unique identifier the client generates before sending the request and includes with it. The server uses the key to recognize a retry and avoid re-executing: First request with key K → server executes, stores "K succeeded, result was R." Retry with same key K → server sees K

Eight months ago, a CS exam forced me to write pseudocode when I already knew how to code. Instead of studying, I rage-built an app. Today examintelligence.app is live. Here’s exactly how I got here—from vibe-coded POCs to a production hybrid AI pipeline—without the curated startup gloss. The Philosophy Behind the Build I’ve always believed studying for marks ≠ actually learning. When I was first introduced to organic chemistry, I hated it. Then I ran into GNNs in Machine Learning with PyTorch and Scikit-Learn , paired with the MoleculeNet dataset. Suddenly, everything clicked. I wanted to learn everything about it. That’s the core problem: exams optimize for pattern recognition, not curiosity. You’re forced down one prescribed path, and it rm -rf s the fun of learning in most cases. So one week before my first prelims, I decided to build exam intelligence. The plan was simple: introduce brutal efficiency using AI for what it’s actually built for: pattern recognition Parse every past paper, mark scheme, and examiner report. Distill it down to precisely what matters. Free up time for coding and creative work. Vibe-Coding the POC (and Why It Collapsed) I’m generally against vibe-coding. It’s unreliable, hard to maintain, and a security nightmare. But with prelims staring me in the face, I had no choice. I opened Claude and vibe-coded it module by module. The only code review I had time for was checking for suspicious os.system or subprocess calls. That was it. I shipped anyway. Initial stack: Gemini API (no agent frameworks, no LangGraph) Streamlit frontend PostgreSQL It validated my idea but functionally, it barely held together. After prelims, I finally looked at what the AI had actually built: Dashboard showing random stats Asked Gemini for a JSON response with 5 keys, saved only 2 Randomly created DB tables while trying to read subjects The kind of code you end up with when you let an AI cook unsupervised for a week. So I did the only reasonable thing: opened Neov

I had arrived at the final frontier. My bare-metal kernel was booting in QEMU, driving NVMe block storage, running multi-agent swarms, and rendering a force-directed canvas. But to make V.E.L.O.C.I.T.Y.-OS a truly next-generation system, I needed to close the loop: the operating system had to be able to evolve and compile itself without human intervention. The V.E.L.O.C.I.T.Y.-OS 12-Part Roadmap We are building a bare-metal, self-healing operating system running entirely inside the CPU's L3 cache. Here is the roadmap for this 12-part series: Part 1: The Spark — Exposing the "Safe-Room" security leak and building the compiler gate. Part 2: The NDA Language — Designing a content-addressed triplet representation to cure context bloat. Part 3: Ditching the Web Stack — Building a native 30MB IDE with 1,500,000x IPC latency drops. Part 4: The Closure JIT — Compiling AST blocks to nested closures and bypassing borrow checker limits. Part 5: JIT Math Optimizations — Replacing division operations with precomputed 16-bit lookup tables. Part 6: x86-64 Assembler & SCEV-Lite — Compiling scalar loops directly to native code in constant time. Part 7: Classic Compiler Passes — Implementing inter-procedural Dead Code Elimination and loop unrolling. Part 8: Reclaiming Ring 0 — Exiting UEFI boot services and transitioning the kernel to Ring 0. Part 9: Bare-Metal Drivers — Writing a PCI scanner, NVMe block storage controller, and FAT32 parser. Part 10: Synaptic Canvas — Rendering a spatial, force-directed GUI based on model token activation vectors. Part 11: Swarms & Hot-Patching — Building multi-agent scheduling and zero-downtime RCU driver updates. Part 12: Self-Evolution — Handing system control over to a local LLM Terminal that self-optimizes via telemetry. (You are here) During the final hours of my Sunday morning sprint, I completed the self-healing loop, the Biosphere P2P registry, and the Boot-to-NDA LLM Terminal handover. To achieve self-healing, I built a Ring 0 telemetry sys

AgentJr — The AI Junior Developer That Manages Your Entire Freelance Business While You Sleep Most "AI developer tools" do one thing: write code. AgentJr does everything a real junior developer does. Code. Clients. Communication. Deployment. Testing. Invoices. Social media. All of it. Automatically. While you sleep. The Real Problem With AI Coding Tools Today Claude Code writes code. Devin writes code. Copilot writes code. But writing code is maybe 40% of what a freelance developer actually does. The other 60%? Talking to clients. Understanding what they actually want. Managing git properly. Branches, commits, PRs. Running tests. Catching bugs before the client sees them. Deploying to the right environment. Not accidentally pushing dev code to production. Sending updates. "Hey, your feature is live." Tracking costs. How much did this project actually cost me in API calls? Following up. Drafting invoices. Scheduling calls. Posting on LinkedIn about the work you just shipped. No AI tool today handles all of that together. They give you a coding assistant and leave the rest to you. AgentJr is different. AgentJr is not a coding assistant. It's a complete AI junior developer that manages your entire workflow — from the moment a client messages you, to the moment the project is deployed, tested, and the invoice is sent. You Are the CEO. AgentJr Is the Manager. Here's the architecture that makes AgentJr unique: You — give direction. Set priorities. Approve plans. That's it. AgentJr (Manager) — understands requirements, asks smart questions, builds plans, manages git, monitors work, handles client communication, runs tests, manages deployments, tracks costs, drafts invoices, posts social media updates. Claude Code / Codex / Gemini CLI (Worker) — writes the actual code. Spawned by AgentJr on your terminal. Per project. You choose which one. AgentJr never writes code itself. It orchestrates the worker that does. This separation is intentional — and it's what makes the whole s

Hello everyone! Me and my friend. We are still learning, and recently we tried to make a very simple, hobby antivirus/security project written in C. We call it, F4us. It is far from perfect and still in a very early development phase. We just wanted to learn how some basic security concepts work under the hood. What we tried to build: A simple honeypot script to log suspicious access. A basic entropy function to check file structures. A background daemon loop to monitor files. Since we are still beginners, we know there are probably a lot of bugs and messy code in it. We just wanted to share this hobby journey here. Thank you for reading! here is the link(github), sorry if include many bugs or critical,it just an experiment: https://github.com/CornelI5/F4us my friend was out, he are in crashout cause this project is too hard. btw, dont use this in your real computer, trust me. just use VM(Virtual Machine),or you will get BSOD(blue screen of death) or kernel panic.