Further Performance Evolution in Python 3.14: Tail Call Interpreter
https://www.reddit.com/r/programming/comments/1melmjw/further_performance_evolution_in_python_314_tail/

submitted by /u/stackoverflooooooow (https://www.reddit.com/user/stackoverflooooooow)
[link] (https://www.manjusaka.blog/posts/2025/07/02/tail-call-in-3-14-interpreter-en/) [comments] (https://www.reddit.com/r/programming/comments/1melmjw/further_performance_evolution_in_python_314_tail/)

C++26 Reflections adventures & compile time UML
https://www.reddit.com/r/programming/comments/1meo7ki/c26_reflections_adventures_compile_time_uml/

submitted by /u/ketralnis (https://www.reddit.com/user/ketralnis)
[link] (https://www.reachablecode.com/2025/07/31/c26-reflections-adventures-compile-time-uml/) [comments] (https://www.reddit.com/r/programming/comments/1meo7ki/c26_reflections_adventures_compile_time_uml/)

I spearheaded the development of an AI app that acts as a VFX Supervisor for Filmmakers and VFX Artists. This is what I learned in the process.... and this is our No Budget Launch Trailer! Curious to hear if anyone else has advice in communicating best to devs now that we have launched our MVP.
https://www.reddit.com/r/programming/comments/1meqvgq/i_spearheaded_the_development_of_an_ai_app_that/

<!-- SC_OFF -->After months of work we just launched our app FX Sup and I wanted to share some of the journey for anyone else building something without doing the coding themselves. This process has been a grind. The idea came from working on film sets and constantly seeing filmmakers miss out on huge production value simply because they didn’t know what was possible with VFX or how to prep for it. That gap between production and post stuck with me for years and I finally decided to try building something to help bridge it. I’m not a developer so at first I explored no-code options. But it quickly became clear that what we needed — a mix of creative tools, project management, and a job board — wasn’t realistic to pull off without going custom. What really saved this project was wireframes and entity relationship diagrams. Honestly that’s been the single most important insight from the whole process. If you're not the one coding it clear wireframes and ER diagrams are your lifeline. That’s how you communicate with devs and make sure you’re building what you actually intended. Every time we skipped that step or got lazy about documentation something came out wrong or confusing or broken. I built the wireframes in Figma and refined the flows over and over. Then I worked with the devs to map out how everything connected on the backend. It wasn’t glamorous but it made everything real. Without that structure this project would have either stalled or turned into a bloated mess. We launched the MVP version last week on the app stores and now we’re collecting feedback and figuring out next steps. Not trying to pitch anything here just sharing in case it’s useful. If you’re building something and not writing the code yourself treat your wireframes and diagrams like your source of truth. It makes all the difference. Happy to answer any questions if anyone’s in a similar place. It’s been a long road and we’re still learning. <!-- SC_ON --> submitted by /u/Prestigious_Chip7205 (https://www.reddit.com/user/Prestigious_Chip7205)
[link] (https://www.youtube.com/watch?v=4e1VexUWwlA&embeds_referring_euri=https%3A%2F%2Fwww.reddit.com%2F) [comments] (https://www.reddit.com/r/programming/comments/1meqvgq/i_spearheaded_the_development_of_an_ai_app_that/)

If Odin Had Macros
https://www.reddit.com/r/programming/comments/1mes37n/if_odin_had_macros/

submitted by /u/gingerbill (https://www.reddit.com/user/gingerbill)
[link] (https://www.gingerbill.org/article/2025/07/31/if-odin-had-macros/) [comments] (https://www.reddit.com/r/programming/comments/1mes37n/if_odin_had_macros/)

The Art of Parsing and Comparing Version Strings
https://www.reddit.com/r/programming/comments/1metblt/the_art_of_parsing_and_comparing_version_strings/

submitted by /u/feltatap (https://www.reddit.com/user/feltatap)
[link] (https://secalerts.co/news/the-art-of-parsing-and-comparing-version-strings/7bVWMEyNBrMIbBmixgGVsI) [comments] (https://www.reddit.com/r/programming/comments/1metblt/the_art_of_parsing_and_comparing_version_strings/)

NATS on edge - A distributed industrial mesh- MQ Summit Session 2025
https://www.reddit.com/r/programming/comments/1metu9x/nats_on_edge_a_distributed_industrial_mesh_mq/

<!-- SC_OFF -->100+ plants, billions of daily messages, 50+ applications Schaeffler built a global NATS mesh that just works Schaeffler's Max Arndt and Jean-Noel Moyne from Synadia spill the secrets at MQSummit 2025 <!-- SC_ON --> submitted by /u/Code_Sync (https://www.reddit.com/user/Code_Sync)
[link] (https://mqsummit.com/talks/nats-on-edge/) [comments] (https://www.reddit.com/r/programming/comments/1metu9x/nats_on_edge_a_distributed_industrial_mesh_mq/)

Pompelmi — Real-Time YARA File Scanning in Node.js and the Web
https://www.reddit.com/r/programming/comments/1mewm8g/pompelmi_realtime_yara_file_scanning_in_nodejs/

submitted by /u/No-Pea5632 (https://www.reddit.com/user/No-Pea5632)
[link] (https://github.com/pompelmi/pompelmi) [comments] (https://www.reddit.com/r/programming/comments/1mewm8g/pompelmi_realtime_yara_file_scanning_in_nodejs/)

Tea App Hack: Disassembling The Ridiculous App Source Code
https://www.reddit.com/r/programming/comments/1meyjjx/tea_app_hack_disassembling_the_ridiculous_app/

submitted by /u/derjanni (https://www.reddit.com/user/derjanni)
[link] (https://programmers.fyi/tea-app-hack-disassembling-the-ridiculous-app-source-code) [comments] (https://www.reddit.com/r/programming/comments/1meyjjx/tea_app_hack_disassembling_the_ridiculous_app/)

Postgres psql Power Tips: 10 Meta‑Commands Every Beginner Should Know
https://www.reddit.com/r/programming/comments/1mezeyw/postgres_psql_power_tips_10_metacommands_every/

<!-- SC_OFF -->https://medium.com/@rohansodha10/psql-power-tips-10-meta-commands-every-beginner-should-know-adc1593b28f2?sk=36e195f7c016fe634939b95a6f957208 <!-- SC_ON --> submitted by /u/Temporary_Depth_2491 (https://www.reddit.com/user/Temporary_Depth_2491)
[link] (https://medium.com/@rohansodha10/psql-power-tips-10-meta-commands-every-beginner-should-know-adc1593b28f2?sk=36e195f7c016fe634939b95a6f957208) [comments] (https://www.reddit.com/r/programming/comments/1mezeyw/postgres_psql_power_tips_10_metacommands_every/)

If i want to work in a game dev company what topics i need to know ?
https://www.reddit.com/r/programming/comments/1mf08q9/if_i_want_to_work_in_a_game_dev_company_what/

<!-- SC_OFF -->In the future, I'd like to work as a game developer. I searched for information about Nintendo, and it says:
Game Program Development
Those with the following work experience and skills, and an interest in making games more interesting: Game development experience, game engine development experience Experience in developing graphics, dynamics, AI, game frameworks, UI, and sound Development experience in C/C++ (required) So, do I need to study C++ related to graphics? I know a little bit of C++ (arrays, structs, vectors, variables, and a little bit of OOP), but I don’t know where to start. If you have any advice, I’d really appreciate it. <!-- SC_ON --> submitted by /u/Comett257 (https://www.reddit.com/user/Comett257)
[link] (https://www.portal.e2r.jp/fixurl/nintendo_career_job/id/4/2?ki=job00149) [comments] (https://www.reddit.com/r/programming/comments/1mf08q9/if_i_want_to_work_in_a_game_dev_company_what/)

Couchbase Lite for C -- mapping an OOP API into a C API.
https://www.reddit.com/r/programming/comments/1mf5gwh/couchbase_lite_for_c_mapping_an_oop_api_into_a_c/

submitted by /u/pdp10 (https://www.reddit.com/user/pdp10)
[link] (https://www.youtube.com/watch?v=IRk6VOcKPFI) [comments] (https://www.reddit.com/r/programming/comments/1mf5gwh/couchbase_lite_for_c_mapping_an_oop_api_into_a_c/)

What Declarative Languages Are
https://www.reddit.com/r/programming/comments/1mf5or8/what_declarative_languages_are/

submitted by /u/ketralnis (https://www.reddit.com/user/ketralnis)
[link] (https://semantic-domain.blogspot.com/2013/07/what-declarative-languages-are.html) [comments] (https://www.reddit.com/r/programming/comments/1mf5or8/what_declarative_languages_are/)

Let's make a game! 295: Charging
https://www.reddit.com/r/programming/comments/1mfk87i/lets_make_a_game_295_charging/

submitted by /u/apeloverage (https://www.reddit.com/user/apeloverage)
[link] (https://www.youtube.com/watch?v=NYy1lRke_CU) [comments] (https://www.reddit.com/r/programming/comments/1mfk87i/lets_make_a_game_295_charging/)

Seed7: a programming language I plan to work on for decades
https://www.reddit.com/r/programming/comments/1mfldk0/seed7_a_programming_language_i_plan_to_work_on/

<!-- SC_OFF -->Seed7 is based on ideas from my diploma and doctoral theses about an extensible programming language (1984 and 1986). In 1989 development began on an interpreter and in 2005 the project was released as open source. Since then it is improved on a regular basis. Seed7 is about readability (https://seed7.net/faq.htm#readability), portability (https://seed7.net/faq.htm#portable), performance (https://seed7.net/scrshots/s7c.htm) and memory safety (https://seed7.net/faq.htm#memory_safety). There is an automatic memory management (https://seed7.net/faq.htm#garbage_collection), but there is no garbage collection process, that interrupts normal processing. The templates (https://seed7.net/manual/tutorial.htm#Templates) and generics (https://seed7.net/manual/decls.htm#Abstract_data_types) of Seed7 don't need special syntax. They are just normal functions, which are executed at compile-time. Seed7 is an extensible (https://seed7.net/faq.htm#extensible_programming) programming language. The syntax and semantics of statements (https://seed7.net/manual/stats.htm) (and abstract data types (https://seed7.net/manual/decls.htm#Abstract_data_type), etc.) is defined in libraries. The whole language is defined in the library "seed7_05.s7i". You can extend the language syntactically (https://seed7.net/manual/syntax.htm) and semantically (introduce new loops (https://seed7.net/manual/tutorial.htm#Declare_a_statement), etc.). In other languages the syntax and semantics of the language is hard-coded in the compiler. Seed7 checks for integer overflow (https://seed7.net/faq.htm#integer_overflow). You either get the correct result or an OVERFLOW_ERROR (https://seed7.net/manual/errors.htm#OVERFLOW_ERROR) is raised. Unlike many JVM based languages Seed7 compiles to machine code ahead of time (GRAAL works ahead of time but it struggles with reflection). Unlike many systems languages (except Rust) Seed7 is a memory safe (https://seed7.net/faq.htm#memory_safety) language. The Seed7 homepage (https://seed7.net/) contains the language documentation. The source code is at GitHub (https://github.com/ThomasMertes/seed7). Questions that are not in the FAQ (https://seed7.net/faq.htm) can be asked at r/seed7 (https://www.reddit.com/r/seed7/). Some programs written in Seed7 are: make7 (https://seed7.net/scrshots/make7.htm): a make utility. bas7 (https://seed7.net/scrshots/bas7.htm): a BASIC interpreter. pv7 (https://seed7.net/scrshots/pv7.htm): a Picture Viewer for BMP, GIF, ICO, JPEG, PBM, PGM, PNG, PPM and TIFF files. tar7 (https://seed7.net/scrshots/tar7.htm): a tar archiving utility. ftp7 (https://seed7.net/scrshots/ftp7.htm): an FTP Internet file transfer program. comanche (https://seed7.net/scrshots/comanche.htm): a simple web server for static HTML pages and CGI programs. Screenshots of Seed7 programs can be found here (https://seed7.net/scrshots/index.htm) and there is a demo page (https://seed7.net/demo.htm) with Seed7 programs, which can be executed in the browser. These programs have been compiled to JavaScript / WebAssembly. I recently released a new version (https://www.reddit.com/r/seed7/comments/1mch5bu/seed7_version_20250729_released_on_github_and_sf/) which added support to read TGA (https://seed7.net/libraries/tga.htm) images, added documentation and improved code quality. Please let me know what you think, and consider starring the project on GitHub (https://github.com/ThomasMertes/seed7), thanks! <!-- SC_ON --> submitted by /u/ThomasMertes (https://www.reddit.com/user/ThomasMertes)
[link] (https://seed7.net/) [comments] (https://www.reddit.com/r/programming/comments/1mfldk0/seed7_a_programming_language_i_plan_to_work_on/)

[P] Implemented the research paper “Memorizing Transformers” from scratch with my own additional modifications in architecture and customized training pipeline .
https://www.reddit.com/r/programming/comments/1mfmxas/p_implemented_the_research_paper_memorizing/

submitted by /u/Remarkable-Ad3290 (https://www.reddit.com/user/Remarkable-Ad3290)
[link] (https://huggingface.co/abhinavv3/GPT_with_Modified_Memorizing_Transformer) [comments] (https://www.reddit.com/r/programming/comments/1mfmxas/p_implemented_the_research_paper_memorizing/)

Day 2 : Basics of programming language
https://www.reddit.com/r/programming/comments/1mfnm8g/day_2_basics_of_programming_language/

submitted by /u/coderjags (https://www.reddit.com/user/coderjags)
[link] (https://youtube.com/watch?v=Gl6EjVYbL5g&si=3qKGK295PkyezebL) [comments] (https://www.reddit.com/r/programming/comments/1mfnm8g/day_2_basics_of_programming_language/)

Compressing Icelandic name declension patterns into a 3.27 kB trie
https://www.reddit.com/r/programming/comments/1mfoh6z/compressing_icelandic_name_declension_patterns/

submitted by /u/XLEX97 (https://www.reddit.com/user/XLEX97)
[link] (https://alexharri.com/blog/icelandic-name-declension-trie) [comments] (https://www.reddit.com/r/programming/comments/1mfoh6z/compressing_icelandic_name_declension_patterns/)

PatchworkOS: A from-scratch NON-POSIX OS strictly adhering to the "everything is a file" philosophy that I've been working on for... a very long while.
https://www.reddit.com/r/programming/comments/1mfoxwc/patchworkos_a_fromscratch_nonposix_os_strictly/

<!-- SC_OFF -->Patchwork is based on ideas from many different places including UNIX, Plan9 and DOS. The strict adherence to "everything is a file" is inspired by Plan9 while straying from some of its weirder choices, for example Patchwork supports hard links, which Plan9 did not. Everything including pipes, sockets, shared memory, and much more is done via the file systems /dev, /proc and /net directories. For example creating a local socket can be done via opening the /net/local/seqpacket file. Sockets are discussed in detail in the README. One unique feature of Patchwork is its file flag system, It's intended to give more power to the shell (check the README for examples) and give better separation of concerns to the kernel, for example the kernel supports native recursive directory access via the :recur flag. Patchwork also focuses on performance with features like a preemptive and tickless kernel, SMP, constant-time scheduling, constant-time virtual memory management, and more. The README (https://github.com/KaiNorberg/PatchworkOS) has plenty more details, screenshots, examples and some (hopefully) simple build instructions. Would love to hear your thoughts, advice or answer questions! <!-- SC_ON --> submitted by /u/KN_9296 (https://www.reddit.com/user/KN_9296)
[link] (https://github.com/KaiNorberg/PatchworkOS) [comments] (https://www.reddit.com/r/programming/comments/1mfoxwc/patchworkos_a_fromscratch_nonposix_os_strictly/)

The React Blog Post: Reflections and Reactions
https://www.reddit.com/r/programming/comments/1mfpgyg/the_react_blog_post_reflections_and_reactions/

<!-- SC_OFF -->Part 2 blog post on "React Still Feels Insane And No One Is Talking About It (https://mbrizic.com/blog/react-is-insane)" <!-- SC_ON --> submitted by /u/boggylp (https://www.reddit.com/user/boggylp)
[link] (https://mbrizic.com/blog/react-ii/) [comments] (https://www.reddit.com/r/programming/comments/1mfpgyg/the_react_blog_post_reflections_and_reactions/)

A one-week deep dive into building a dual-mode template engine (Runtime Parser vs. Build-time AST Compiler)
https://www.reddit.com/r/programming/comments/1mfthww/a_oneweek_deep_dive_into_building_a_dualmode/

<!-- SC_OFF -->Hey r/programming (https://www.reddit.com/r/programming), I just came out of a fascinating, intense week of development and wanted to share the architectural journey. The challenge was a classic one: how do you design a system that's incredibly easy to use in a development environment, but also ruthlessly optimized for production? The context is a UI templating engine for an open-source web framework I work on (Neo.mjs). Our goal was to offer an intuitive, HTML-like syntax that required zero build steps in development. This led to a dual-mode architecture with two completely different implementations for the same input. Mode 1: The Runtime Interpreter (For Development) The "easy" path. We used a standard language feature (JavaScript's Tagged Template Literals) so developers can just write html...`` and see it work instantly. Input: A template string with embedded dynamic values. Process: At runtime, a tag function intercepts the call. It dynamically imports a parser library (parse5), which converts the string into an AST. We then traverse that AST to produce our internal VDOM structure. Trade-off: It's a fantastic developer experience, but it requires shipping a ~176KB parser to the client. Unacceptable for production. Mode 2: The Build-Time Compiler (For Production) This is where it gets fun. The goal was to produce the exact same VDOM structure as the runtime mode, but with zero runtime overhead. Input: The developer's raw source code file. Process: We built a script that acts as a mini-compiler, using acorn to parse the JS source into its own AST. It traverses the AST, looking for our html tagged template nodes. It extracts the template's strings and expressions. A key challenge here is that expressions like ${this.name} have no meaning at build time, so we capture the raw code string "this.name" and wrap it in a special placeholder. It uses the same core parsing logic as the runtime mode to convert the template into a serializable VDOM object, now with placeholders instead of real values. It then converts that VDOM object back into a valid JavaScript AST ObjectExpression node. The placeholders are converted back into real expression nodes. Finally, it replaces the original template literal node in the source code's AST with this new, optimized object node. The modified AST is then written back to a file using astring. The result is that the code that ships to production has no trace of the original template string or the parser. It's as if the developer wrote the optimized VDOM by hand from the start. This whole system, from concept to completion across all build environments, was built in less than a week and just went live. We wrote a very detailed "Under the Hood" guide that explains the entire process. You can see the full release notes (with live demos) here: https://github.com/neomjs/neo/releases/tag/10.3.0 And the deep-dive guide into the architecture is here: https://github.com/neomjs/neo/blob/dev/learn/guides/uibuildingblocks/HtmlTemplatesUnderTheHood.md I'm fascinated by this "dev vs. prod" dichotomy in software design. I'd love to hear your thoughts on this dual-mode approach. Are there other patterns for solving this? What are the potential pitfalls of this kind of AST replacement that I might not have considered? <!-- SC_ON --> submitted by /u/TobiasUhlig (https://www.reddit.com/user/TobiasUhlig)
[link] (https://github.com/neomjs/neo/blob/dev/learn/guides/uibuildingblocks/HtmlTemplatesUnderTheHood.md) [comments] (https://www.reddit.com/r/programming/comments/1mfthww/a_oneweek_deep_dive_into_building_a_dualmode/)

Vibe code is legacy code
https://www.reddit.com/r/programming/comments/1mg5ib4/vibe_code_is_legacy_code/

submitted by /u/ChiliPepperHott (https://www.reddit.com/user/ChiliPepperHott)
[link] (https://blog.val.town/vibe-code) [comments] (https://www.reddit.com/r/programming/comments/1mg5ib4/vibe_code_is_legacy_code/)