AMD GAIA 0.16 introduces C++17 agent framework for building AI PC agents in pure C++
https://www.reddit.com/r/programming/comments/1rncnnk/amd_gaia_016_introduces_c17_agent_framework_for/

submitted by /u/Fcking_Chuck (https://www.reddit.com/user/Fcking_Chuck)
[link] (https://www.phoronix.com/news/AMD-GAIA-0.16) [comments] (https://www.reddit.com/r/programming/comments/1rncnnk/amd_gaia_016_introduces_c17_agent_framework_for/)

<!-- SC_OFF -->Been going back and forth on this for a while. The common wisdom these days is "just use Virtual Threads, reactive is dead", and honestly it's hard to argue against the DX argument. But I kept having this nagging feeling that for workloads mixing I/O and heavy CPU (think: DB query -> BCrypt verify -> JWT sign), the non-blocking model might still have an edge that wasn't showing up in the benchmarks I could find. The usual suspects all had blind spots for my use case: TechEmpower (https://github.com/TechEmpower/FrameworkBenchmarks) is great but it's raw CRUD throughput, chrisgleissner's loom-webflux-benchmarks (https://github.com/chrisgleissner/loom-webflux-benchmarks) (probably the most rigorous comparison out there) simulates DB latency with artificial delays rather than real BCrypt, and the Baeldung article on the topic (https://www.baeldung.com/java-reactor-webflux-vs-virtual-threads) is purely theoretical. None of them tested "what happens when your event-loop is free during the DB wait, but then has to chew through 100ms of BCrypt right after". So I built two identical implementations of a Spring Boot account service and hammered them with k6. The setup Stack A: Spring WebFlux + R2DBC + Netty Stack B: Spring MVC + Virtual Threads + JDBC + Tomcat i9-13900KF, 64GB DDR5, OpenJDK 25.0.2 (Temurin), PostgreSQL local with Docker 50 VUs, 2-minute steady state, runs sequential (no resource sharing between the two) 50/50 deterministic VU split between two scenarios Scenario 1 - Pure CPU: BCrypt hash (cost=10), zero I/O WebFlux offloads to Schedulers.boundedElastic() so it doesn't block the event-loop. VT just runs directly on the virtual thread. WebFlux VT median 62ms 55ms p(95) 69ms 71ms max 88ms 125ms Basically a draw. VT wins slightly on median because there's no dispatch overhead. WebFlux wins on max because boundedElastic() has a larger pool to absorb spikes when 50 threads are all doing BCrypt simultaneously. Nothing surprising here, BCrypt monopolizes a full thread in both models, no preemption possible in Java. Scenario 2 - Real login: SELECT + BCrypt verify + JWT sign WebFlux VT median 80ms 96ms p(90) 89ms 110ms p(95) 94ms 118ms max 221ms 245ms WebFlux wins consistently, −20% on p(95). The gap is stable across all percentiles. My read on why: R2DBC releases the event-loop immediately during the SELECT, so the thread is free for other requests while waiting on Postgres. With JDBC+VT, the virtual thread does get unmounted from its carrier thread during the blocking call, but the remounting + synchronization afterward adds a few ms. BCrypt then runs right after, so that small overhead gets amplified consistently on every single request. Small note: VT actually processed 103 more requests than WebFlux in that scenario (+0.8%) while showing higher latency, which rules out "WebFlux wins because it was under less pressure". The 24ms gap is real. Overall throughput: 123 vs 121 req/s. Zero errors on both sides. Caveats (and I think these matter): Local DB, same machine. With real network latency, R2DBC's advantage would likely be more pronounced since there's more time freed on the event-loop per request Only 50 VUs, at 500+ VUs the HikariCP pool saturation would probably widen the gap further Single run each, no confidence intervals BCrypt is a specific proxy for "heavy CPU", other CPU-bound ops might behave differently Takeaway If your service is doing "I/O wait then heavy CPU" in a tight loop, the reactive model still has a measurable latency advantage at moderate load, even in 2026. If it's pure CPU or light I/O, Virtual Threads are equivalent and the simpler programming model wins hands down. Full report + methodology + raw k6 JSON: https://gitlab.com/RobinTrassard/codenames-microservices/-/blob/account-java-version/load-tests/results/BENCHMARK_REPORT.md <!-- SC_ON --> submitted by /u/Lightforce_ (https://www.reddit.com/user/Lightforce_)

[link] (https://gitlab.com/RobinTrassard/codenames-microservices/-/blob/account-java-version/load-tests/results/BENCHMARK_REPORT.md) [comments] (https://www.reddit.com/r/programming/comments/1rnda23/i_couldnt_find_a_benchmark_testing_webflux_r2dbc/)

I ported Daniel Lemire's fast_float to c99
https://www.reddit.com/r/programming/comments/1rnswm5/i_ported_daniel_lemires_fast_float_to_c99/

<!-- SC_OFF -->It's a single-header drop in that's been exhaustively tested against the fast_float suite and is benchmarking slightly faster than the cpp. simd, portable, single-header, no allocation, so hot right now <!-- SC_ON --> submitted by /u/foobear777 (https://www.reddit.com/user/foobear777)
[link] (http://github.com/kolemannix/ffc.h) [comments] (https://www.reddit.com/r/programming/comments/1rnswm5/i_ported_daniel_lemires_fast_float_to_c99/)

Looking for textbook📚: Finite Automata and Formal Languages: A Simple Approach, by A. M. Padma Reddy, published by Pearson Education India. 📚
https://www.reddit.com/r/programming/comments/1rnu1d1/looking_for_textbook_finite_automata_and_formal/

<!-- SC_OFF -->Hi everyone, My university syllabus for Theory of Computation / Automata Theory recommends the book: Finite Automata and Formal Languages: A Simple Approach — A. M. Padma Reddy Has anyone here used this book before or know where I could: • access a legal PDF or ebook
• borrow it through a digital library
• find lecture notes or alternative books that cover the same topics If not, I'd also appreciate recommendations for good alternative textbooks covering: Module I: Introduction to Finite Automata Central Concepts of Automata Theory Deterministic Finite Automata (DFA) Nondeterministic Finite Automata (NFA) Applications of Finite Automata Finite Automata with ε-Transitions Module II: Regular Expressions Regular Languages Properties Module III: Properties of Regular Languages Context-Free Grammars Module IV: Pushdown Automata Context-Free Languages Module V: Turing Machines Undecidability Any help or recommendations would be appreciated. Thanks! 🙏 Thanks in advance! 📚 <!-- SC_ON --> submitted by /u/Broad-Ad2003 (https://www.reddit.com/user/Broad-Ad2003)
[link] (https://www.google.com/search?q=Finite+Automata+and+Formal+Languages%3A+A+Simple+Approach%2C+by+A.+M.+Padma+Reddy&rlz=1C1VDKB_enIN1111IN1112&oq=Finite+Automata+and+Formal+Languages%3A+A+Simple+Approach%2C+by+A.+M.+Padma+Reddy&gs_lcrp=EgZjaHJvbWUyBggAEEUYOTIGCAEQRRhBMgYIAhBFGEEyBggDEEUYPDIGCAQQRRhB0gEHNjQzajBqN6gCALACAA&sourceid=chrome&ie=UTF-8) [comments] (https://www.reddit.com/r/programming/comments/1rnu1d1/looking_for_textbook_finite_automata_and_formal/)

Avoiding Modern C++ | Anton Mikhailov
https://www.reddit.com/r/programming/comments/1rnu5lj/avoiding_modern_c_anton_mikhailov/

submitted by /u/BlueGoliath (https://www.reddit.com/user/BlueGoliath)
[link] (https://www.youtube.com/watch?v=ShSGHb65f3M) [comments] (https://www.reddit.com/r/programming/comments/1rnu5lj/avoiding_modern_c_anton_mikhailov/)

BlockLike: Bridging the gap between block programming and JavaScript.
https://www.reddit.com/r/programming/comments/1rnvmk7/blocklike_bridging_the_gap_between_block/

submitted by /u/ronilan (https://www.reddit.com/user/ronilan)
[link] (https://github.com/ronilan/BlockLike) [comments] (https://www.reddit.com/r/programming/comments/1rnvmk7/blocklike_bridging_the_gap_between_block/)

Some Words on Wigglypaint
https://www.reddit.com/r/programming/comments/1rnw0h5/some_words_on_wigglypaint/

submitted by /u/rogual (https://www.reddit.com/user/rogual)
[link] (https://beyondloom.com/blog/onwigglypaint.html) [comments] (https://www.reddit.com/r/programming/comments/1rnw0h5/some_words_on_wigglypaint/)

LLM-driven large code rewrites with relicensing are the latest AI concern
https://www.reddit.com/r/programming/comments/1ro2w8v/llmdriven_large_code_rewrites_with_relicensing/

submitted by /u/Fcking_Chuck (https://www.reddit.com/user/Fcking_Chuck)
[link] (https://www.phoronix.com/news/Chardet-LLM-Rewrite-Relicense) [comments] (https://www.reddit.com/r/programming/comments/1ro2w8v/llmdriven_large_code_rewrites_with_relicensing/)

Quantum simulates properties of the first-ever half-Möbius molecule, designed by IBM and researchers
https://www.reddit.com/r/programming/comments/1ro3f3a/quantum_simulates_properties_of_the_firstever/

submitted by /u/donutloop (https://www.reddit.com/user/donutloop)
[link] (https://research.ibm.com/blog/half-mobius-molecule) [comments] (https://www.reddit.com/r/programming/comments/1ro3f3a/quantum_simulates_properties_of_the_firstever/)

OSS Coding Agent with Self-hosted LLM: own the whole stack with Opencode and vLLM
https://www.reddit.com/r/programming/comments/1ro3tl5/oss_coding_agent_with_selfhosted_llm_own_the/

submitted by /u/RelevantEmergency707 (https://www.reddit.com/user/RelevantEmergency707)
[link] (https://cefboud.com/posts/coding-agent-self-hosted-llm-opencode-vllm/) [comments] (https://www.reddit.com/r/programming/comments/1ro3tl5/oss_coding_agent_with_selfhosted_llm_own_the/)

NestJS is a bad Typescript framework
https://www.reddit.com/r/programming/comments/1ro40xj/nestjs_is_a_bad_typescript_framework/

submitted by /u/SkaceKachna (https://www.reddit.com/user/SkaceKachna)
[link] (https://blog.skacekamen.dev/posts/nest-js-is-not-really-good/) [comments] (https://www.reddit.com/r/programming/comments/1ro40xj/nestjs_is_a_bad_typescript_framework/)

State of WASI support for CPython: March 2026
https://www.reddit.com/r/programming/comments/1ro4exs/state_of_wasi_support_for_cpython_march_2026/

submitted by /u/mariuz (https://www.reddit.com/user/mariuz)
[link] (https://snarky.ca/state-of-wasi-support-for-cpython-march-2026/) [comments] (https://www.reddit.com/r/programming/comments/1ro4exs/state_of_wasi_support_for_cpython_march_2026/)

Learn Observer Pattern the Easy Way | Java Design Patterns
https://www.reddit.com/r/programming/comments/1ro52s1/learn_observer_pattern_the_easy_way_java_design/

<!-- SC_OFF -->Documenting my journey learning design patterns. Today: Observer Pattern Simple explanation + example. Would love feedback from devs here. <!-- SC_ON --> submitted by /u/Big-Conflict-2600 (https://www.reddit.com/user/Big-Conflict-2600)
[link] (https://youtu.be/SxTmZ5QLTEc) [comments] (https://www.reddit.com/r/programming/comments/1ro52s1/learn_observer_pattern_the_easy_way_java_design/)

How Injection Keeps Breaking Real Systems
https://www.reddit.com/r/programming/comments/1ro8sei/how_injection_keeps_breaking_real_systems/

submitted by /u/Missics (https://www.reddit.com/user/Missics)
[link] (https://www.eliranturgeman.com/2026/03/06/malicious-user-input/) [comments] (https://www.reddit.com/r/programming/comments/1ro8sei/how_injection_keeps_breaking_real_systems/)

Two mechanisms for dynamic type checks
https://www.reddit.com/r/programming/comments/1rocnm2/two_mechanisms_for_dynamic_type_checks/

submitted by /u/self (https://www.reddit.com/user/self)
[link] (https://wingolog.org/archives/2026/02/18/two-mechanisms-for-dynamic-type-checks) [comments] (https://www.reddit.com/r/programming/comments/1rocnm2/two_mechanisms_for_dynamic_type_checks/)

Local LLM Stack into a Tool-Using Agent | by Partha Sai Guttikonda | Mar, 2026
https://www.reddit.com/r/programming/comments/1roriuu/local_llm_stack_into_a_toolusing_agent_by_partha/

submitted by /u/pardhu-- (https://www.reddit.com/user/pardhu--)
[link] (https://guttikondaparthasai.medium.com/local-llm-stack-into-a-tool-using-agent-ea7db102939a) [comments] (https://www.reddit.com/r/programming/comments/1roriuu/local_llm_stack_into_a_toolusing_agent_by_partha/)

Building a strict RFC 8259 JSON parser: what most parsers silently accept and why it matters for deterministic systems
https://www.reddit.com/r/programming/comments/1rp0zl4/building_a_strict_rfc_8259_json_parser_what_most/

<!-- SC_OFF -->Most JSON parsers make deliberate compatibility choices: lone surrogates get replaced, duplicate keys get silently resolved, and non-zero numbers that underflow to IEEE 754 zero are accepted without error. These are reasonable defaults for application code. They become correctness failures when the parsed JSON feeds a system that hashes, signs, or compares by raw bytes. If two parsers handle the same malformed input differently, the downstream bytes diverge, the hash diverges, and the signature fails. This article walks through building a strict RFC 8259 parser in Go that rejects what lenient parsers silently accept. It covers UTF-8 validation in two passes (bulk upfront, then incremental for semantic constraints like noncharacter rejection and surrogate detection on decoded code points), surrogate pair handling where lone surrogates are rejected per RFC 7493 while valid pairs are decoded and reassembled, duplicate key detection after escape decoding (because "\u0061" and "a" are the same key), number grammar enforcement in four layers (leading zeros, missing fraction digits, lexical negative zero, and overflow/underflow detection), and seven independent resource bounds for denial-of-service protection on untrusted input. The parser exists because canonicalization requires a one-to-one mapping between accepted input and canonical output. Silent leniency breaks that mapping. The article includes the actual implementation code for each section. <!-- SC_ON --> submitted by /u/UsrnameNotFound-404 (https://www.reddit.com/user/UsrnameNotFound-404)
[link] (https://lattice-substrate.github.io/blog/2026/02/26/strict-rfc8259-json-parser/) [comments] (https://www.reddit.com/r/programming/comments/1rp0zl4/building_a_strict_rfc_8259_json_parser_what_most/)

Why glibc is faster on some Github Actions Runners
https://www.reddit.com/r/programming/comments/1rp2mbc/why_glibc_is_faster_on_some_github_actions_runners/

submitted by /u/not-matthias (https://www.reddit.com/user/not-matthias)
[link] (https://codspeed.io/blog/why-glibc-faster-github-actions) [comments] (https://www.reddit.com/r/programming/comments/1rp2mbc/why_glibc_is_faster_on_some_github_actions_runners/)

Is legal the same as legitimate: AI reimplementation and the erosion of copyleft
https://www.reddit.com/r/programming/comments/1rp2vno/is_legal_the_same_as_legitimate_ai/

submitted by /u/hongminhee (https://www.reddit.com/user/hongminhee)
[link] (https://writings.hongminhee.org/2026/03/legal-vs-legitimate/) [comments] (https://www.reddit.com/r/programming/comments/1rp2vno/is_legal_the_same_as_legitimate_ai/)

Linux Internals: How /proc/self/mem writes to unw
https://www.reddit.com/r/programming/comments/1rp398v/linux_internals_how_procselfmem_writes_to_unw/

submitted by /u/Dear-Economics-315 (https://www.reddit.com/user/Dear-Economics-315)
[link] (https://offlinemark.com/an-obscure-quirk-of-proc/) [comments] (https://www.reddit.com/r/programming/comments/1rp398v/linux_internals_how_procselfmem_writes_to_unw/)