标签：#t

The incident is also being investigated by the National Highway Traffic Safety Administration.

I like neofetch / fastfetch , but I wanted one with a genuinely empty dependency graph — nothing pulled from crates.io. So I built purefetch : a small system-info fetcher written entirely in Rust using only std plus raw Linux syscalls. Disclosure up front: purefetch was built largely with AI assistance (Claude Code). I directed the design, and every change was reviewed and tested — including running it on four architectures under QEMU — but most of the code is AI-generated. I'd rather be honest about that than pretend otherwise. _,met$$$$$gg. ooonea@unicorn ,g$$$$$$$$$$$$$$$P. ────────────── ,g$$P" """Y$$.". OS Debian GNU/Linux 13.5 (trixie) x86_64 ,$$P' `$$$. Host ThinkPad P53 (20QQS0JD01) ',$$P ,ggs. `$$b: Kernel 6.12.94+deb13-amd64 `d$$' ,$P"' . $$$ Uptime 6 days, 15 hours, 30 mins $$P d$' , $$P Packages 2477 (dpkg), 1 (flatpak) $$: $$. - ,d$$' Shell zsh 5.9 $$; Y$b._ _,d$P' Display 1920x1080 (eDP-1) Y$$. `.`"Y$$$$P"' DE GNOME 48.7 `$$b "-.__ WM Mutter (Wayland) `Y$$ Terminal kitty 0.41.1 `Y$$. CPU Intel(R) Core(TM) i7-9850H @ 4.60 GHz `$$b. GPU Quadro RTX 3000 `Y$$b. Memory 15.28 GiB / 62.61 GiB (24%) `"Y$b._ Swap 0 B / 8.00 GiB (0%) `""" Disk (/) 8.52 GiB / 489.57 GiB (2%) Locale en_US.UTF-8 Battery 76% (Not charging) Zero dependencies, really No libc crate, no sysinfo , no nix , no color crate — nothing from crates.io. Almost everything is just reading and parsing /proc and /sys . The result is a single ~484 KiB binary that builds offline. The only things std can't do are statfs (disk usage) and ioctl (terminal size / tty check). Instead of pulling in a binding crate, those are issued as raw Linux syscalls via core::arch::asm! : #[cfg(target_arch = "x86_64" )] unsafe fn syscall3 ( n : usize , a1 : usize , a2 : usize , a3 : usize ) -> isize { let ret : isize ; core :: arch :: asm! ( "syscall" , inlateout ( "rax" ) n as isize => ret , in ( "rdi" ) a1 , in ( "rsi" ) a2 , in ( "rdx" ) a3 , out ( "rcx" ) _ , out ( "r11" ) _ , options ( nostack ), ); ret } Four arch

CAI.com — a custodial @cai .com email, multi-chain stablecoin wallet, and MCP-installable agent API A custodial email, a stablecoin wallet, a credential vault, and an agent-ready API — all at one @cai.com address. This post walks through what CAI is, what you get when you sign up, and how to wire the agent side into any MCP-compatible host. What you get at cai.com/app A free @cai.com email comes with four product surfaces, all under one account: A real inbox at @cai.com . Send and receive mail like any other address. The signup gives you the address; the dashboard gives you the SMTP/IMAP credentials if you want to use a desktop client. A custodial multi-chain stablecoin wallet. Built in. Six chains. External wallets supported. MoonPay for fiat on-ramp (partial-live, third-party KYC and region limits apply — see cai.com/capabilities.html ). A user vault for site credentials. Store website logins and passwords. The agent you build retrieves them when needed, with your explicit confirmation. The vault is for your site credentials, not the agent's API key. An API key for the agent you build or use. Free tier covers read scopes; pay and full scopes may require verification. The key is in the account dashboard. How the signup works The signup at cai.com/app is four steps. About 2 minutes. Go to cai.com/app . Pick "Apply for @cai.com email." Enter your name. That's the only field on the first screen. CAI emails a 6-digit verification code to the address you provide. The code expires in 15 minutes. The email has a one-time link, not the code — copy the code from the email and paste it into the form. Enter the code, create a password, and you're done. At the end you have: A @cai.com email address. A custodial multi-chain stablecoin wallet. A user vault for site credentials. An API key for the agent you build or use. No card. The email is free. The agent side (for the technical reader) For the technical reader, the agent side is the reason to look at CAI. The install is one c

Ever wondered why sometimes the simplest things throw a wrench in our beautifully crafted code? I recently had a realization that hit me like a ton of bricks: the bottleneck could literally be the air in the room. It sounds absurd, right? But let me take you on a little journey through my recent experiences that led me to this conclusion. The Setup: A Frustrating Week Just a few weeks ago, I was knee-deep in a project using Python and TensorFlow to build an AI model for image classification. I was feeling pretty confident, you know? I had my dataset prepped and cleaned, my model architecture designed, and I was ready to train. But then, out of nowhere, my training took an eternity. I was kicking myself for not optimizing my code, but something just felt off. I started checking everything from my training loop to the data pipeline. I even considered that maybe I had some rogue semicolons in my Python code—classic mistake, right? But no, everything seemed fine. Then, in a moment of clarity, I realized my laptop was struggling to keep up. The fan was roaring like it was auditioning for a heavy metal band. It hit me that maybe, just maybe, the problem was my environment—specifically, the air conditioning. Environment: The Unsung Hero I’ve learned that environment can have a huge impact—like, why didn’t I think of this sooner? I had been training my model in my home office, where the temperature was rising faster than my enthusiasm for debugging. I decided to take things to the next level and moved my setup to a cooler room. And guess what? My training speed improved significantly. It turned out that my laptop was throttling itself to prevent overheating. This was my "aha moment." It was a reminder that sometimes the bottlenecks in tech aren’t just about code or hardware; they’re about the conditions we create for them. The Code: Finding Efficiency Once I had a handle on my environment, I dove back into my code. I had learned the hard way that performance optimization is

I spent over 20 years working in industrial maintenance as a boilermaker. Most of that time was in refinery shutdowns and turnarounds—high-pressure environments where systems either hold or fail. There is no “mostly working” in that world. That experience has shaped how I approach software development. ⸻ I’m not just “learning to code.” I’m building systems. I’m currently working on transitioning into web development, but I’m not approaching it as a tutorial exercise I’m building real projects from day one—and documenting the process as I go. Not theory. Not exercises. Actual systems that are meant to run. ⸻ What I’m building right now A portfolio site that behaves like a system (kmwebdev.me) This isn’t a “personal website” in the usual sense. It’s a live system under controlled change. I treat it like industrial maintenance work: versioned updates instead of redesigns small, controlled changes only tracking what changed and why stability over aesthetics Nothing gets changed without intent. ⸻ A production-focused email framework (Skeleton Framework) Alongside the portfolio work, I’m building a separate system for HTML email development. Email is one of the most constrained environments in web development. Rendering is inconsistent, standards are partial, and modern CSS support is unreliable across many clients. So instead of fighting those constraints, I’m building a framework specifically designed around them. The focus is simple: predictable rendering in real-world email clients It’s still early, but it’s being developed with production use in mind—not experimentation. ⸻ The way I work hasn’t changed—only the tools have In industrial maintenance, you learn a few hard rules: don’t assume—verify don’t scale chaos don’t change more than you can test document everything that matters So I carry that directly into development: versioned releases (v1.0, v1.3.6, etc.) controlled incremental changes explicit documentation of limitations real-world testing across environmen

Everyone is talking. Almost no one is thinking. Your morning starts with a vibration, then another, then a pile-on. Slack wants a status update. Instagram wants your face. A group chat you muted in March has resurrected itself to debate brunch. By 9:07 am you have done the emotional labor of a small call center and you have not finished your coffee. We call this being connected. A more honest word is being farmed. The internet does not pay you for your best ideas. It pays you for your fastest replies. Availability became a virtue, then a job description, then a personality. Silence got rebranded as flaking. I decided to rebrand it back, but with better tools. Not the aesthetic digital detox where you post a grainy photo of trees with “offline” in lowercase and then lurk from a finsta. I mean real disappearance. The kind where your work still ships, your people still feel held, your money still moves, and you are simply not there to watch the conveyor belt. You do not need to quit. You need to quit performing presence. The Attention Tax Is Real, and You Are Overdrawn Every ping is a micro-withdrawal from your nervous system. You pay in focus, in mood, in the ability to finish a thought. Platforms collect the interest. Researchers at UC Irvine have been tracking this for years. After an interruption it takes roughly 23 minutes to get back to the original task. The average knowledge worker gets interrupted 80 to 90 times a day. Do the multiplication and you realize most people never actually get back. They just start new half-tasks until bedtime. We treat this like a willpower problem. It is an architecture problem. Your phone is designed to win. You will not out-discipline a trillion-dollar attention refinery. You have to change the plumbing. Silence is not doing nothing. Silence is compound interest for your brain. Ten uninterrupted minutes today becomes a finished essay next week becomes a body of work next year. The people who seem calm are not morally superior. Th

Introduction to DMARC and the p=quarantine Policy DMARC (Domain-based Message Authentication, Reporting, and Conformance), defined in RFC 7489 , is an email authentication protocol. It builds upon SPF and DKIM to provide domain owners with the ability to protect their domain from unauthorized use. DMARC enables senders to specify how receiving mail servers should handle unauthenticated emails originating from their domain. It also provides a mechanism for receiving servers to report back to the domain owner about authentication results. DMARC policies dictate the action receiving mail servers should take when an email fails DMARC authentication. The three primary policies are: p=none : Monitor mode. Receiving servers take no action on failed messages but send reports. This is the initial deployment phase. p=quarantine : Receiving servers should treat failed messages as suspicious. They are typically placed in the recipient's spam folder or flagged for further review. p=reject : Receiving servers should outright reject messages that fail DMARC authentication. This is the strongest enforcement policy. Implementing p=quarantine is a critical step towards full domain protection. It allows domain owners to mitigate spoofing and phishing attempts without immediately blocking legitimate, but misconfigured, email streams. This policy provides a balance between security enforcement and minimizing potential deliverability disruptions. Prerequisites for DMARC p=quarantine Implementation Before deploying a p=quarantine policy, proper configuration of SPF and DKIM is mandatory. DMARC relies on these underlying authentication mechanisms and their alignment with the sending domain. SPF (Sender Policy Framework) SPF, specified in RFC 7208 , allows domain owners to publish a list of authorized sending IP addresses in their DNS. Receiving mail servers check the SPF record to verify if an incoming email originated from an authorized server. An SPF record is a TXT record at the root of

Some Apple devices are about to get much more intelligent, while others are getting left behind.

Introduction Fixing N+1 queries with select_related / prefetch_related or selectinload (see the previous post ) gets you down to a small, sane number of queries per request. The next bottleneck is what each query costs once the table has millions of rows — and that is almost always about indexing. An index turns "scan every row" into "look it up directly." Skip it, and a query that's instant in development takes seconds once real data volume shows up in production. How Indexes Work: The B-Tree Intuition Without an index, a WHERE clause forces a sequential scan : the database reads every row and checks the condition — O(n) , cost grows linearly with table size. An index is a separate, sorted structure (almost always a B-tree ) mapping column values to row locations. Because it's sorted and balanced, finding a value is a tree walk: O(log n) . On a 10-million-row table, that's the difference between reading 10 million rows and roughly 23 tree nodes. This isn't free: Writes get slower — every INSERT / UPDATE / DELETE on an indexed column also updates the index. Storage grows — each index is a sorted copy of (part of) the data. An index trades write cost and storage for read speed. Indexing a column you rarely filter or sort on is pure cost, no benefit. Reading Query Plans: EXPLAIN ANALYZE Postgres' EXPLAIN ANALYZE shows what the planner actually did, not an estimate. Before an index , filtering orders by customer_id : EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 48291 ; Seq Scan on orders (cost=0.00..21453.00 rows=42 width=96) (actual time=0.021..118.442 rows=41 loops=1) Filter: (customer_id = 48291) Rows Removed by Filter: 1199959 Planning Time: 0.112 ms Execution Time: 118.471 ms Seq Scan means Postgres read all ~1.2 million rows and discarded all but 41. actual time is real elapsed time — 118ms for one lookup. After CREATE INDEX idx_orders_customer_id ON orders (customer_id); : Index Scan using idx_orders_customer_id on orders (cost=0.42..8.53 rows=42 wid

Introduction Fixing N+1 queries (see the previous post ) gets your Hibernate app down to a handful of queries per request. The next bottleneck is what each of those queries costs once your tables have millions of rows — and that is almost always a question of indexing. An index turns "scan every row" into "look it up directly." Get the index wrong — or skip it — and a query that took 2ms in development takes 4 seconds in production once real data volume shows up. How Indexes Work: The B-Tree Intuition Without an index, a WHERE clause forces a sequential scan : the database reads every row and checks the condition. That's O(n) — cost grows linearly with table size. An index is a separate, sorted data structure (almost always a B-tree ) that maps column values to row locations. Because it's sorted and balanced, finding a value is a tree walk: O(log n) . On a 10-million-row table, that's the difference between reading 10 million rows and reading roughly 23 tree nodes. The cost is not free: Writes get slower. Every INSERT / UPDATE / DELETE on an indexed column must also update the index structure. Storage grows. Each index is a copy of (part of) the data, sorted differently. An index is a trade: you pay on every write so that specific reads become fast. Indexing a column you rarely filter or sort on is pure cost with no benefit. Reading Query Plans: EXPLAIN ANALYZE Postgres' EXPLAIN ANALYZE shows what the planner actually did — not what you hope it did. Before an index , filtering orders by customer_id : EXPLAIN ANALYZE SELECT * FROM orders WHERE customer_id = 48291 ; Seq Scan on orders (cost=0.00..21453.00 rows=42 width=96) (actual time=0.021..118.442 rows=41 loops=1) Filter: (customer_id = 48291) Rows Removed by Filter: 1199959 Planning Time: 0.112 ms Execution Time: 118.471 ms Seq Scan means Postgres read all ~1.2 million rows and threw away all but 41 of them. actual time is the real elapsed time, not an estimate — 118ms for one lookup. After CREATE INDEX idx_orders

Introduction Python's testing tools are lightweight enough that it's easy to write a lot of tests without writing good ones. A suite that mocks every collaborator, duplicates the same assertion ten times with different inputs pasted in by hand, or chases a coverage number will pass in CI and still miss real bugs. pytest gives you fixtures, parametrize , and monkeypatch — the tools that make it just as easy to write the right tests as the wrong ones. This post covers how to use them well. Test at the Right Level: the Pyramid Not every test should look the same. The test pyramid is a rough guide to where your effort should go: Unit tests — the bulk of the suite. Pure functions and classes, no I/O, no real database. Milliseconds each. Integration tests — fewer of these. Verify the seams : does your ORM query actually produce correct SQL against a real database, does your HTTP client actually parse a real response. End-to-end tests — a handful. Cover the critical flows through the whole stack, accepting they're slower and more brittle. # Unit — pure logic, no database, no framework def test_applies_ten_percent_discount_for_orders_over_100 (): calculator = DiscountCalculator () total = calculator . apply ( order_total = 150.0 ) assert total == pytest . approx ( 135.0 ) # Integration — the seam that matters: our query against a real database import pytest @pytest.fixture def db_session ( postgres_container ): # real Postgres in a test container, not mocked with postgres_container . session () as session : yield session def test_finds_orders_placed_in_the_last_week ( db_session ): db_session . add ( Order ( id = " ord-1 " , placed_at = datetime . now ( UTC ))) db_session . commit () recent = order_repository . find_recent ( db_session , within = timedelta ( days = 7 )) assert len ( recent ) == 1 A unit suite that never touches a database runs in seconds and catches most logic bugs. A handful of integration tests catch what only shows up at the boundary — the query that's s

Erick the Architect is a founding member of, and the primary producer for, the legendary Flatbush Zombies. He's toured the world, performed on Kimmel and Fallon, played Coachella, and collaborated with everyone from Joey Bada$$ and the Rza to James Blake and hardcore punk band Trash Talk. But perhaps the most unexpected collab was with […]

I know a vocal group of people who swear by the number pad on their keyboard. And yet, for years I haven't cared about using one - until I put my hands on the Epomaker RT98. It's a mechanical keyboard with a charming retro aesthetic, a fun CRT-like screen, VIA compatibility, a nice typing feel, […]

Wi-Fi standards remain as confusing as ever.

GitHub热门项目 | A curated list of Rust code and resources. | Stars: 58,153 | 144 stars this week | 语言: Rust

GitHub热门项目 | Before I go to bed, I tell my agents: good night, have fun | Stars: 2,889 | 420 stars this week | 语言: TypeScript

GitHub热门项目 | macOS dictation app | Stars: 1,678 | 494 stars this week | 语言: Swift

GitHub热门项目 | OpenWiki — Mac desktop AI knowledge management tool. Capture clipboard, build personal wiki, get AI insights. | Stars: 469 | 25 stars today | 语言: Rust

GitHub热门项目 | Open-source, community-driven agent harness | Stars: 39,416 | 65 stars today | 语言: Rust

GitHub热门项目 | A library of Agent Skills designed to work with the Stitch MCP server. Each skill follows the Agent Skills open standard, for compatibility with coding agents such as Antigravity, Gemini CLI, Claude Code, Cursor. | Stars: 6,363 | 35 stars today | 语言: TypeScript