标签：#p

Bryan Oliver discusses the frontier of AI infrastructure: chaos engineering for large-scale GPU clusters. He shares how engineering leaders can handle complex topologies, network protocols like RDMA, and NUMA misalignments. Discover seven practical fault-injection strategies to maximize multi-million dollar hardware efficiency and build robust observability loops. By Bryan Oliver

It follows reports of 100,000 jobs being under threat at the German automaker.

China made a breakthrough in its space program with the successful capture of a Long March 10B rocket booster.

GitHub热门项目 | Delightful JavaScript Testing. | Stars: 45,535 | 81 stars today | 语言: TypeScript

GitHub热门项目 | The official Python library for the OpenAI API | Stars: 31,211 | 92 stars today | 语言: Python

GitHub热门项目 | CLI tool for configuring and monitoring Claude Code | Stars: 28,654 | 104 stars today | 语言: Python

GitHub热门项目 | Asio C++ Library | Stars: 6,035 | 87 stars today | 语言: C++

GitHub热门项目 | A modern, C++-native, test framework for unit-tests, TDD and BDD - using C++14, C++17 and later (C++11 support is in v2.x branch, and C++03 on the Catch1.x branch) | Stars: 20,570 | 69 stars today | 语言: C++

GitHub热门项目 | Skills for Real Engineers. Straight from my .claude directory. | Stars: 164,017 | 1,728 stars today | 语言: Shell

GitHub热门项目 | A YAML parser and emitter in C++ | Stars: 6,050 | 65 stars today | 语言: C++

GitHub热门项目 | Abseil Common Libraries (C++) | Stars: 17,472 | 3 stars today | 语言: C++

While fully loaded models are quite pricey, the HP OmniBook Ultra is hard to beat for those in the market for a premium Windows ultraportable.

Builder Journal · ARC Prize 2026 There is a moment in every role-playing game where you load your character with so much heavy gear that they can barely walk. Strongest sword in the game, can't reach the fight. I did the machine-learning version of that this month. I kept making my agent more capable, and the scoreboard kept punishing me for it, and it took me two tries to understand that the upgrades were the problem. A quick frame, in case this is your first entry in this thread : I'm in the ARC Prize 2026, building an agent that has to learn small games it has never seen, with no instructions. As the benchmark's creator measured it, the hardest part by far is the piece that figures out the rules of a game by experimenting on it. So that piece is where I have been pouring my effort. The obvious upgrade The obvious way to make that piece better is to teach it more kinds of games. If it can model three families of puzzle today, teach it a fourth, and it should win more. So I did exactly that. I built support for a new class of game it could recognize and solve, wrote it carefully, tested it, and confirmed the thing I wanted to confirm: the agent now beat a game it provably could not beat the day before. Real, verified, new capability. Not a story I was telling myself, a genuine new skill on the board. Then I submitted, and the score went down. Twice This is the part I want to be honest about, because one bad result is noise and two is a pattern. My agent's attempts to use this theory-building component had already been underwhelming on the real board, landing around 0.05, 0.07, and 0.09 across earlier tries, all of them under the 0.25 my plain, careful agent scores when it does not reach for the fancy component at all. The fourth skill was supposed to turn that corner. Instead the next submission came in at 0.04, the worst of the lot. I had added ability and the number had dropped, again. So I stopped adding and started counting. I ran a survey across twenty-five of

It's Friday evening. An endpoint that normally answers in 200 milliseconds is suddenly taking eight seconds. You open Grafana. Every graph is green. CPU is calm, memory is fine, the disk isn't full. By every dashboard you have, the database is healthy. It is not healthy. This is the failure mode monitoring is worst at: the server is unmistakably alive , so nothing alerts, while inside the database something is slowly rotting. A table has bloated. An index nobody uses is dragging down every INSERT . A forgotten transaction is sitting open, holding a lock and quietly making everything worse. None of it crashes. It just degrades, a little at a time, until one Friday evening it tips over. The good news is that Postgres will tell you all of this — you just have to ask. The queries below run on bare PostgreSQL (13 or newer; one version note along the way), need no agent and no paid monitoring, and use an extension in exactly one place where it genuinely earns it. Open psql and check your own database as you read. 1. The cheapest signal: dead rows Start here, because it costs nothing and catches the most. Postgres never deletes a row in place. An UPDATE or DELETE leaves behind a dead tuple — an old version of the row — and autovacuum cleans those up later. Until it does (or if it can't keep up), the dead rows sit in the table, taking space and forcing every scan to page past them. The fastest look is pg_stat_user_tables , always available, no extension: SELECT schemaname , relname AS table , n_live_tup , n_dead_tup , round ( n_dead_tup * 100 . 0 / nullif ( n_live_tup + n_dead_tup , 0 ), 1 ) AS dead_ratio , last_autovacuum FROM pg_stat_user_tables WHERE n_dead_tup > 0 ORDER BY n_dead_tup DESC LIMIT 20 ; A dead_ratio above ~20% on a large table is worth investigating. And watch for a table where the ratio is high and last_autovacuum is empty — that means autovacuum has never successfully run on it, which is its own red flag (we'll see why in section 5; the whole story conver

Understanding Observability with the LGTM Stack From "what happened last night?" to "here's exactly what happened and why" — in under 5 minutes Table of Contents Introduction What Is Observability? The Three Pillars of Observability Metrics Logs Traces Why You Need All Three Together The LGTM Stack Architecture: How It All Fits Together OpenTelemetry: The Instrumentation Standard The OTel Collector: The Brain of the Pipeline Loki: Log Aggregation Tempo: Distributed Tracing Mimir: Metrics at Scale Grafana: Connecting the Dots Conclusion Introduction Let me tell you a story that probably sounds familiar. It's 2 AM on a Sunday. Your API is slow. Users are complaining. But you're not at your desk — you're in a Sleeping, or just living your life. You have no idea it's even happening. The next morning you walk into the office and your boss meets you at the door. "Hey, the API was really slow yesterday around 2 AM. What happened?" And you're stuck. Completely stuck. You pull up the server logs — it's a wall of unformatted text. Maybe the issue already fixed itself. Maybe the container restarted overnight and the logs are gone. You weren't there, and your system left no trail. So you say the thing every developer dreads saying: "I don't know. I'll look into it." Now imagine the exact same situation — but this time you have observability set up. You open your dashboard, set the time range to yesterday 2 AM, and within two minutes you can see everything. Response times spiked to 4 seconds. The database connection pool got exhausted. And it started the exact moment a scheduled batch job kicked off and hammered the DB with hundreds of queries at once. You have a graph. You have traces. You have the exact log line that caused it. You walk back to your boss with your laptop: "Here's what happened and here's the fix." That's observability. Your system tells its own story — even when you're not watching. That's what this blog is about. I'll walk you through what observability actua

Everyone talks about AI writing code. Nobody talks about AI debugging code. Bad error messages are the worst, we've all seen them. You open the logs or run your program and see something like this... Error: something went wrong It leaves you asking: What happened? Where did it happen? Why did it happen? How do I fix it? You might have written some of these pretty silly error messages, I know I have. They don't help us fix software quickly because we first have to figure out why the error happened. Rust has been shipping fantastic error messages for years. Take this example where I accidentally call println instead of println! . $ cargo run 101 ↵ Compiling ducksay v0.2.0 (~/oss/ducksay) error[E0423]: expected function, found macro `print` --> src/main.rs:51:3 | 51 | print("{}", render_with_style(&message, cli.width.get(), style)); | ^^^^^ not a function | help: use `!` to invoke the macro | 51 | print!("{}", render_with_style(&message, cli.width.get(), style)); | It's fantastic! It tells you what went wrong, where it occurred, and how to fix it. When you're building software, you should make your error messages exceptional (punny 😂). Here's another example from Vite+ where I had a syntax error in the config file. $ vp dev failed to load config from ~/oss/test-ssr-on-aws/vite.config.ts error when starting dev server: Error: Build failed with 1 error: [PARSE_ERROR] Error: Unexpected token ╭─[ vite.config.ts:5:3 ] │ 5 │ , │ ┬ │ ╰── ───╯ Now imagine debugging code with generic error messages that tell you absolutely nothing helpful. You'll have to manually trace through the code to figure out what the heck is going on. AI agents run into the same problem. If the error tells them almost nothing, they have to spend extra time reading files, tracing execution paths, and making additional tool calls just to understand what failed. So what can we do to help humans and AI? Here are some of my top recommendations for writing good error messages. 1. Be descriptive and specific W

Hello Dev Community! 👋 It is officially Day 128 of my software engineering marathon! Today, I tackled an essential lifecycle design challenge in modern frontend development: managing persistent browser loops, orchestrating ticking background workers, and mastering Timer Cleanups inside the useEffect Hook ! ⚛️⏱️💻 I put these architectural paradigms into action by engineering a lightweight, responsive Real-Time Clock Application that tracks exact server-client time down to the second without triggering rogue background processor spikes! 🛠️ Deconstructing the Day 128 Asynchronous Scheduler As captured across my clean system workspace configurations in "Screenshot (286).png" and "Screenshot (287).png" , the scheduling mechanism enforces strict resource allocation: 1. Initializing Reactive Temporal State Managed our standard state anchor using native JavaScript runtime Date models to trigger instant re-renders upon completion of each interval cycle: javascript const [time, setTime] = useState(new Date());useEffect(() => { let intervalId = setInterval(() => { setTime(new Date()); }, 1000);

Hello Dev Community! 👋 It is officially Day 127 of my software engineering marathon! Today, I leveled up my asynchronous data pipeline in React.js by tackling a critical production-grade performance problem: avoiding memory leaks and managing component unmounting states using the useEffect Cleanup function alongside the native browser AbortController API ! ⚛️🛡️⚡ Additionally, I integrated a fully responsive async loading engine to drastically improve our overall User Experience (UX). 🛠️ Deconstructing the Day 127 Network Boundary Control As shown inside my refactored workspace code layout across "Screenshot (283)_2.png" and "Screenshot (284)_2.png" , the side-effect layer is now safe from ghost background executions: 1. Ingesting the Abort Signal API Inside the lifecycle layer, before initiating the endpoint call, I instantiated an active execution cancellation anchor on Lines 12-13 inside PostContainer.jsx : javascript const controller = new AbortController(); const signal = controller.signal;

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

Hello Dev Community! 👋 It is officially Day 125 of my software engineering marathon! Today, I crossed an elite milestone in frontend data architecture: moving completely away from local hardcoded mock lists by connecting my centralized state management infrastructure to live third-party servers using the Fetch API alongside Async/Await ! ⚛️🌐⚡ Now, the social media feed dynamically handles server-side data models, passes payloads to an active state reducer, and broadcasts states down to presentation layers via a custom Context portal! 🛠️ Deconstructing the Day 125 Async Network Lifecycle As shown inside my development setup across "Screenshot (279).png" , "Screenshot (280).png" , and "Screenshot (281).png" , the application state engine is clean and modular: 1. Extensible Central State Reducers ( PostList.jsx ) Engineered explicit structural actions inside the reducer core to seamlessly support both user generation and full-scale network array overriding: javascript } else if (action.type === "NEW_INITIAL_POSTS") { NewPostValue = action.payload.posts; }