Why ID Format Matters More Than ID Generation (Lessons from Production)
https://www.reddit.com/r/programming/comments/1pf02wp/why_id_format_matters_more_than_id_generation/

submitted by /u/piljoong (https://www.reddit.com/user/piljoong)
[link] (https://piljoong.dev/posts/distributed-id-generation-complicated/) [comments] (https://www.reddit.com/r/programming/comments/1pf02wp/why_id_format_matters_more_than_id_generation/)

Fizz Buzz in 4 lines of CSS
https://www.reddit.com/r/programming/comments/1pf41xp/fizz_buzz_in_4_lines_of_css/

submitted by /u/brightlystar (https://www.reddit.com/user/brightlystar)
[link] (https://mastodon.social/@susam/115668571178604230) [comments] (https://www.reddit.com/r/programming/comments/1pf41xp/fizz_buzz_in_4_lines_of_css/)

Prometheus woke me up. I decided to get to know it better
https://www.reddit.com/r/programming/comments/1pf476p/prometheus_woke_me_up_i_decided_to_get_to_know_it/

submitted by /u/Helpful_Geologist430 (https://www.reddit.com/user/Helpful_Geologist430)
[link] (https://cefboud.com/posts/prometheus-monitoring-alertmanager-internals-tsdb/) [comments] (https://www.reddit.com/r/programming/comments/1pf476p/prometheus_woke_me_up_i_decided_to_get_to_know_it/)

Leaving Intel
https://www.reddit.com/r/programming/comments/1pfhhah/leaving_intel/

<!-- SC_OFF -->He's accomplished so much in only 3.5 years. I wonder where he's going next? Any guesses? <!-- SC_ON --> submitted by /u/ThanksMorningCoffee (https://www.reddit.com/user/ThanksMorningCoffee)
[link] (https://www.brendangregg.com/blog//2025-12-05/leaving-intel.html) [comments] (https://www.reddit.com/r/programming/comments/1pfhhah/leaving_intel/)

Some guy played GTA 5 with his car (C, golang, Python)
https://www.reddit.com/r/programming/comments/1pflbe6/some_guy_played_gta_5_with_his_car_c_golang_python/

submitted by /u/SomewhereRough_ (https://www.reddit.com/user/SomewhereRough_)
[link] (https://youtu.be/W1cvxAJ-fYQ) [comments] (https://www.reddit.com/r/programming/comments/1pflbe6/some_guy_played_gta_5_with_his_car_c_golang_python/)

Polynomial roots visualisation inspired by 2swap's video on the quintic
https://www.reddit.com/r/programming/comments/1pflitt/polynomial_roots_visualisation_inspired_by_2swaps/

<!-- SC_OFF -->Upon watching this 2swap video (https://youtu.be/9HIy5dJE-zQ) I thought the visuals were incredibly mesmerising and thus created my own visualisation program with which I could play around with different coefficients and degrees. The GitHub readme page discusses several implementation details and optimisations to enable real-time rendering of the point cloud, including using OpenCL kernels to parallelise evaluation. Might have gone a little overboard and added animation facilities to this. <!-- SC_ON --> submitted by /u/therealoranges (https://www.reddit.com/user/therealoranges)
[link] (https://github.com/TheRealOrange/acidvis) [comments] (https://www.reddit.com/r/programming/comments/1pflitt/polynomial_roots_visualisation_inspired_by_2swaps/)

SystemSketcher. A tools where you can design system architecture and prepare for interview.
https://www.reddit.com/r/programming/comments/1pfn5cx/systemsketcher_a_tools_where_you_can_design/

<!-- SC_OFF -->Hey everyone, I’ve been preparing for system design interviews and kept wishing there was a simple way to sketch architectures and get instant feedback. Checkout SystemSketcher, a free web tool where you can: Sketch system diagrams quickly Use keyboard shortcuts to speed up drawing Enter “interview mode” and get AI to act as an interviewer Explain your design while the AI checks gaps, asks follow-up questions, and summarizes your solution Not selling anything, just looking for feedback from people who actually do system design. If you’re willing to try it out and tell me what’s confusing / missing / broken, I’d really appreciate it. Thanks! <!-- SC_ON --> submitted by /u/lalatputih (https://www.reddit.com/user/lalatputih)
[link] (https://systemsketcher.com/) [comments] (https://www.reddit.com/r/programming/comments/1pfn5cx/systemsketcher_a_tools_where_you_can_design/)

Google and Youtube advanced search techniques while learning totally new computer science concepts
https://www.reddit.com/r/programming/comments/1pfnqhl/google_and_youtube_advanced_search_techniques/

<!-- SC_OFF -->Wrote a blog while procastinating to learn ipv6. Completely unnoscripted. <!-- SC_ON --> submitted by /u/PrimaryWaste8717 (https://www.reddit.com/user/PrimaryWaste8717)
[link] (https://rbcrossley.github.io/post/google-and-youtube-search-techniques-for-learning-new-concepts/) [comments] (https://www.reddit.com/r/programming/comments/1pfnqhl/google_and_youtube_advanced_search_techniques/)

Built my first Interpreted language at 15
https://www.reddit.com/r/programming/comments/1pfqbkv/built_my_first_interpreted_language_at_15/

<!-- SC_OFF -->Hello everyone. I'm a 15-year-old developer and I just finished building Lento, an interpreted language in Go. https://github.com/caelondev/lento A bit of background: I have this hobby where whenever I learn a new programming language, I build an interpreter in it to really solidify my understanding. I find that creating an interpreter forces you to actually use almost everything a language has to offer—syntax, control flow, file I/O, REPL interactions, functions, data structures, type systems, memory management, and more. It's like a comprehensive exam that shows what you've truly learned, and it's been an incredible way to discover the strengths and quirks of each language I pick up. Lento is a tree-walk interpreter with a C-like syntax that includes the essential features you'd expect from a noscripting language: variables, functions with closures, control flow structures (if/else, loops, break/continue/return), arrays and objects, a full set of operators, and an interactive REPL. It's designed to be simple and fast, executing noscripts in microseconds. Building this has been eye-opening. Implementing the lexer, parser (using Pratt parsing for operator precedence), and the runtime environment taught me so much about how languages actually work under the hood. There's something really satisfying about writing code that reads and executes other code. I'd really appreciate any feedback from the community! Feel free to check it out, try the examples in the repo, and open issues if you spot any bugs or have suggestions for improvements. Since I'm still learning, any advice on parser design, language features, or performance optimizations would be incredibly valuable. Has anyone else used similar projects to learn programming concepts? I'd love to hear about your experiences! Thanks for checking it out! <!-- SC_ON --> submitted by /u/Adorable-Bee4127 (https://www.reddit.com/user/Adorable-Bee4127)
[link] (https://github.com/caelondev/lento) [comments] (https://www.reddit.com/r/programming/comments/1pfqbkv/built_my_first_interpreted_language_at_15/)

i created some simple(not actually) iso burner
https://www.reddit.com/r/programming/comments/1pfrbd8/i_created_some_simplenot_actually_iso_burner/

<!-- SC_OFF -->I've created this tool because im bored, and sick of limited linux iso burner tools with no persistence, and the command is to much sweat. so I've been plan to create some you know. like it. actually I've tested it out but im so completely dumb 😥😥, because instead of /dev/sdb is the -o i made it /dev/sdb3 🤦‍♀️🤦‍♀️🤦‍♀️🤦‍♀️🤦‍♀️🤦‍♀️. it would help if some y'all try it. and suggets what to add, and optimize in the next update. Happy Advance Christmas! <!-- SC_ON --> submitted by /u/Youre_Good_8111 (https://www.reddit.com/user/Youre_Good_8111)
[link] (https://github.com/JeckAsChristopher/MyISO) [comments] (https://www.reddit.com/r/programming/comments/1pfrbd8/i_created_some_simplenot_actually_iso_burner/)

Technical Writeup: Building an Ultra-Fast, Zero-Auth, Multi-Language Anagram API using C# ASP.NET Core & In-Memory Data
https://www.reddit.com/r/programming/comments/1pfue6n/technical_writeup_building_an_ultrafast_zeroauth/

<!-- SC_OFF -->Hey r/programming (https://www.reddit.com/r/programming), I’m releasing a 100% free and public API called Poocoo API, focusing on advanced word operations. While the service is simple, the core engineering challenge was achieving ultra-fast anagram search performance with a multi-language dataset. I wanted to share a technical writeup on how the anagram search was optimized, rather than just listing features. Technical Deep Dive: The Anagram Optimization Challenge The backend is built with C# ASP.NET Core, with all dictionary data held in-memory for minimal latency. The key to speed was preprocessing and indexing the words: Preprocessing: Instead of calculating character counts (or sorting) letters at runtime for every user request, I pre-sort and store a "canonical form" (an 'alphabetized signature') for every word in the dictionary. For example, the words "dog" and "god" both map to the signature "dgo". In-Memory Index: The entire dictionary is loaded into a fast in-memory structure (a Dictionary> or similar hash map) where the Key is the canonical signature and the Value is a list of all anagrams sharing that signature. Runtime Efficiency: When a user requests anagrams for a jumble of letters (e.g., "ellohworld"), the API only needs to: Generate the canonical signature of the input letters (dhlloorw). Perform one direct lookup in the in-memory index. Return the pre-calculated list of matching words. This approach guarantees O(1) complexity (after the initial signature generation), resulting in millisecond response times. API Use & Key Details Zero-Auth Policy: No API keys, tokens, or signup are needed. I wanted it to be plug-and-play for simple side projects. Multi-language Support: Dictionaries for English (EN), German (DE), French (FR), and Polish (PL). Example Anagram Search: https://api.poocoo.app/api/v1/words-from-letters?letters=hellloword The API also features a quick advanced filtering endpoint. I'm keen to hear your technical feedback on the optimization approach or any C# suggestions! Client Repo (Vanilla JS Demo): https://github.com/tjaworski997/poocoo.api.demo Live Demo (Test it yourself): https://tjaworski997.github.io/poocoo.api.demo/ <!-- SC_ON --> submitted by /u/VirtualPossibility75 (https://www.reddit.com/user/VirtualPossibility75)
[link] (https://github.com/tjaworski997/poocoo.api.demo) [comments] (https://www.reddit.com/r/programming/comments/1pfue6n/technical_writeup_building_an_ultrafast_zeroauth/)

LZAV 5.7: Improved compression ratio, speeds. Now fully C++ compliant regarding memory allocation. Benchmarks across diverse datasets posted. Fast Data Compression Algorithm (inline C/C++).
https://www.reddit.com/r/programming/comments/1pgc7sz/lzav_57_improved_compression_ratio_speeds_now/

submitted by /u/avaneev (https://www.reddit.com/user/avaneev)
[link] (https://github.com/avaneev/lzav) [comments] (https://www.reddit.com/r/programming/comments/1pgc7sz/lzav_57_improved_compression_ratio_speeds_now/)

One of Those Bugs
https://www.reddit.com/r/programming/comments/1pgd3jq/one_of_those_bugs/

submitted by /u/Commission-Either (https://www.reddit.com/user/Commission-Either)
[link] (https://daymare.net/blogs/one-of-those-bugs/) [comments] (https://www.reddit.com/r/programming/comments/1pgd3jq/one_of_those_bugs/)

[OSS] HashSmith – High-performance open-addressing hash tables for Java (SwissTable / Robin Hood)
https://www.reddit.com/r/programming/comments/1pgfatm/oss_hashsmith_highperformance_openaddressing_hash/

<!-- SC_OFF -->Hey everyone 👋 I've been experimenting with high-performance hash table implementations on the JVM and ended up creating HashSmith: What it is:
- A collection of open-addressing hash tables for Java
- Implementations based on Robin Hood probing and SwissTable-style layouts
- Focused on predictable performance and memory efficiency Highlights:
- JMH benchmarks comparing HashSmith vs JDK HashMap
- JOL-based memory footprint analysis
- Java 21, with vector-friendly layouts in mind (where applicable) I'd love feedback on:
- API design (does it feel “Java-ish”?)
- Benchmark methodology (anything obviously missing?)
- Edge cases/workloads you'd like to see tested
- How this could be improved or extended – features, variants, or trade-offs worth exploring next Thanks! <!-- SC_ON --> submitted by /u/Charming-Top-8583 (https://www.reddit.com/user/Charming-Top-8583)
[link] (https://github.com/bluuewhale/HashSmith) [comments] (https://www.reddit.com/r/programming/comments/1pgfatm/oss_hashsmith_highperformance_openaddressing_hash/)

Authentication Explained: When to Use Basic, Bearer, OAuth2, JWT & SSO
https://www.reddit.com/r/programming/comments/1pgfxs1/authentication_explained_when_to_use_basic_bearer/

submitted by /u/javinpaul (https://www.reddit.com/user/javinpaul)
[link] (https://javarevisited.substack.com/p/system-design-basics-authentication) [comments] (https://www.reddit.com/r/programming/comments/1pgfxs1/authentication_explained_when_to_use_basic_bearer/)

Surface Tension of Software: why systems hold together
https://www.reddit.com/r/programming/comments/1pgis1n/surface_tension_of_software_why_systems_hold/

<!-- SC_OFF -->Some systems manage to stay coherent as they grow, while others seem to lose their shape almost immediately. I’ve been thinking about this through a metaphor from physics: surface tension — the quiet force that helps structures keep themselves together. Here’s a short reflection on how that idea maps to software systems and why certain architectures resist chaos better than others. https://iamstelios.com/blog/surface-tension-of-software/ <!-- SC_ON --> submitted by /u/gonefreeksss (https://www.reddit.com/user/gonefreeksss)
[link] (https://iamstelios.com/blog/surface-tension-of-software/) [comments] (https://www.reddit.com/r/programming/comments/1pgis1n/surface_tension_of_software_why_systems_hold/)

Spinlocks vs. Mutexes: When to Spin and When to Sleep
https://www.reddit.com/r/programming/comments/1pgjrbd/spinlocks_vs_mutexes_when_to_spin_and_when_to/

<!-- SC_OFF -->Every Lock Costs You Something <!-- SC_ON --> submitted by /u/Extra_Ear_10 (https://www.reddit.com/user/Extra_Ear_10)
[link] (https://howtech.substack.com/p/spinlocks-vs-mutexes-when-to-spin) [comments] (https://www.reddit.com/r/programming/comments/1pgjrbd/spinlocks_vs_mutexes_when_to_spin_and_when_to/)

KOllector - Publishing KOReader Highlights
https://www.reddit.com/r/programming/comments/1pgkdmr/kollector_publishing_koreader_highlights/

submitted by /u/iamstonecharioteer (https://www.reddit.com/user/iamstonecharioteer)
[link] (https://tech.stonecharioteer.com/posts/2025/kollector/) [comments] (https://www.reddit.com/r/programming/comments/1pgkdmr/kollector_publishing_koreader_highlights/)

How Computers Store Decimal Numbers
https://www.reddit.com/r/programming/comments/1pgonfz/how_computers_store_decimal_numbers/

<!-- SC_OFF -->I've put together a short article explaining how computers store decimal numbers, starting with IEEE-754 doubles and moving into the decimal types used in financial systems. There’s also a section on Avro decimals and how precision/scale work in distributed data pipelines. It’s meant to be an approachable overview of the trade-offs: accuracy, performance, schema design, etc. Hope it's useful: https://open.substack.com/pub/sergiorodriguezfreire/p/how-computers-store-decimal-numbers <!-- SC_ON --> submitted by /u/Kindly-Tie2234 (https://www.reddit.com/user/Kindly-Tie2234)
[link] (https://open.substack.com/pub/sergiorodriguezfreire/p/how-computers-store-decimal-numbers) [comments] (https://www.reddit.com/r/programming/comments/1pgonfz/how_computers_store_decimal_numbers/)

Trying Sandboxing Network Tools with Landlock
https://www.reddit.com/r/programming/comments/1pgp118/trying_sandboxing_network_tools_with_landlock/

<!-- SC_OFF -->Because Network monitoring tools like wireshark etc do need CAP_NET_RAW to capture traffic but normally keep these privileges forever. This potentially creates unnecessary attack surface and even allowed RCE in the past see cvedetails (https://www.cvedetails.com/product/8292/Wireshark-Wireshark.html?vendor_id=4861). Therefore I've been exploring Linux's Landlock security for sandboxing: Start with needed capabilities (CAP_NET_RAW) Open packet capture handle Apply Landlock restrictions (block filesystem writes, network connections) Drop CAP_NET_RAW - existing pcap handles remain valid This seems to work fine and I was able to block filesystem access e.g. restrict it to /proc only for process lookups, network sandboxing to block TCP bind/connect. In my case RustNet (https://github.com/domcyrus/rustnet) though I'm not sure if this will even help that much because if you need eBPF for process-to-socket mapping, CAP_BPF still gives attackers significant capabilities. That said I'm pretty confident that an attacker won't be able to exfiltrate information because there is no filesystem access nor any way to send something across the wire. Has anyone else implemented Landlock sandboxing in their tools? I'm curious how I could improve things further. <!-- SC_ON --> submitted by /u/hubabuba44 (https://www.reddit.com/user/hubabuba44)
[link] (https://domcyrus.github.io/systems-programming/security/linux/2025/12/06/landlock-sandboxing-network-tools.html) [comments] (https://www.reddit.com/r/programming/comments/1pgp118/trying_sandboxing_network_tools_with_landlock/)

F-35 Fighter Jet’s C++ Coding Standards
https://www.reddit.com/r/programming/comments/1pgq8vc/f35_fighter_jets_c_coding_standards/

submitted by /u/azhenley (https://www.reddit.com/user/azhenley)
[link] (https://www.stroustrup.com/JSF-AV-rules.pdf) [comments] (https://www.reddit.com/r/programming/comments/1pgq8vc/f35_fighter_jets_c_coding_standards/)