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/)

Architecture Case Study: [Open Source] Platform for Research into the Foundational Physics of Open-Ended Evolution
https://www.reddit.com/r/programming/comments/1pgqac8/architecture_case_study_open_source_platform_for/

<!-- SC_OFF --> Why I am posting this: I am looking for architectural feedback and potential collaborators (System Engineering, Compiler Design, A-Life Physics) for a challenging open source research project. 1. The Mission I am building Evochora, a laboratory designed to investigate the hurdles towards Open-Ended Evolution (OEE). Landmark systems like Tierra or Avida were milestones, but the field hasn't yet cracked the code for creating truly unbounded complexity. My goal is to provide a rigorous platform to study exactly why digital evolution gets stuck and to test solutions (like thermodynamics, signaling, multi-threading, etc.) that might help us progress on one of the most profound goals in science: Understand whether the evolutionary path taken on Earth — from self-replication to multicellularity and cognition — is a unique accident or the result of a universal principle. Existing landmark A-Life systems demonstrated that code can evolve. However, they often face evolutionary stagnation. To keep simulations stable, they rely on "disembodied" logic, artificial CPU quotas, or predefined goals. I built Evochora to test the hypothesis that emergent complexity arises from embodiment and physics. For more details, here is the full scientific overview: Scientific Overview & Architecture Deep Dive (https://github.com/evochora/evochora/blob/main/docs/SCIENTIFIC_OVERVIEW.md) Comparison of Approaches: Feature Traditional A-Life (e.g. Avida) Evochora Architecture Agent Body Disembodied (CPU + Memory Buffer) Embodied (IP + Data Pointers in Spatial Grid) Interaction Limited / Message Passing Spatial (Competition for shared memory cells) Physics Fixed / Task-Specific Extensible (Pluggable Energy & Mutation models) Execution Sequential Logic Parallel & Multi-threaded (via FORK instruction) 2. The "Physics" Core: An Embodied VM The platform is architected from the ground up to serve as a flexible and high-performance testbed. Its design is guided by the principles of modularity, spatial embodiment, and extensible physics. The Conceptual Architecture of the VM: +---------------------------------------------------------------+ | Evochora "World" (n-D Molecule Grid) | | | | [ ENERGY ] [ STRUCTURE ] [ CODE ] [ DATA ] | +-------^-----------------^----------------^-------------^------+ | | | | Interaction: | | | | (HARVEST) (BLOCK) (EXECUTE) (READ) | | | | | | | | +-------|-----------------|----------------|-------------|------+ | | ORGANISM | | | | | | | | | | | +---v-----------------v----+ +----v-------------v----+ | | | Data Pointers (DPs) | | Inst. Pointer (IP) | | | | [DP 0] [DP 1] ... [DP n] |<-----| | | | +--------------------------+ +-----------------------+ | | ^ ^ | | (Move/Read/Write) (Control) | | | | | | +-------------v----------------------------------v------+ | | | Virtual Machine | | | | Registers: [DRs] [PRs] [FPRs] [LRs] (Locations) | | | | Stacks: [Data Stack] [Call Stack] [Loc. Stack] | | | | Metabolism: [Energy Register (ER)] --(Cost)--> 0 | | | +-------------------------------------------------------+ | +---------------------------------------------------------------+ Each organism executes instructions with its dedicated VM. The instructions are not linear but live as molecules in a spatial n-dimensional world. To define primordial organisms, I created a specialized assembly language (EvoASM) that is translated into machine code by the multi-pass compiler included in Evochora. The compiler supports macros, labels, and procedures, and emits the n-dimensional machine code that the VMs execute. All VMs share the same environment (basically serving as RAM), in which organisms must interact to navigate, harvest energy, and replicate to survive. Full EvoASM Language Reference

(https://github.com/evochora/evochora/blob/main/docs/ASSEMBLY_SPEC.md) 3. Solving the Data Flood: Distributed Data Pipeline Simulating evolution generates a massive amount of data (>100 GB/hour for dense grids). If the physics loop waits for disk I/O, performance collapses. So the Simulation Engine is decoupled from persistence, indexing, and analytics using an asynchronous, message-driven pipeline. Data Flow Architecture: ┌────────────────────────────┐ │ SimulationEngine │ └─────────────┬──────────────┘ │ (TickData) ▼ ┌────────────────────────────┐ │ Tick Queue │ └─────────────┬──────────────┘ │ (Batches) ▼ ┌────────────────────────────┐ │ Persistence Service │ (Competing Consumers) └─┬─────────────────────┬────┘ │ (Data) (BatchInfo Event) │ │ ▼ ▼ ┌───────────┐ ┌───────────┐ │ Storage │ │ Topics │ └─────┬─────┘ └──────┬────┘ │ (Reads) (Triggers) │ │ └────────┬────────┘ │ ▼ ┌────────────────────────────┐ │ Indexer Services │ (Competing Consumer Groups) └─────────────┬──────────────┘ │ (Indexed Data) ▼ ┌────────────────────────────┐ │ Database │ └─────┬───────────────┬──────┘ │ │ (Queries) ▼ ▼ ┌────────────┐ ┌────────────┐ │ Visualizer │ │ Analyzer │ (Web based) └────────────┘ └────────────┘ 4. Project Status & Roadmap The engineering foundation is solid. We are now transitioning from "Building the Lab" to "Running the Experiments". Engineering Maturity: Component Status Feature Highlights Virtual Machine ✔ Functional Full register set, 3 stacks, dual-pointer architecture. Compiler ✔ Functional Multi-phase immutable pipeline with source-map generation. Data Pipeline ✔ Architected Decoupled architecture designed for cloud scalability. Visualizer ✔ Live WebGL-based real-time inspection of organism memory/registers. Biology ⚠️ Unstable Self-replication works, but as expected tends towards "Grey Goo" collapse. Callout I am looking for contributors who are just as thrilled as me about pushing the science of artificial life beyond the next frontiers. I need help in any kind of aspect: Engineering: Improve and extend the VM and compiler design to shape the physics of the digital world. Scale: Improve and extend the data pipeline for massive cloud scaling. Frontend: Improve and extend the existing analyzer and visualizer frontends (e.g., for controlling the data pipeline). Science: Researchers and scientists to help provide the scientific background to surpass the hurdles towards open-ended evolution. Resources: Repo: GitHub Source Code (https://github.com/evochora/evochora/blob/main/docs/SCIENTIFIC_OVERVIEW.md) Docs: Scientific Overview (https://github.com/evochora/evochora/blob/main/docs/SCIENTIFIC_OVERVIEW.md) Spec: EvoASM Reference (https://github.com/evochora/evochora/blob/main/docs/ASSEMBLY_SPEC.md) Demo: Running Demo System (http://evochora.org/) I am happy to receive any kind of feedback or questions! <!-- SC_ON --> submitted by /u/Hot-Requirement-3485 (https://www.reddit.com/user/Hot-Requirement-3485)
[link] (https://github.com/evochora/evochora/) [comments] (https://www.reddit.com/r/programming/comments/1pgqac8/architecture_case_study_open_source_platform_for/)

Dataflow Templating -- The Missing Semantic in Reactive Dataflow Programming
https://www.reddit.com/r/programming/comments/1pgsymp/dataflow_templating_the_missing_semantic_in/

<!-- SC_OFF -->Clone subgraphs on demand as an analogue to function calling. I wrote this in Observable Dataflow but it should apply to most Reactive Dataflow programming systems like FrTime. <!-- SC_ON --> submitted by /u/tlarkworthy (https://www.reddit.com/user/tlarkworthy)
[link] (https://observablehq.com/@tomlarkworthy/dataflow-templating) [comments] (https://www.reddit.com/r/programming/comments/1pgsymp/dataflow_templating_the_missing_semantic_in/)

Trying to explain Google's PageRank
https://www.reddit.com/r/programming/comments/1pgtzgy/trying_to_explain_googles_pagerank/

<!-- SC_OFF -->I am trying to explain Google's Page Rank Algorithm in an easy graphical way and was looking for some feedback on if it is understandable. I am heavily inspired by 3Blue1Brown. Any feedback is greatly appreciated. <!-- SC_ON --> submitted by /u/RealSirJoe (https://www.reddit.com/user/RealSirJoe)
[link] (https://www.youtube.com/watch?v=RWEzFmxqwPQ) [comments] (https://www.reddit.com/r/programming/comments/1pgtzgy/trying_to_explain_googles_pagerank/)

Three Systems Thinking Rules for Effective Observability
https://www.reddit.com/r/programming/comments/1pgv6by/three_systems_thinking_rules_for_effective/

submitted by /u/congolomera (https://www.reddit.com/user/congolomera)
[link] (https://thesystemistsimon.medium.com/three-systems-thinking-rules-for-effective-observability-02725cef5d7b?source=friends_link&sk=6146ba0492f0a14e503768cbff012be6) [comments] (https://www.reddit.com/r/programming/comments/1pgv6by/three_systems_thinking_rules_for_effective/)

Server-Side Request Forgery: How it Works
https://www.reddit.com/r/programming/comments/1pgwvfu/serverside_request_forgery_how_it_works/

submitted by /u/GiraffeFire (https://www.reddit.com/user/GiraffeFire)
[link] (https://youtu.be/EWdphas_OP4) [comments] (https://www.reddit.com/r/programming/comments/1pgwvfu/serverside_request_forgery_how_it_works/)

MyCTiger: Use the Ring programming language for generating and building C programs (Prototype of the idea).
https://www.reddit.com/r/programming/comments/1pgx1go/myctiger_use_the_ring_programming_language_for/

<!-- SC_OFF -->MyCTiger transforms the Ring programming language into a powerful domain-specific language (DSL) for generating and building C programs. It empowers developers to enjoy the performance and efficiency of C while leveraging Ring’s expressive syntax and productivity for DSL creation. Unlike traditional approaches that embed Ring within C applications or extend the Ring VM using C code, MyCTiger reimagines Ring as a meta-language for C. This isn’t about runtime language integration—it’s about compile-time code generation. With MyCTiger, Ring becomes a high-level interface for producing C code, enabling direct injection of raw C and seamless use of existing C libraries without bindings. It is only a prototype to demonstrate the idea, so interested developers can enhance it in their own forks according to their needs, design, or vision (i.e. Keeping the current prototype simple is very important for educational purposes). <!-- SC_ON --> submitted by /u/mrpro1a1 (https://www.reddit.com/user/mrpro1a1)
[link] (https://github.com/ringpackages/myctiger) [comments] (https://www.reddit.com/r/programming/comments/1pgx1go/myctiger_use_the_ring_programming_language_for/)

My Advice For Engineers and Engineering Leaders to Get a New Role Faster
https://www.reddit.com/r/programming/comments/1pgy4hv/my_advice_for_engineers_and_engineering_leaders/

submitted by /u/gregorojstersek (https://www.reddit.com/user/gregorojstersek)
[link] (https://newsletter.eng-leadership.com/p/my-advice-for-engineers-and-engineering) [comments] (https://www.reddit.com/r/programming/comments/1pgy4hv/my_advice_for_engineers_and_engineering_leaders/)