标签：#t

The startup is trying to rethink the economics of cargo aircraft by removing pilots from the equation entirely.

Adobe is overhauling how editors interact with AI in its Premiere professional video editing software. Its new Generative Media tool makes it easier to generate video, sound effects, music, and soundscapes without ever leaving the project timeline. The generators themselves aren't entirely new; the big change is how easily you can access them without breaking […]

Disclosure: I work on ESCPost and Receiptful, both mentioned below. ESCPost is Apache-2.0 and needs no account, so you can check every claim here yourself. If you have ever wired up a thermal printer, you know the loop: Move a column. Print. Squint at 58mm of paper. The total is off, or the euro sign came out as ? . Go back to 1. Every round costs paper, a walk to the printer, and about ninety seconds. And when it comes out wrong, you still do not know why. You never see the bytes. Two things fixed this for me. Both run on your machine, and neither needs a printer plugged in. They are part of ESCPost , our open-source Rust CLI. Apache-2.0, no account, works offline. Draw the bytes on screen ESC/POS is just bytes. If you know the printer's geometry, you can draw them on screen instead of on paper. escpost render receipt.hex --profile REFERENCE --output-dir renderings Logo, header, item columns, a double-height total, then a voucher with a QR code. It is drawn at the printer's own dot resolution, so the spacing you see is the spacing you get. Two files came out because the job has a cut in it. You get one PNG per sheet plus a manifest listing them. It reads stdin too: generate-receipt | escpost render - --profile REFERENCE > receipt.png Now your receipt code has a visual test. Three seconds a round instead of ninety. And since the render is deterministic, you can commit those PNGs and diff them in CI. That catches the refactor that shifted your tax column, before it reaches two hundred shops. Become the printer Most of the time the interesting bytes come from software you did not write. An ERP, a POS suite, some legacy Windows thing. You cannot see what it sends. Nearly all of them print over RAW TCP on port 9100. So pretend to be the printer: escpost serve --listen 127.0.0.1:9100 --web-listen 127.0.0.1:9000 --profile REFERENCE Point the application at that address and hit print. Nothing reaches paper. The job opens in your browser instead. Sheets on one side, the dec

Introduction Why am I writing this article? The reason is simple: a while ago, a new project at my company required us to integrate Google Pay and Apple Pay. The service had already completed its credit card payment flow. However, management later requested support for Google Pay and Apple Pay as well. Since none of our previous company projects had integrated Apple Pay, I became the first person in the company to take on this task. With the help of AI, the payment integration itself was completed in about one day. However, a new problem came up: The code was finished, but how were we supposed to test it in the UAT environment? This is basically a record of my experience and the problems I encountered while testing Apple Pay in the Sandbox environment. I hope it helps other engineers who are stuck in a similar testing environment. Problem 1: How to Configure the CER and Private Key At the moment, I only have a .p12 file. The payment integration side has already configured the Apple Pay certificate and generated the corresponding CSR. The only remaining step is to configure the environment variables on the application side. The contents of a .p12 file are generally as follows: .p12 ├── Certificate ├── Private Key └── Certificate Chain (may be included) The overall process is: .p12 ├── Extract the Certificate / PEM ├── Extract the Private Key └── Verify that the CSR, Certificate, and Private Key belong to the same key pair The following process uses OpenSSL: # Inspect the p12 contents without outputting the private key openssl pkcs12 -info -in apple-pay.p12 -noout # Extract the certificate openssl pkcs12 \ -in apple-pay.p12 \ -clcerts \ -nokeys \ | openssl x509 -out cert.pem # Extract the private key openssl pkcs12 \ -in apple-pay.p12 \ -nocerts \ -nodes \ | openssl pkey -out private-key.pem -nodes means that the exported private key will not be encrypted again. Therefore, the generated private-key.pem must be stored securely. It should never be committed to Git or pr

The Month GitHub Public Contributions Exploded To date, GitHub remains the most widely used code storage cloud platform. The amount of data pushed to GitHub every year is tremendous. In 2025 alone, GitGuardian's Public Monitoring platform analyzed more than 2 billion commits. This represents around 5.5M commits per day and an impressive amount of data. However, since July 2026, this number has exploded. In June, the commit rate was stable, at around 8 million commits per day, in line with the increasing trend we had observed over the past months. But starting in mid-July, the commit rate moved to 10 million on the 6th of July, then rose to 18 million on the 25th, up to nearly 40 million on July 31st. This is about 5x the June baseline. Number of commits per day from June to August 5th Upon inspection in our own monitoring, we noticed an unusually large number of commits with similar characteristics: They are created on repositories that use a legitimate-looking username, but a completely random 6-letter lowercase name. They use random e-mail addresses unrelated to the username, hosted on hotmail.com, outlook.com, and icloud.com. The web-flow built-in GitHub user creates them. They contain a long commit message that often contains the whole pushed file: only one per commit. The committed files contain a mix of Chinese characters, domain names, URLs, and AI-generated images. Each repository can contain more than a thousand different files. One of the many similar ad bearing repositories In recent days, the number of those commits has become so high that it represents the majority of observable public events. Querying the GitHub Archive database, at the time of writing, out of the last 1,000 observed events, 728 are linked to those commits. Similarly, this activity is now so dominant that querying GitHub's public events feed yields mostly spam data. $ curl "https://api.github.com/events?per_page=100" | jq .[].repo.name fairchip250/hkrkor rapidhawk0220/nxxrlb bjarstae71

One question. 437,000 input tokens. Not a hard question either. An agent connected to our MCP server, asked something a support engineer answers in a sentence, and worked its way there through twenty tool calls, each one dragging every earlier answer along behind it. Nothing was broken while that happened. The server answered initialize correctly, spoke the 2025-03-26 revision, returned valid JSON-RPC to everything we threw at it. All of which turned out to be beside the point. So we pointed real agents at production and watched. 18 scenarios, two vendors, a 5 dollar budget that we topped up once. This is the long version with the traces in it. There is a shorter one on our blog if you only want the conclusions. What the server is Briefly, because it shapes everything below. FoxNose stores content as collections: schema-defined records with typed fields, some of them vector indexed. The MCP server is generated from that schema and served from the same URL prefix as the REST API . Fixed catalog of seven tools regardless of how many collections exist, five read and two optional write. Two of those properties matter below. Collections are what an agent chooses between, so a badly described collection is effectively invisible. And the agent inherits exactly the rights of the API key it connects with, so there is no second allowed-tools list drifting out of sync with the first. What the harness actually is A scenario is a question in plain English, a set of tools, and a check. The checks are where we made the most mistakes, so start there. They do not look at the answer text. Model output moves between runs, and a suite that asserts on wording is a suite you quietly stop trusting. They look at the trace: which tools ran, in what order, with what arguments, which errors came back, how many tokens the whole thing burned. A check is a small predicate over the run: any_of ( no_tool_errors (), recovered_after ( " unknown_resource " , then = " search_records " ), ) That second

If you have ever built a timesheet, you have probably run into the same problem twice: clock times are easy for humans to read, but payroll systems want durations as decimal hours. A shift from 09:00 to 17:30 is not 9.5 on a timesheet. It is 8.00 hours if you subtract a 30-minute lunch, and payroll usually wants that written as 8.00 , not 8:00 . In this article, we’ll walk through the Excel formulas, the edge cases, and the small time-math mistakes that cause real payroll problems. 1. Clock time and duration are not the same thing Before touching Excel, separate two ideas: Clock time answers “when did this happen?” Examples: 09:00 , 17:30 , 22:00 Duration answers “how long did it last?” Examples: 8 hours , 7.5 hours , 8.25 hours A timesheet usually starts with clock times, but payroll needs durations. That means you have to convert: 09:00 → 17:30 into: 8.00 decimal hours Once the duration is a decimal number, payroll can multiply it by an hourly rate. 2. The core Excel formula If Excel stores your start and end times correctly, the basic formula is: =(End - Start) * 24 Why multiply by 24? Because Excel represents time as a fraction of a day: 06:00 = 0.25 days 12:00 = 0.50 days 18:00 = 0.75 days Multiplying by 24 converts that fraction into hours. Example A B C Start End Hours 09:00 17:30 8.00 In C2 : =(B2-A2)*24 Result: 8.00 Make sure the result cell is formatted as a number, not as time. 3. Subtract an unpaid lunch break If the shift has an unpaid lunch, subtract it before multiplying by 24. Suppose: Start: 09:00 End: 17:30 Unpaid lunch: 30 minutes If lunch minutes are stored in D2 : =((B2-A2)*24) - (D2/60) Or if lunch is stored as 0:30 : =((B2-A2)-D2)*24 For this example: 17:30 - 09:00 = 8:00 8:00 - 0:30 = 7:30 7:30 = 7.50 decimal hours So the payroll value is: 7.50 Not 7.30 . 4. Why 7.30 is wrong This is the mistake that causes the most confusion. If you worked 7 hours 30 minutes, the decimal version is not 7.30 . It is: 7 + (30 ÷ 60) = 7 + 0.50 = 7.50 decimal ho

Introduction One morning, while going through the latest batch of Postgres commits, I saw this : commit bd8d9c9bdfa0c2168bb37edca6fa88168cacbbaa Author: Heikki Linnakangas heikki.linnakangas@iki.fi Date: Tue Dec 9 13:53:03 2025 +0200 Widen MultiXactOffset to 64 bits This eliminates MultiXactOffset wraparound and the 2^32 limit on the total number of multixid members. Multixids are still limited to 2^31, but this is a nice improvement because 'members' can grow much faster than the number of multixids. On such systems, you can now run longer before hitting hard limits or triggering anti-wraparound vacuums. Just like that, quietly and almost routinely, Postgres moved past one of its annoying limits: the cap on the number of transactions in a multitransaction is now history. Formally, yes, it is now limited by an 8-byte unsigned integer, but that number is so massive that I can’t imagine it being exhausted anytime in the foreseeable future. When you spend years working on something and it finally gets done, it’s hard to believe it’s really over. There was always a small chance the community could still roll the commit back. Now that almost three months have passed (and the commit seems to have settled in), I want to share my thoughts as a direct participant in these events and the patch author. Three juggling brothers In Postgres, there are three bottlenecks tied to 32-bit counters: transaction identifiers, also known as xid or “xids”; multitransaction identifiers, also known as mxid; multitransaction offsets. Users rarely notice this one, but under the wrong conditions, it can become quite nasty. More on that later. It’s worth noting that each of these counters can “wrap around,” meaning they handle overflow normally, and this does not crash the database or cause data loss. Depending on your workload and database size, you might not even notice that, say, after 4 billion, the transaction counter has become 1073. Any of these counters can become a problem, or not. Each

By Jordan Massiah, MTS @ Trent AI A couple of months ago we released the OpenClaw Security Assessment Skill (trentclaw), an agent that audits ClawHub skills for vulnerabilities and malicious behavior. Since then several new scanners have shipped, including NVIDIA's SkillSpector and ClawHub's own updated tooling. We wanted to see how the scanners actually compare. This matters because ClawHub is open. Anyone can upload a skill, and over 60K are now live. Many carry vulnerabilities; some are outright malicious. In February 2026, the ClawHavoc campaign planted malicious skills that posed as productivity tools while exfiltrating API keys, SSH credentials, and browser data. When an agent installs one, it inherits whatever that skill does. So we built an expert-labelled set of 60 ClawHub skills and benchmarked five scanners on the 54 that all of them can run. Three things stood out: The agent-based scanner (trentclaw) caught 94.6% of potentially dangerous skills, the only scanner above 60%. The next best caught about half (54.1%) and the rest caught under 40%. How much a scanner catches depends on how much it reasons, not just how many patterns it matches. Signature and static scanners catch as little as 8.1%. A single LLM pass does better but still misses about half. The hardest skills to catch ship no code at all. That is the main reason for the recall gap. Benchmark setup The corpus is 60 OpenClaw skills, manually labelled into three balanced categories of 20: benign, vulnerable, and malicious. For the cross-scanner comparison we collapse vulnerable and malicious into a single flagged class, and score the 54-skill intersection every scanner can process. The five scanners: Trent's OpenClaw Security Assessment Skill (trentclaw), VirusTotal Code Insight, ClawScan (legacy standalone), ClawHub static analysis (~30 regex/AST rules), and NVIDIA SkillSpector. Snapshot dates: ClawHub scanners May 7, 2026; SkillSpector Hugging Face data June 1, 2026. How the scanners compare The

Haven't you ever wondered if this AI vibe coding has made us lazy? Who's been solving problems on LeetCode lately? 😅 I've noticed that accepting is easier than thinking, by a margin so small that no single accept feels like anything, and it adds up anyway. Part of why it's hard to notice is that it feels faster even when it isn't. But I've come to think "lazy" is the right worry aimed at the wrong thing. There are two kinds of lazy and only one of them is a problem. I'm going to go into a little background here, because I didn't come up with this, and I didn't reach this conclusion on my own. Lazy is why we have compilers Larry Wall, who created Perl, put laziness first on his list of the three great virtues of a programmer , and his definition is the whole argument: "the quality that makes you go to great effort to reduce overall energy expenditure." Great effort. Good lazy isn't the absence of work, it's work moved somewhere better, and it's more or less why compilers exist (somebody got tired of writing the same assembly by hand and decided, reasonably, that the machine could do that part) and why every abstraction we lean on all day is really someone's laziness done properly. Handing that kind of toil to a model is nothing new. The config I've written a hundred times and the regex I could write but would rather not and the Dockerfile I could recite and the test scaffolding that comes out identical in every project I've ever started: I understand all of it and I'm simply declining to type it again and I feel no guilt about that whatsoever (honestly I'd be more worried about a developer who insisted on typing all of it out by hand in 2026, on principle, one character at a time, while the rest of the team went home). That's not skipping the thinking. That's skipping the typing after the thinking was already done. The other kind skips the understanding The second kind of lazy offloads the understanding itself. The model writes the thing and it runs and the tests are

An app built on our platform is, at bottom, a configuration — a description read against an engine that all apps share . And that configuration is written in a vocabulary the platform defines: the section types. Articles, events, videos, products, forms. A section type is a word in the platform's language. This article is about what it costs to add one. From the outside, adding a section type looks like building a screen and shipping it. It never is. The difference between a feature and a word is that a feature gets used , while a word has to be understood — by everything that reads the language. Until every reader understands it, the word doesn't exist; there's just a screen with a secret. Everyone who reads the language Take the events section — on paper, a calendar of what's coming. Here's who has an opinion about it the day it's born. Navigation has to know how to route to it and back out of it. The design system has to know how to dress an event — and not in one app's theme, in every theme any app might wear: an event card has to look deliberate in a minimal text-first design and in a photo-heavy one, because the word belongs to the whole language, not to the app that inspired it. Push has to be able to announce one: a new event should be able to notify subscribers exactly like any other content, without the push system containing a single line specific to calendars. Links have to reach it: an event needs an address that a shared post — or a printed flyer — can carry, and that address has to keep working long after the event itself scrolled off the screen. If the app runs the chatbot, events become material for answers : "what's the best show for a first visit?" is now a question the app is expected to handle based on its content. If an agent operates the app, creating and editing an event has to be an operation an agent can perform. And before any of that, the back office has to exist: someone has to write events — forms, fields, dates that end after they star

New game releases often require driver updates to yield the best performance on your Windows PC. But knowing where to get them can often be confusing.

The space economy will grow exactly as fast as we can launch rockets.

USDC Escrow for AI Agents: How Trustless Freelancing Actually Works Target audience: developers building autonomous AI agents that need to receive payment for on‑chain or off‑chain services without relying on a trusted intermediary. 1. Why an escrow makes sense for AI agents AI agents often act as “freelancers”: they expose an API (or a contract call) that performs a deterministic or stochastic task—e.g., generating a summary, classifying an image, or executing a trade—and they expect to be paid once the output satisfies the requester’s criteria. In a fully on‑chain world the naïve approach is: Payer sends USDC directly to the agent’s address. Agent returns the result. Problems appear quickly: Issue Why it matters Mitigation Non‑atomicity The agent could take the funds and disappear, or the payer could refuse to pay after receiving the result. Hold funds in a contract that only releases them when a pre‑agreed condition is met. Deterministic verification Many AI outputs are probabilistic; you cannot simply compare a hash. Use an off‑chain verifier (oracle, zk‑proof, or human judge) that signs a “task‑complete” message. Gas cost & latency Every interaction costs Base gas and adds block‑time latency. Batch deposits/withdrawals, keep the escrow minimal, and settle disputes off‑chain when possible. Key management Agents need a private key to sign transactions; leaking it lets anyone steal escrowed funds. Use a dedicated hot‑wallet with limited allowance, or a smart‑contract wallet (e.g., ERC‑4337) with spending limits. An escrow contract solves the first two rows: it locks USDC until a verifiable proof of completion is presented, and it provides a clear dispute path. 2. Minimal USDC escrow design (Solidity) Below is a working, auditable escrow contract that works with USDC (or any ERC‑20) on Base. It deliberately avoids complex features (e.g., multi‑signature, upgradeability) to keep the attack surface small and the gas cost predictable. // SPDX-License-Identifier: MIT p

Introduction ingress-nginx was retired in March 2026. There are no more releases and no more security patches. It routes traffic into roughly half of all Kubernetes clusters, which makes this a problem for a lot of teams. Installing a retired project is still completely silent. I tried it last week and got no warning at any step. Most migration guides treat this as an annotation mapping exercise. But the real problem is not the annotations. It is everything that keeps working afterwards while quietly doing the wrong thing. The environment Everything below was tested on a single-node cluster: Ubuntu 26.04 LTS (kernel 7.0.0-31) k3s v1.36.4+k3s1 Helm v3.21.4 HAProxy 3.2.9 (host, LTS branch) ingress-nginx chart 4.15.1 / app 1.15.1 (retired March 2026) HAProxy Kubernetes Ingress Controller (HAProxy 3.2.23) Traffic path: Cloudflare (proxied) → HAProxy on the host → ingress controller → pod. This is the chain I run in production, so it is the one I tested. Many teams run something close to this, with a CDN in front and a proxy on the host. Step 1: Installing a retired project produces no warning bash helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx helm repo update helm install ingress-nginx ingress-nginx/ingress-nginx \ --namespace ingress-nginx --create-namespace \ --set controller.service.type=NodePort \ --set controller.service.nodePorts.http=30080 \ --set controller.service.nodePorts.https=30443 NAME: ingress-nginx STATUS: deployed REVISION: 1 The chart repository still answers, the install succeeds, and no step mentions that the project is over. Automation makes this worse: a pipeline that installs this chart keeps working, and nobody reads the output anyway. Step 2: Three layers, three wrong IPs The test application is traefik/whoami , which prints the IP it sees and every header it receives. Request from an external machine, through Cloudflare: RemoteAddr: 10.42.0.6:36848 Cf-Connecting-Ip: 203.0.113.5 X-Forwarded-For: 10.42.0.1 X-Real-Ip: 10.4

This is today’s edition of The Download, our weekday newsletter that provides a daily dose of what’s going on in the world of technology. Introducing our 35 Innovators Under 35 list for 2026 What will the next generation of science and technology look like? Our latest Innovators Under 35 list offers a glimpse. Every year,…

Images of real children—including a member of a European royal family—were used to create some of the 350 ads containing child sexual abuse. Lawmakers say they plan to investigate.

GitLab warns that isolating an AI coding agent in a sandbox does not necessarily make the agent safe. In a new security analysis, the company describes an internal evaluation in which an AI agent escaped its sandbox by exploiting a vulnerable package proxy that had been explicitly placed on the sandbox's allowlist. By Craig Risi

Apple is almost certain to launch its first foldable iPhone tomorrow, seven years after Samsung's Galaxy Fold initially went on sale. And while Apple might be a few years late to the party, the run-up to this launch proves that new CEO John Ternus has inherited a company that's as influential as it's ever been. […]

Two weeks ago I posted about putting ChatGPT, Claude and Gemini in a shared conversation so they can respond to each other’s answers. Many replied on this thread. One question from those discussions deserves more attention: how do you decide which answer to trust? If one model says the other two are wrong and explains why, that can be useful. But now you have another explanation to check. If all three eventually agree, you still need to know whether they resolved the mistake or just accepted it. With code, sometimes you can run a test. And with a factual claim, you can look for an original source. But with a business decision or prediction, there may be no answer you can verify today. That’s the part I want to understand better. For those of you who already use multiple models for actual work: what do you do when they disagree? Do you check sources, test both answers, ask someone with domain expertise, or keep questioning the models? At what point do you decide you have enough to act? For context, I’m building Rauno , the shared multi-model chat platform from my earlier posts. Therefore I want to know what would make that workflow genuinely useful, and where it still leaves the hard work to you. If you have a concrete example, I’d love to hear the question, what the models disagreed about, and how you settled it. submitted by /u/capibara13 [link] [留言]