Surgery on Chromium Source Code: Replacing DevTools' HTTP Handler With Redis Pub/Sub
https://www.reddit.com/r/programming/comments/1plo5ei/surgery_on_chromium_source_code_replacing/

submitted by /u/DEADFOOD (https://www.reddit.com/user/DEADFOOD)
[link] (https://www.deadf00d.com/post/chromium-pub-sub-redis.html) [comments] (https://www.reddit.com/r/programming/comments/1plo5ei/surgery_on_chromium_source_code_replacing/)

I Tried Gleam for Advent of Code, and I Get the Hype
https://www.reddit.com/r/programming/comments/1plq6kw/i_tried_gleam_for_advent_of_code_and_i_get_the/

submitted by /u/tymscar (https://www.reddit.com/user/tymscar)
[link] (https://blog.tymscar.com/posts/gleamaoc2025/) [comments] (https://www.reddit.com/r/programming/comments/1plq6kw/i_tried_gleam_for_advent_of_code_and_i_get_the/)

Linus Torvalds on building and packaging software for Linux
https://www.reddit.com/r/programming/comments/1plrmdh/linus_torvalds_on_building_and_packaging_software/

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

Why Twilio Segment Moved from Microservices Back to a Monolith
https://www.reddit.com/r/programming/comments/1plrq5e/why_twilio_segment_moved_from_microservices_back/

<!-- SC_OFF -->real-world experience from Twilio Segment on what went wrong with microservices and why a monolith ended up working better. <!-- SC_ON --> submitted by /u/Digitalunicon (https://www.reddit.com/user/Digitalunicon)
[link] (https://www.twilio.com/en-us/blog/developers/best-practices/goodbye-microservices) [comments] (https://www.reddit.com/r/programming/comments/1plrq5e/why_twilio_segment_moved_from_microservices_back/)

Database Sharding and Partitioning with a solid breakdown of different strategies and their use cases.
https://www.reddit.com/r/programming/comments/1plvg1p/database_sharding_and_partitioning_with_a_solid/

<!-- SC_OFF -->Sharding and partitioning are useful when we want to scale our databases (both storage and compute) and directly improve the overall throughput and availability of the system. In this blog idive deep into details around how a database is scaled using sharding and partitioning, understanding the difference and different strategies, and learn how they beautifully fit together, and help us handle the desired scale. Once you read the blog, you will never be confused between the two; moreover, you will know all the practical nuances as to what it takes to configure either in production. <!-- SC_ON --> submitted by /u/Comfortable-Fan-580 (https://www.reddit.com/user/Comfortable-Fan-580)
[link] (https://pradyumnachippigiri.substack.com/p/nail-sharding-in-system-design-interviews) [comments] (https://www.reddit.com/r/programming/comments/1plvg1p/database_sharding_and_partitioning_with_a_solid/)

making lua do what it shouldn't: typesafe structs
https://www.reddit.com/r/programming/comments/1plwdkc/making_lua_do_what_it_shouldnt_typesafe_structs/

submitted by /u/qwool1337 (https://www.reddit.com/user/qwool1337)
[link] (https://if-not-nil.github.io/lua-structs/) [comments] (https://www.reddit.com/r/programming/comments/1plwdkc/making_lua_do_what_it_shouldnt_typesafe_structs/)

Terminal text editors are a dead end
https://www.reddit.com/r/programming/comments/1pm6h3n/terminal_text_editors_are_a_dead_end/

submitted by /u/nix-solves-that-2317 (https://www.reddit.com/user/nix-solves-that-2317)
[link] (https://www.youtube.com/watch?v=tvlupFXjqpQ) [comments] (https://www.reddit.com/r/programming/comments/1pm6h3n/terminal_text_editors_are_a_dead_end/)

A terminal text editor you can just use. Instant response, minimal footprint.
https://www.reddit.com/r/programming/comments/1pm83bz/a_terminal_text_editor_you_can_just_use_instant/

submitted by /u/nix-solves-that-2317 (https://www.reddit.com/user/nix-solves-that-2317)
[link] (https://sinelaw.github.io/fresh/) [comments] (https://www.reddit.com/r/programming/comments/1pm83bz/a_terminal_text_editor_you_can_just_use_instant/)

Overcoming ClickHouse's JSON Constraints to build a High Performance JSON Log Store
https://www.reddit.com/r/programming/comments/1pm94lv/overcoming_clickhouses_json_constraints_to_build/

<!-- SC_OFF -->Hi! I write for a newsletter called The Observability Real Talk, and this week's edition covered how we built a high-performance JSON log store, overcoming Clickhouse's JSON constraints. We are touching up on,
- Some of the problems we faced
- Exploring max_dynamic_path option setting
- How we built a 2-tier log storage system, which drastically improved our efficiency
Lmk your thoughts and subscribe if you love such deep engineering lore! <!-- SC_ON --> submitted by /u/elizObserves (https://www.reddit.com/user/elizObserves)
[link] (https://newsletter.signoz.io/p/overcoming-clickhouses-json-constraints) [comments] (https://www.reddit.com/r/programming/comments/1pm94lv/overcoming_clickhouses_json_constraints_to_build/)

Database Proxies: Challenges, Working and Trade-offs
https://www.reddit.com/r/programming/comments/1pm9g9k/database_proxies_challenges_working_and_tradeoffs/

submitted by /u/Local_Ad_6109 (https://www.reddit.com/user/Local_Ad_6109)
[link] (https://engineeringatscale.substack.com/p/scaling-databases-with-proxies) [comments] (https://www.reddit.com/r/programming/comments/1pm9g9k/database_proxies_challenges_working_and_tradeoffs/)

Valhalla? Python? Withers? Lombok? - Ask the Architects at JavaOne'25
https://www.reddit.com/r/programming/comments/1pma0uj/valhalla_python_withers_lombok_ask_the_architects/

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

The strangest programming languages you've ever heard of!!
https://www.reddit.com/r/programming/comments/1pmeq58/the_strangest_programming_languages_youve_ever/

<!-- SC_OFF -->Share with us the STRANGEST programming languages you've ever heard of: <!-- SC_ON --> submitted by /u/Leading-Welcome-5847 (https://www.reddit.com/user/Leading-Welcome-5847)
[link] (https://www.omnesgroup.com/weirdest-programming/) [comments] (https://www.reddit.com/r/programming/comments/1pmeq58/the_strangest_programming_languages_youve_ever/)

LPC 2025 - Hall B1 - Live from Tokyo
https://www.reddit.com/r/programming/comments/1pmeqp0/lpc_2025_hall_b1_live_from_tokyo/

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

The Case Against Microservices
https://www.reddit.com/r/programming/comments/1pmhvsd/the_case_against_microservices/

<!-- SC_OFF -->I would like to share my experience accumulated over the years with you. I did distributed systems btw, so hopefully my experience can help somebody with their technical choices. <!-- SC_ON --> submitted by /u/01x-engineer (https://www.reddit.com/user/01x-engineer)
[link] (https://open.substack.com/pub/sashafoundtherootcauseagain/p/the-case-against-microservices?r=56klm6&utm_campaign=post&utm_medium=web&showWelcomeOnShare=false) [comments] (https://www.reddit.com/r/programming/comments/1pmhvsd/the_case_against_microservices/)

Writing Code vs. Writing Prose
https://www.reddit.com/r/programming/comments/1pmid3g/writing_code_vs_writing_prose/

submitted by /u/bnuredini (https://www.reddit.com/user/bnuredini)
[link] (https://onbreakpoint.com/writing-code-vs.-writing-prose) [comments] (https://www.reddit.com/r/programming/comments/1pmid3g/writing_code_vs_writing_prose/)

AI and the Ironies of Automation - Part 2
https://www.reddit.com/r/programming/comments/1pmjpbh/ai_and_the_ironies_of_automation_part_2/

<!-- SC_OFF -->Very interesting and thought-provoking piece on the limits and tradeoffs of automation: Because these AI-based agents sometimes produce errors, a human – in our example a software developer – needs to supervise the AI agent fleet and ideally intervenes before the AI agents do something they should not do. Therefore, the AI agents typically create a plan of what they intend to do first (which as a side effect also increases the likelihood that they do not drift off). Then, the human verifies the plan and approves it if it is correct, and the AI agents execute the plan. If the plan is not correct, the human rejects it and sends the agents back to replanning, providing information about what needs to be altered. These agents might get better with time, but they will continuously need human oversight - there is always the possibility of error. That leads us to the problems: How can we train human operators at all to be able to intervene skillfully in exceptional, usually hard to solve situations (if skills in theory not needed regularly, since outsourced to AI)? How can we train a human operator so that their skills remain sharp over time and they remain able to address an exceptional situation quickly and resourcefully (again, if skills in theory not needed regularly, since outsourced to AI)? Perhaps the final irony is that it is the most successful automated systems, with rare need for manual intervention, which may need the greatest investment in human operator training. <!-- SC_ON --> submitted by /u/BinaryIgor (https://www.reddit.com/user/BinaryIgor)
[link] (https://www.ufried.com/blog/ironies_of_ai_2/) [comments] (https://www.reddit.com/r/programming/comments/1pmjpbh/ai_and_the_ironies_of_automation_part_2/)

Lessons from implementing a crash-safe Write-Ahead Log
https://www.reddit.com/r/programming/comments/1pmkzy8/lessons_from_implementing_a_crashsafe_writeahead/

<!-- SC_OFF -->I wrote this post to document why WAL correctness requires multiple layers (alignment, trailer canary, CRC, directory fsync), based on failures I ran into while building one. <!-- SC_ON --> submitted by /u/ankur-anand (https://www.reddit.com/user/ankur-anand)
[link] (https://unisondb.io/blog/building-corruption-proof-write-ahead-log-in-go/) [comments] (https://www.reddit.com/r/programming/comments/1pmkzy8/lessons_from_implementing_a_crashsafe_writeahead/)

I created a real time anonymous chat system and ran into moderation challenges
https://www.reddit.com/r/programming/comments/1pmn8ge/i_created_a_real_time_anonymous_chat_system_and/

submitted by /u/eren_rndm (https://www.reddit.com/user/eren_rndm)
[link] (https://gotalks.in/) [comments] (https://www.reddit.com/r/programming/comments/1pmn8ge/i_created_a_real_time_anonymous_chat_system_and/)

I built a real-time ASCII camera in the browser (60 FPS, Canvas, TypeScript)
https://www.reddit.com/r/programming/comments/1pmnk5o/i_built_a_realtime_ascii_camera_in_the_browser_60/

submitted by /u/Aroy666 (https://www.reddit.com/user/Aroy666)
[link] (https://github.com/pshycodr/phosphor-cam) [comments] (https://www.reddit.com/r/programming/comments/1pmnk5o/i_built_a_realtime_ascii_camera_in_the_browser_60/)

LLM agents kept looping and breaking UI state — I fixed it by making execution deterministic
https://www.reddit.com/r/programming/comments/1pmriw6/llm_agents_kept_looping_and_breaking_ui_state_i/

<!-- SC_OFF -->I work as a frontend engineer in a SaaS product. At some point I noticed that most SaaS UIs aren’t an open world — they’re mostly projections of BFF DTOs into a small set of recurring patterns: forms, cards, tables, dashboards, filters. I was experimenting with letting an LLM drive parts of this UI. I started with the usual agent loop: the model reasons, mutates UI state, checks the result, and repeats. It technically worked, but it was fragile. Simple tasks took multiple loops, state drifted in ways I couldn’t reproduce, and debugging mostly came down to reading logs and guessing. What changed things was making that SaaS structure explicit and narrowing the model’s role. Instead of letting the LLM mutate state directly, I made it emit a single validated intent over a typed snapshot of the UI state. A deterministic runtime then applies effects, runs validation, and updates the snapshot. That removed agent loops entirely. State transitions became replayable, debugging stopped being guesswork, and costs dropped enough that small models are actually usable. When something goes wrong, I can see exactly where the transition failed. This isn’t a new agent framework or AI philosophy. It’s just treating SaaS UIs as the structured systems they already are, and letting the model operate on that structure instead of free-form UI mutation. Demo and code: https://taskflow.manifesto-ai.dev (https://taskflow.manifesto-ai.dev/) https://github.com/manifesto-ai/taskflow <!-- SC_ON --> submitted by /u/TraditionalListen994 (https://www.reddit.com/user/TraditionalListen994)
[link] (https://taskflow.manifesto-ai.dev/) [comments] (https://www.reddit.com/r/programming/comments/1pmriw6/llm_agents_kept_looping_and_breaking_ui_state_i/)

Built an AI system that generates complete applications autonomously - architecture breakdown and lessons learned
https://www.reddit.com/r/programming/comments/1pmtf3a/built_an_ai_system_that_generates_complete/

<!-- SC_OFF -->I spent 4 months building APEX - a multi-agent AI system with 430 capabilities that can generate production-ready full-stack applications from natural language. **The Architecture:** APEX orchestrates 6 specialized sub-agents across 10 autonomous phases: - ATLAS (Coordinator) - Plans missions, delegates work - CATALYST (Builder) - Generates code files - CIPHER (Analyzer) - Reads logs, understands failures - AEGIS (Validator) - Tests and validates - REMEDY (Healer) - Patches errors, self-heals - VERDICT (Evaluator) - Scores quality, makes decisions **Technical Challenge Solved:** The hardest part was import path resolution across the stack. Generated files need to import from each other, and getting the paths right across frontend/backend/database was non-trivial. Solution: Dependency graph calculation in Phase 52 that determines generation order and ensures all imports resolve correctly. **Real Performance:** Input: "Build a task management SaaS with kanban boards" Output (2 seconds later): - 3 React components (KanbanBoard, TaskCard, TaskList) - FastAPI backend with CORS and routing - PostgreSQL schema with 3 normalized tables - Complete architecture blueprint **Code Quality:** The generated FastAPI server includes proper CORS configuration, Pydantic models, route organization, and Uvicorn production setup. Not toy code - actual production scaffolding. **Questions I expect:** "Is this real or vaporware?" 100% real. Working demo. Can generate apps live. "Will this replace developers?" No. It 100x's them. Removes boilerplate, frees developers for creative work. **Technical details:** Multi-LLM routing (Gemini → Claude → GPT-4) based on task complexity Self-healing error detection and correction Firestore-based shared intelligence layer Phase-based autonomous execution More info: https://justiceapexllc.com/engine Happy to answer questions about the architecture, LLM routing, or autonomous orchestration. <!-- SC_ON --> submitted by /u/TTVJusticeRolls (https://www.reddit.com/user/TTVJusticeRolls)
[link] (https://justiceapexllc.com/engine.html) [comments] (https://www.reddit.com/r/programming/comments/1pmtf3a/built_an_ai_system_that_generates_complete/)