标签：#us

Here is every promise a to-do list makes. VARIABLE tasks Init == tasks = [i \in Ids |-> "absent"] Add(i) == tasks[i] = "absent" /\ tasks' = [tasks EXCEPT ![i] = "open"] Complete(i) == tasks[i] = "open" /\ tasks' = [tasks EXCEPT ![i] = "done"] Reopen(i) == tasks[i] = "done" /\ tasks' = [tasks EXCEPT ![i] = "open"] Delete(i) == tasks[i] # "absent" /\ tasks' = [tasks EXCEPT ![i] = "absent"] ClearCompleted == /\ \E i \in Ids : tasks[i] = "done" /\ tasks' = [i \in Ids |-> IF tasks[i] = "done" THEN "absent" ELSE tasks[i]] Not a summary. Not the important ones. All of them. A task cannot go from absent straight to done. Clearing completed items leaves the open ones alone. You cannot delete something that was never there. Nine lines, and when you've read them you have read the entire contract. Now go find that list for the system you work on. You can't. It doesn't exist. It's distributed across a test suite that asserts outcomes rather than rules, some validation scattered through handlers, and the memory of whoever's been there longest. The guarantees are real — your users depend on every one of them — and there is no file you can open to see them. That's the gap I want to talk about, because you can close it in an afternoon, and because something has changed recently that makes closing it pay for itself. The prime mark and two operators That's most of the syntax, so let's get it out of the way. tasks' means "tasks, in the next state." /\ is and . \E is "there exists." A definition like Complete(i) is a formula relating the current state to the next one — read it out loud: the task is open, and afterwards it is done. That's it. That's the language, near enough, for this purpose. The real file adds about eight lines of scaffolding around what you saw: a module header, a TypeOK saying a task is always in exactly one of the three states, and the two lines that tie the actions together — Next == \/ \E i \in Ids : Add(i) \/ Complete(i) \/ Reopen(i) \/ Delete(i) \/ ClearComplete

Your smart home is not smart. It is just very, very observant. I did not buy a smart speaker because I wanted a friend. I bought it because it was on sale for $29.99 and it promised to play rain sounds on command. For two years she lived on my kitchen counter. She set timers for pasta. She told me the weather with the aggressive optimism of someone who has never paid rent. She was helpful. She was ambient. She was furniture that could hear. And then one night at 2:17 a.m., she lit up blue for no reason. No wake word. No one speaking. Just a soft, smug blue ring in a dark apartment, listening to an empty room like she was waiting for me to confess something. That is the moment you understand your home is not just connected. It is attentive. And attentiveness without consent is just surveillance with better industrial design. We Carried Them In Ourselves No one kicked down the door. We invited this in. We carried it in from Best Buy, plugged it in, gave it our Wi-Fi password, which is literally the master key to our entire digital life, and whispered, here, learn my routines. We did it because convenience is a drug that hits faster than paranoia. Let's do an inventory of your very normal, very bugged apartment. Your TV watches you back. Modern smart TVs use Automatic Content Recognition. That is a polite, enterprise friendly way of saying your TV takes screenshots of everything you watch every few seconds and sells that ledger to advertisers. You agreed to it on page 47 of a menu you clicked through while trying to watch Love Island. Your robot vacuum maps your floor plan. It knows the square footage of your bedroom, how often you move the couch, and where you drop the most crumbs. That map is stored in the cloud. Your light bulbs log when you are home. Your smart plugs log when you are not. Your doorbell films every human who has ever had the courage to approach your front door, plus every dog walker who did not, and then it stores that footage on a server you do not

Recently, a man I was rock climbing with told me about how he'd used AI to make a motivational poster for himself, which he'd hung on his bedroom wall: a bear, walking a slackline over a canyon, holding a sign that said, "Do cool shit." I made what I hoped was a polite noise. What […]

Aptoide has become the first app store distributed inside Google Play under a judge's order.

Today, I’m talking with Lila Snyder, who is the CEO of Bose. You certainly know Bose — it’s one of the most famous brands in all of consumer tech. The company started 60 years ago selling speakers to consumers, and its focus on research and development has led it to be a leader in both […]

Boeing is selling three of its electric vertical takeoff and landing (eVTOL) subsidiaries to Archer Aviation, in addition to taking an undisclosed stake in the San Jose-based company. The subsidiares to be acquired by Archer include Wisk Aero, which has been developing an autonomous electric aircraft; SkyGrid, which is building air traffic management systems to […]

Discovered Materials raised $9 million to fund the hunt for more novel materials to build more efficient chips.

An AI interview is increasingly the first step of a hiring process. Since there’s no human on the other end, candidates are scheduling them whenever—even deep into the night.

Most businesses don't buy disconnected systems on purpose. They arrive one tool at a time. You start with a spreadsheet. You add a CRM because the spreadsheet stopped scaling. Accounting software because the taxman insisted. A shipping portal because you started sending parcels. Each choice was sensible on its own day. Then one morning you look up and realize that none of these tools talk to each other — and the thing holding them together is a person. Someone reads a number off one screen and types it into another. That person is your integration. And that's a cost you're paying every day without ever seeing it on an invoice. The Cost You Don't Get Billed For Here's the trap. The cost of a disconnected system doesn't show up anywhere you look. It's not a subscription. It's not a line item. It's hidden inside a job title. Someone on your team spends the first hour of every day taking yesterday's orders and copying them, one at a time, from the checkout into the accounting system, then into the CRM, then into the shipping portal. It feels like work, because it is. Nobody questions it, because it's always been done that way. But watch what actually happens as you grow. At ten orders a day, that copying is an hour. At thirty, it's most of a morning. At sixty, it's a full-time role whose entire purpose is retyping data that already exists somewhere else. You never made a decision to create that role. It grew on its own, one order at a time, and now it sets a limit: you can only take as many orders as one person can hand-transcribe before they burn out or start making mistakes. That's the real shape of the cost. It isn't the minutes. It's the ceiling. When a human is your integration, your growth is capped at the throughput of that human — and you'll experience the cap not as a cost, but as a vague sense that "we can't handle more right now." Where the Errors Live The second cost is quieter and more expensive: the mistakes. Anything a person copies by hand between two sy

Anyone can port a library. Point a translator at the source, clean up the output, get it to compile, and you have something that looks like a port. The actual engineering problem is different and much harder: proving that the new code means the same thing as the old code, across thirty algorithms, hundreds of edge cases, and a test suite written by people who were not thinking about you. This is the story of porting textdistance , a Python library for measuring string similarity, to Rust. The result is textdistance-rs . The porting took a fraction of the time. Everything else: the differential fuzzing, the 140 divergences, the 35 year old threshold I violated, the floating-point drift at the 15th decimal place, is what this writeup is actually about. Thirty algorithms and one architectural bet The original textdistance covers a lot of ground: edit-based distances (Levenshtein, Damerau-Levenshtein, Hamming, Jaro-Winkler), token-based measures (Jaccard, Sørensen-Dice, cosine, Tversky), sequence-based methods (LCS, Ratcliff-Obershelp), phonetic algorithms (MRA, Editex), and compression-based distances built on normalized compression distance. Over thirty algorithms in total, all reimplemented in Rust. But before writing a single algorithm, I had to make the decision that shaped everything downstream: how does the existing Python test suite (397 tests I did not write) talk to the Rust code? The obvious answer is PyO3: wrap every algorithm in a #[pyclass] , build a native extension, and the Python tests import Rust directly. The answer I chose instead was a subprocess CLI. The Rust core is a standalone binary that speaks JSON over stdin/stdout, and a thin Python adapter shells out to it: // The entire cross-language surface is one struct. #[derive(Deserialize)] struct Request { algorithm : String , s1 : String , s2 : String , qval : Option < usize > , external : Option < bool > , } fn dispatch ( req : & Request ) -> Response { match req .algorithm .as_str () { "hamming"

Between two great powers, when a neighbor presses you to follow, borrow its momentum. A cornered state will not believe your words. — The 36 Stratagems, Obtain safe passage to conquer the State of Guo Previously on this series: #10: Lena Watched a Team Adopt Her AI Template. Leo Didn't Know the Knife Was in the Contract. — Lena came to CoreStack as a consultant and built Leo's reporting template. Five weeks later the template went live and locked in six months of baseline data. Leo learned he'd been taken by a smile. #14: Leo Found an AI Leak. He Wasn't the First to Find It. — FinOptima was writing stolen training data back through its cache. Leo injected fifteen lines of weight drift. In the same logs he saw the name acl-train for the first time and filed it in his own _misc/ . #18: Leo Tracked an AI Signal to Derek. Both Were Looking for the Same Enemy. — Third Cup. An Americano sat on Derek's side. The private channel had been open since that night. #23: Alex Counted the AI's Hands. Lena Set the Bait. — The honeypot in the MediSys sandbox was touched twice by the same source, egress pointing at ACL's Singapore node. On the other side, Lena fed forged node-characteristic data into ACL's monitoring pipeline. Leo had run one interval comparison over the old channel. The conclusion was a single line, and it ended up in hands he didn't know. The Data The message arrived before dawn. The phone vibrated on the desk. Leo had just finished editing a block of code; the window was still on the editor. He didn't look right away; he waited for the build to finish, then picked up the phone. Last time, Derek had sent a few numbers and a comparison request: "Check this interval. Is it the pattern you know?" Leo replied with two words: send it. When the comparison was done, the conclusion stayed one line. Later that line went through other hands, source stripped, signature stripped. He never learned where it landed. Derek didn't say, and Leo didn't ask. This time was different. T

📌 TL;DR I'm still early in my own career, and lately I've been thinking about how much advice we...

Meme Monday! Today's cover image comes from the last thread. DEV is an inclusive space! Humor in...

From Learning to Teaching: Building Bitcoin Tools in Rust Susan Githaiga Susan Githaiga Susan Githaiga Follow Aug 10 From Learning to Teaching: Building Bitcoin Tools in Rust # rust # bitcoin # opensource # buidl4africa 1 reaction Add Comment 3 min read

Originally published on IFEELVOID . Play the song and count the pulse for 15 seconds. Multiply that number by four. If you counted 35 beats, the song is roughly 140 BPM. That is the fastest manual way to find the beat of a song. It is also where the confusion starts. A trap record at 140 BPM can feel like 70. A drumless intro can hide the pulse completely. A sample can drift. And knowing the tempo still does not tell you the musical key you need for bass lines, vocal tuning, remixes, or harmonic mixing. This guide gives you the manual method, the DAW method, and the faster analysis workflow I use when a session cannot stop for guesswork. First: what does “beat” mean? People use “beat” to describe three different things: The pulse: the steady count you nod your head to. The BPM: how many pulses happen in one minute. The instrumental: the drums, melody, bass, and arrangement behind a vocal. If you need the tempo and key so you can work with the audio, keep going. Method 1: count the BPM manually Find the strongest repeating pulse. In most trap and hip-hop records, start with the snare or clap. Count along for 15 seconds, then multiply by four. Start the song at a section where the drums are clear. Tap your foot or nod to the main pulse. Count every pulse for exactly 15 seconds. Multiply the count by four. Repeat once to make sure your count is stable. Twenty beats in 15 seconds is 80 BPM. Thirty beats is 120 BPM. Thirty-five beats is 140 BPM. Watch for half-time and double-time A beat can be represented at two mathematically correct tempos. A dark trap record may read as 70 BPM or 140 BPM depending on whether you count the slow backbeat or the faster production grid. Neither number is automatically wrong. Use the tempo that matches your purpose. Producers usually want the grid that makes drum placement and subdivisions easy. DJs may want the value that matches the rest of their library. Method 2: use tap tempo Most DAWs, DJ applications, and metronome tools include ta

Sadly, there hasn't been a new episode of No Dogs in Space since July of 2024. Part four of the podcast's series on Can wrapped up an abbreviated season three, which focused on experimental rock. Don't get me wrong, I loved seasons one and two, but the show seemed to be gearing up for a […]

Welcome back to TechCrunch Mobility, your hub for the future of transportation and now, more than ever, the role AI is playing in it.

Most performance advice online assumes a baseline that doesn't exist for most of the world. Fast wifi, a recent phone, a stable connection. Lighthouse scores optimized for conditions half the planet doesn't have. I build web products for businesses in Kenya. A meaningful share of my users are on 3G, sometimes 2G, often on a budget Android phone with limited storage and a browser that hasn't seen an update in a year. Here's what that actually changes about how you build. Your bundle size is a business decision, not a dev preference A 2MB JS bundle that loads instantly on your MacBook can take 15 to 20 seconds on a real 3G connection. That's not a slow load, that's a user who left before your app finished parsing. I've watched analytics confirm this directly, drop-off spikes exactly where bundle size peaks. Skeleton screens matter more than animations Every extra animated transition is more work for a weak CPU to render. I stripped most micro-interactions out of a recent build and page-perceived speed improved more than any code-splitting change I made that month. Motion is a luxury feature for people with headroom to spare. Offline isn't an edge case, it's Tuesday Connections drop mid-session constantly, not from bad code, just from the actual infrastructure. If your app throws away form state on a dropped connection, you're actively costing your users. Basic local persistence before submission became a non-negotiable for me after watching real users lose an entire booking form to a 4 second network blip. Images are still the biggest offender in 2026 Everyone optimized images years ago and moved on. They didn't. I still regularly find production sites shipping unoptimized hero images at 3 to 4MB. On a fast connection that's invisible. On the connections a huge share of the world actually uses, that single image can be the whole page load. The real point "Fast" isn't a Lighthouse score. It's whether the app actually works for the person holding the phone it's meant fo

GitHub热门项目 | Render JSX & HTML to image, SVG or PDF. 170+ CSS properties supported. Drop-in next/og replacement. | Stars: 2,737 | 15 stars today | 语言: Rust

GitHub热门项目 | A radically modular HTML/CSS rendering engine | Stars: 3,961 | 26 stars today | 语言: Rust