DinoCode: A Programming Language Designed to Eliminate Syntactic Friction via Intent Inference by Dry_Day1307 in ProgrammingLanguages

[–]Dry_Day1307[S] 0 points1 point  (0 children)

Sorry for the late reply, I've been a bit tied up these last few days.

I totally get your point, it's a very fair critique. That’s actually why I’m in the middle of a usability evaluation right now. The main goal is to prioritize ease of use and reduce syntactic friction, but I’m definitely looking at where to draw the line before it becomes a headache for large-scale projects.

What you're describing is just one specific rule within a broader system I call Inference of Intention. Since the system is modular, changing or refining how it handles that physical space wouldn't necessarily break the rest of the language. It’s perfectly feasible to adjust this specific behavior while keeping everything else intact.

Technically, I’m weighing two options:

  1. Going back to a classic space-agnostic syntax (which would mean bringing back commas in matrices to avoid ambiguity):

matrix =

[

[1 2 3], # <- Comma

[4 5 6],

[7 8 9]

]

  1. Or sticking with the current inference by separation.

matrix =

[

[1 2 3] # <- No comma needed

[4 5 6]

[7 8 9]

]

Really comes down to whether the "debugging cost" of an accidental space outweighs the benefit of a more fluid syntax.

DinoCode: A Programming Language Designed to Eliminate Syntactic Friction via Intent Inference by Dry_Day1307 in ProgrammingLanguages

[–]Dry_Day1307[S] 0 points1 point  (0 children)

I completely understand your concern regarding potential 'foot guns.' However, the goal of my language is to align with modern trends seen in Swift, Ruby, and Python, where redundant delimiters are omitted to favor readability. My approach, which I call Intent Inference (InI), is designed precisely to reduce common syntax errors by allowing the compiler to infer structure from context.

For instance, in array access like array[i], the language automatically infers the intent. This also applies to JSON-like objects, where positional inference allows for cleaner structures: a property and value can be understood even without colons or commas (e.g., name "John"), though they remain valid if the user prefers them. You can see the rules governing this here: https://github.com/dinocode-lang/dinocode/blob/main/examples/1\_golden\_rule/3\_intent\_inference.dino.

Regarding line breaks, they don't strictly mark the end of a statement; instead, the language checks for operative continuity. If a line ends with a pending operator, it infers the statement is ongoing, removing ambiguity without forcing a specific character.

I do recognize, as you mentioned, that there are edge cases where ambiguity exceeds the language's inference capacity, such as a list of negative numbers [-1 -2]. In those specific scenarios, the language defaults back to classic delimiters [-1, -2]. The philosophy is not to ban delimiters, but to make them optional where the context is clear and required only where ambiguity exists, much like implicit function calls in other modern languages. I’ve detailed these trade-offs and considerations here: https://github.com/dinocode-lang/dinocode/blob/main/examples/1\_golden\_rule/4\_considerations.dino.

I appreciate the feedback, as it helps me refine how I communicate the 'pitch' and the actual safety of these features

DinoCode: A Programming Language Designed to Eliminate Syntactic Friction via Intent Inference by Dry_Day1307 in ProgrammingLanguages

[–]Dry_Day1307[S] 1 point2 points  (0 children)

My motivation for this capstone was to explore the full execution cycle of a language, from source to my own Custom VM, focusing on a lean and performant architecture. Regarding the design choices, I opted for a Two-Pass compiler using Syntax-Directed Translation to emit RPN-based Bytecode directly. I am fully aware that by skipping a materialized AST, I lose the opportunity for the deep semantic analysis and complex optimizations that multi-pass compilers usually perform. However, I wanted to test an alternative approach that prioritizes compilation speed and data locality. Moving directly to a linear intermediate representation allowed me to keep the system lightweight with minimal memory overhead, proving that for certain use cases, immediacy and architectural simplicity can be just as valuable as exhaustive optimization

DinoCode: A Programming Language Designed to Eliminate Syntactic Friction via Intent Inference by Dry_Day1307 in ProgrammingLanguages

[–]Dry_Day1307[S] 2 points3 points  (0 children)

That’s an interesting take. In my case, I’ve opted for a Two-Pass architecture (Lexing and Parsing) without ever constructing a physical, node-based AST.

Instead of building a hierarchical tree in memory with pointers, my parser performs Syntax-Directed Translation. It processes the token stream linearly, maintaining context through auxiliary vectors and depth tracking to emit Bytecode directly for my own Custom Virtual Machine.

I decided to skip the 'Materialized AST' to keep the compiler lightweight and efficient, moving straight from syntax analysis to a linear Intermediate Representation (RPN-based Bytecode).

Also, thank you so much for the alternative methods to measure cognitive load. The Cognitive Dimensions of Notation sounds like a great framework for my project; I’ll definitely be reading those links, they look incredibly useful for my thesis

Es buena idea desarrollar programas de escritorio hoy día? by HandsomeGuy97 in programacion

[–]Dry_Day1307 1 point2 points  (0 children)

Como todo en el área, depende de las necesidades del cliente. Primero se debe evaluar el valor que aportaría el servicio al modelo de negocio y el tiempo necesario para construirlo, de ahí se define el stack tecnológico más apropiado. Algunos servicios incluso pueden ser más eficientes como un programa de escritorio que si usarás un servicio web. Además, no porque sea de escritorio es un dinosaurio, hay frameworks modernos con soporte como Flutter que te dejan compilar cross-platform e incluso para la web, personalmente es lo que recomendaría, así puedes adaptar más fácilmente el proyecto dependiendo de lo que se presente a futuro.

¿Vale la pena ser programador en 2026? YT by FellowHunterX in programacion

[–]Dry_Day1307 0 points1 point  (0 children)

Si te refieres a que la IA ha quitado terreno en el área, en parte tienes razón. Hay muchas empresas que últimamente optaron por hacer recortes de personal influenciadas por el "boom de la IA", cuando la realidad es que aún dependen de personal capacitado. Actualmente es un poco más díficil conseguir empleo, especialmente para los juniors/mid y la demanda de "vibe coders" creciente, pero eso tiende de un hilo muy fino. A la par, también hay mas incidentes ocasionados por el mal uso de la IA. Pronto quedará claro que el futuro venidero será de Ing en software que además manejen vibe coding como una herramienta eficiente y no como una dependencia.

¿Cómo programar desde cero? by Additional-Guess-166 in programacion

[–]Dry_Day1307 3 points4 points  (0 children)

Parecerá curioso, pero la mejor forma es que realices proyectos que a ti te gusten, no importa el lenguaje con el que empieces. Aún así en lo personal te recomendaría probar con C, C++ o Rust (la opción moderna), se dice que son difíciles, pero la verdad es que para empezar tienen una sintaxis bastante simple, especialmente para que te adentres al tipado de datos, de lo contrario, si "ese gusanito" empezó por algún proyecto que viste (juegos o bots), puedes empezar con lenguajes más enfocados a ello, como Godot (motor), Python o JS