标签：#us

GitHub热门项目 | 🤱🏻 Turn any webpage into a desktop app with one command. | Stars: 50,088 | 72 stars today | 语言: Rust

I haven't written articles in quite a while and I recently decided to come back to it. At work I use AI daily, so a big part of my coding tasks are delegated to agents. I try not to do the same when it comes to writing text but I don't have a clear reason for that (or maybe I do and I don't want to admit it). I am sure people can take advantage of generating text with the help of AI but at the moment I feel like prompting would not save me any time and writing the text myself would be faster. What about you? Are you using AI to write your articles? Image credit - jessica olivella, on pexels

It's 2am. A pipe just let go behind a kitchen wall and water is coming through the ceiling into the room below. The homeowner is standing in the dark in a panic, phone in hand, Googling "emergency plumber near me." They tap the first number. It rings four times and drops to voicemail. They don't leave a message. They tap the second number. You were the first number. You were asleep. And you just lost the most profitable job you'd have booked all week to whoever picked up on the second ring. This is the part of running a plumbing business that nobody puts on a P&L. The call that matters most arrives at the exact moment no human is there to answer it. And in plumbing, unlike any other trade, that's not the exception. It's the majority of the work. Plumbing's problem is different from every other trade An HVAC shop bleeds during summer rush. A roofer loses jobs to slow follow-up over a three-week sales cycle. Plumbing is its own animal, because plumbing is emergency-driven, and emergencies don't keep business hours. Industry call-tracking data tells the story. Depending on the source, anywhere from 40% to over 70% of home-service calls land outside the standard nine-to-five window, and for emergency-driven trades like plumbing it skews to the high end of that range. Either way the takeaway is the same. A huge share of your inbound isn't coming in while someone's at the desk. It's coming in at night, on a Saturday, on Thanksgiving morning when a basement is filling with sewage. If you're staffed to answer the phone nine to five, you are structurally set up to miss a large slice of your own demand. Not because you're doing anything wrong. Because the work shows up when the lights are off. And here's what makes it brutal. The after-hours emergency call isn't just any job. It's your best one. Why the missed emergency call costs more than the tech A routine daytime service call, a dripping faucet, a running toilet, runs a couple hundred dollars and the customer is happy to

GitHub热门项目 | Community-built comprehensive 2D content creation appplication for graphic design, digital art, and interactive real-time motion graphics powered by a node-based procedural graphics engine | Stars: 26,198 | 18 stars today | 语言: Rust

GitHub热门项目 | Build system optimized for JavaScript and TypeScript, written in Rust | Stars: 30,507 | 9 stars today | 语言: Rust

GitHub热门项目 | Per-process network monitoring for your terminal with deep packet inspection. Cross-platform, sandboxed. | Stars: 4,287 | 46 stars today | 语言: Rust

GitHub热门项目 | IronClaw is an Agent OS focused on privacy, security and extensibility | Stars: 12,409 | 9 stars today | 语言: Rust

Based on real software development trends. About a VP of Engineering who believed AI would verify its own output, 47 TODOs that shipped to production, and a $2,800,000 discount calculation error that nobody caught. This story is based on a submission from a community member. If you have a similar story or something you need to get off your chest — reach out. The next one could be yours. Act 1 · The Tech Meeting "Starting today — no more hand-written code." Marcus, the new VP of Engineering, put a slide up on the big screen. Four words: WRITING BY HAND IS OVER. I was sitting in the back row, against the wall. Seven years at this company. Three core modules that I'd built from scratch. Two production systems that ran the company's primary revenue stream. Now someone was telling me — don't write anymore. The room went quiet for about five seconds. Then people started whispering. Someone pulled out a phone and took a picture of the slide. Marcus added: "AI coding isn't optional — it's a mandatory development standard. We benchmarked this. AI writes code 400% faster than humans. Anyone still typing manually is wasting the company's time." I raised my hand. "Who reviews the code?" "AI reviews it." "Who writes the tests?" "AI tests itself." "What if AI writes something wrong?" Marcus laughed. Not a polite laugh. The kind of laugh you give someone whose question you've already decided doesn't matter. "Let me ask you something." He paused. "Do you really think — you, one person — have more training data than Orion-7? " People started laughing. Not supportive laughter. Pile-on laughter. "Or do you think the world's AI companies — hundreds of billions in investment, tens of thousands of GPUs — built something that's less reliable than one backend developer?" Nobody was looking at me anymore. Everyone was watching him, waiting for the kill shot. He didn't take it. He just smiled. "Starting next sprint, it's AI across the board. Anyone who has concerns — my door's open." Act 2 ·

AWS recently announced ExtendDB, a DynamoDB-compatible adapter that lets developers use the DynamoDB API with different storage backends, starting with PostgreSQL. The project supports existing SDKs and tools without modification, giving teams greater flexibility to run DynamoDB-style workloads outside of native DynamoDB while maintaining compatibility with current applications and workflows. By Renato Losio

Nobody wants to hear this. But the reason your software is hard to change, hard to test, and hard to explain to a new engineer isn't your tech stack. It's that your code doesn't reflect how your business actually works. Your engineers are using one word — "customer," "order," "student," "subscriber" — and meaning six different things depending on which part of the system they're touching. Your domain expert says "order" and means something completely different from what your database schema says "order" is. That gap? That's where complexity lives. That's where bugs are born. That's where senior engineers spend their Fridays. Domain-Driven Design is the discipline of closing that gap. Here's what it actually means, practically, without the academic noise. The Core Problem: One Model Trying to Mean Everything Imagine a map that tried to show subway routes, underwater hazards, hiking trails, and flight paths — all at once. It would be useless. A subway map works because it only shows what matters for navigating trains. A nautical chart works because it only shows what matters for sailing. Each map is an abstraction built for a specific purpose, valid within a specific context. Your software models need to work the same way. The moment you build a single "Customer" class that has to satisfy your billing team, your marketing team, your support team, and your logistics team simultaneously — that class becomes a bloated, ambiguous disaster. Everyone adds their fields. Nobody removes anything. The model stops meaning anything specific to anyone. This is the monolithic model trap. And most large codebases are sitting right inside it. Strategic Design: Understand the Problem Before You Touch Code DDD separates design into two layers. Strategic design comes first — it's the work you do before writing a single line of code. Step 1: Find Your Subdomains A subdomain is a slice of the business problem. Ordering. Shipping. Notifications. Payments. Inventory. These aren't your micro

I have a side habit. When I run out of ideas for what to build next, I do not open Twitter or Product Hunt. I open Reddit. There are about thirty subs where the same complaint comes up every week. Someone describes a workflow they hate, asks if a tool exists, and a commenter says "I wish, please tell me if you find one." That second comment is the cofounder you do not need to pay. Here are 5 I pulled from threads in the last few months. Each one has a real Reddit post behind it, real search volume on the keyword someone would type into Google, and a wedge small enough to build over a weekend. None of these are billion-dollar ideas. All of them could be a $2k MRR side project if you actually shipped. 1. Invoice reminders for trade contractors "i know the title sounds made up. invoice reminders for plumbers. $14K a month. but that's exactly why it works. nobody is competing for this." r/passive_income, 3,653 upvotes Search demand: 7,200 monthly searches for "invoice reminder software" and adjacent terms. Why it works: plumbers, electricians, and HVAC techs send invoices and then forget about them. Their customers also forget. Nobody wants to be the awkward one chasing money. A scheduled email or SMS sequence converts ghosted invoices into paid ones. The buyer is one tradesperson, the value is measured in actual dollars recovered, and the competition is QuickBooks (terrible at this) or nothing. Wedge: a single Stripe-or-QBO connector that sends a polite nudge at day 7, a firmer one at day 14, and a "final notice" template at day 30. Charge $19 a month. 2. Field service software for solo tradespeople "Is there field service management software that doesn't assume you have a team? I run residential HVAC solo, sometimes one helper when it gets busy. Everything I've tried is built for dispatching crews." r/EntrepreneurRideAlong Search demand: 8,800 monthly searches for "field service management software" with solo and small-business modifiers. Why it works: Jobber, Houseca

This field test was against Kubernetes. The issue was Kubernetes #138728: https://github.com/kubernetes/kubernetes/pull/139545 The issue involved the watch cache path around initial events. The useful diagnostic boundary was: watch cache consistency work → read lock hold time → initial event delivery That matters because cache paths in Kubernetes are not just storage details. They sit between stored state and the clients watching that state. If too much work happens while a cache lock is held, the system may still be logically correct, but the operational path can become more expensive, more blocking, or harder to scale than it needs to be. The local repair candidate is intentionally narrow. It does not redesign the watch cache. It does not change the broader storage model. It does not rewrite WatchList behavior. The patch focuses on reducing how much work happens while the watch-cache read lock is held. For ordered stores, the repair keeps the cheap snapshot boundary during interval construction, but defers full ordered list materialization until the interval is consumed by the watcher path. In plain terms: Take the necessary cache boundary under lock. Do not do heavier list materialization there if it can be safely deferred. The local patch touched only the watch-cache interval implementation and its focused tests. Local validation passed for the relevant cacher tests, store tests, full cacher package tests, and diff hygiene. Status: draft PR opened for maintainer review Field Test #013 Project: Kubernetes Issue type: watch-cache / initial-events behavior Boundary: cache consistency work under lock vs bounded watcher consumption Result: narrow local repair candidate and focused test coverage Status: local proof prepared; no public PR or comment opened yet This field test matters because it shows Scarab operating inside a major distributed systems platform. The bug shape was not a simple crash. It was not a UI issue. It was not a configuration mismatch. It was a me

If you are a Software Developer of some form or another, chances are that you follow what are considered best practices for "Clean Code"or "Clean Architecture". It's considered generally best practice according to these books to keep functions down to a few lines, ensure classes have exactly one reason to change, and wrap implementation details behind abstract interfaces. It’s an approach designed to isolate responsibilities and keep the long-term cost of software modifications flat. Yet, as codebases grow under this paradigm, engineers frequently encounter a subtle friction. In the drive to decouple every moving part, applications often accumulate a massive web of boilerplate and multi-layered abstractions. This raises a fundamental question: does hyper-decomposing code actually reduce complexity, or does it simply scatter it across dozens of shallow files, making a single linear operation difficult to follow? This article revisits the baseline assumptions of Clean Architecture by examining a growing yet subtly different software design philosophy championed by systems engineers and computer science pragmatists. We will explore how different software environments define code quality, look at actual case studies of algorithmic decomposition, and map out alternative patterns like John Ousterhout's "Deep Modules." Along the way, we will examine how our design choices interact with mathematical correctness proofs, functional programming paradigms, and a modern toolchain increasingly driven by automated AI agents. The bubbles that shape your opinions The frameworks championed by the "Clean" movement were largely forged in the world of large-scale corporate IT consulting. They were explicitly designed to manage risk in massive organizations where hundreds of engineers with varying levels of experience write code against a single, shared repository. In a setting like a sprawling insurance platform or a legacy banking app with shifting corporate rules, Clean Architecture s

This field test was against Next.js. The issue was Next.js #94450: https://github.com/vercel/next.js/issues/94450 The reported problem involved production browser source maps when React Compiler and Turbopack were involved. The visible symptom was that the final browser source map could expose transformed compiler output instead of preserving the original client source content. That matters because source maps are not just debugging extras. They are provenance artifacts. They tell the developer what source the browser output came from. If a source map claims to represent a source file but its sourcesContent contains compiler-transformed output instead of the original file content, then the debugging artifact has drifted from the source truth it is supposed to preserve. The useful diagnostic boundary was: original client source → transform source map → Turbopack source-map composition → final browser chunk map The important proof was that the Babel/React Compiler transform itself could produce a source map whose sourcesContent still represented the original client file. So the loss was not simply: React Compiler changed the code The sharper issue was: the browser source-map composition path was not preserving original source authority all the way into the final artifact That made the repair lane much narrower. The local repair candidate has two parts: Preserve the original loader input source in the Babel loader transform map. Fill missing source-map file provenance from the origin path when an incoming transform map omits it, so Turbopack has enough identity information to match the transform map back to the generated intermediate file during composition. The goal is not to rewrite source-map behavior broadly. It is not to patch the final browser map after the fact. It is to preserve source authority at the point where the transform map is composed into the browser artifact. A regression fixture was added around a React Compiler client component with an original sou

I've been building a database engine from scratch in Rust, and I recently finished the lexer. The lexer itself wasn't the most interesting part. What I found more valuable was how my design evolved as I learned more about Rust and how compilers and database systems are typically implemented. My First Approach When I started, I stored the input as a Vec<char> . It felt straightforward because I could access characters directly without worrying about UTF-8 boundaries. I also represented identifiers like this: Ident ( String ) At first glance, this seems perfectly reasonable. Every identifier token carries its own text, making it easy for the parser to consume. The Problem As the lexer grew, I started asking myself a simple question: The identifier already exists in the original SQL query. Why am I allocating another string and copying the same data into every token? For a query like: SELECT username , email FROM users ; the source text already contains: username email users Creating separate String allocations for each identifier means duplicating data that already exists. I also learned an important detail about Rust enums. The size of an enum is influenced by its largest variant. Once variants start carrying additional data, every token instance becomes larger than it otherwise needs to be. Moving to a Span-Based Design Instead of storing identifier text directly inside tokens, I switched to storing only the token kind: Ident along with source location information: Span { start , end , line , column , } Now the token only answers two questions: What is this token? Where did it come from? If the parser needs the actual identifier text, it can recover it directly from the original SQL source using the stored byte range. Replacing Vec<char> with &str The second design change was moving away from: Vec < char > and operating directly on: & str using lifetimes. Instead of creating another collection containing the entire input, the lexer now walks over borrowed source tex

GitHub热门项目 | A modern runtime for JavaScript and TypeScript. | Stars: 106,979 | 15 stars today | 语言: Rust

GitHub热门项目 | 🥧 Savoury implementation of the QUIC transport protocol and HTTP/3 | Stars: 11,540 | 7 stars today | 语言: Rust

We are exploring an experimental blockchain mechanism called "Proof of Weather" In the world of blockchain, various methods are used to achieve network consensus. The most well-known is Bitcoin’s Proof of Work (PoW). While PoW is an excellent mechanism, it has one major drawback. It consumes an enormous amount of electricity. At one point, I found myself wondering: Does blockchain really require such vast computational resources? Isn’t there something else that’s needed? This led to the creation of Dawn, the experimental cryptocurrency project I am developing, and an experimental blockchain mechanism called Proof of Weather. In this article, I will discuss: Why I decided to use weather How Proof of Weather works Security considerations Implementation in Rust How Does Proof of Work Work? Proof of Work is often explained as a mechanism where computers compete against each other in computational tasks. However, one important property of PoW is that it produces outcomes that are difficult to predict in advance. Miners repeatedly perform massive amounts of hash calculations, and only those who happen to meet the conditions can generate a block. This unpredictability plays a role in determining who can produce the next block. However, this process consumes enormous amounts of electricity worldwide. So I wondered: Aren’t there already phenomena in nature that are difficult to predict? Why Weather? Proof of Weather utilizes weather data as that unpredictable element. Of course, weather forecasts exist. However, Temperatures several days in the future Atmospheric pressure at specific locations Precipitation Wind speed and other factors cannot be predicted with absolute certainty. In particular, when combining observations from multiple locations, it becomes even more difficult to accurately calculate future values in advance. In other words, meteorological observations have the potential to be used as A real-world information source where future values cannot be fully predic

New simulations reveal that the moons of Uranus may retain traces of giant planets.

AI Does Not Cancel Reality I watched the conversation between Mo Gawdat and Marina Mogilko about the future of AI. The conversation is strong. It contains important ideas, but it also contains many claims that sound large in scale, although on closer inspection they rely on very broad generalizations. AI is indeed changing the labor market, education, startups, content, hiring, and ways of thinking. But it does not cancel money, connections, trust, the human vector, creativity, necessity, morality, or people’s ability to adapt. Video on YouTube AI in hiring: automation amplifies chaos Many people have entered the job market. Companies receive huge volumes of resumes. HR departments cannot handle the volume. It is natural that part of the selection process is moving to AI. But there is a serious problem here. Candidates are also starting to play against AI. Resumes are adjusted to vacancies. Cover letters are assembled around keywords. Profiles become optimized for the filter, not for real work. In such a system, the best specialist does not necessarily pass. Often, the person who understood the selection mechanism better passes. The result: the picture becomes cleaner, while the quality of the decision becomes lower. The company gets not the strongest candidate, but the candidate who matched the algorithm best. This leads to lower hiring quality, lower productivity, and slower development. “I built a startup in six weeks”: a product is not a startup The conversation includes the idea that an AI startup would once have taken years and hundreds of engineers, and now it can be built in weeks. Technically, this is true. Prototypes are now built faster. Small teams have powerful tools. One person can now do more than a group could do before. But two different things are mixed here. Building a product faster has become real. Building a startup faster has become real only when resources are present. A startup is not only code. A startup is money, connections, trust, reputa