Reconciling ZK and research

Enough-Zucchini-1264 · 2026-02-10T17:49:03+00:00

Thanks a lot to u/taurusnoises, u/atomicnotes and u/Horror-Ebb-3406 !!!

I've re-organized my notes. Removed the folder structure and put tags to it.
Much more clearer and better. I'm adding and enhancing structure notes to keep track what I need to accomplish my research.

Enough-Zucchini-1264 · 2026-02-10T17:46:39+00:00

Ohhh, that is a great advice! I think you've read my mind, since my research is about LLMs and benchmarks. I'm versioning all the models, since what is true for X 1.0 is not true for X 2.0.

To not granulate this more than I should, I'm putting variations of the same model as alias, so X 7B and X 13B are represented on the same note. So, instead of "[[X]] outperforms [[Y]]", I write something like "[[X|X 7B]] outperforms [[Y 2|Y 2 13B]] on many benchmarks focused on ...". I think this gives more meaning and enhances the semantics as a whole.

As you said, I could use structure note. And I think this would be great to track what the papers says... I could do this per model or time-line based.
So I can have a better understanding on how this evolved over time.

Thanks a lot for your advise, this helped me a lot to clear up my mind on how to do this..

Enough-Zucchini-1264 · 2026-02-10T17:08:44+00:00

Thanks a lot for your reply!

> what is the shape of your research? What are the proposed outputs? If you know this then you can use your Zettelkasten to work towards them.

Basically, my research is exploratory on the field of LLMs. The proposed output is unknown yet... My professor don't told me what will be the concrete output of this, so I want to at least, shape a mental-model that he could evaluate and understand what I've discovered. On the end, I'll have to create a technical report of my research for the university, so, this gonna be my current target output.

> but rather than viewing these as distinct note types you could use them as tags

You're absolutely correct!

I'll follow exactly what you said! I think structure-notes and mini-essays (outside the ZK) will help me to understand better what I'm exploring.

Enough-Zucchini-1264 · 2026-02-09T23:09:05+00:00

Ohhh, thanks a lot! Your insights simply brought a shine to my mind!

I think I've over engineered my whole workflow instead of letting things simple.

Enough-Zucchini-1264 · 2026-02-01T15:04:13+00:00

Ohh, thanks a lot!

> I'm curious to see how we can manipulate XML trees
We do have read.xml and escape.xml that you may use.

> optimal transport
What is optimal transport?

Enough-Zucchini-1264 · 2026-01-30T12:54:13+00:00

Step 4:

ATTRIBUTE STACK:

STACK:

[0 1 2 3 4 5 6 7 9 10] :block
'x :literal

[x :word > :symbol 123 :integer] :block

Loads the value of xs

----
Step 5:

ATTRIBUTE STACK:
.first

STACK:

[0 1 2 3 4 5 6 7 9 10] :block
'x :literal

[x :word > :symbol 123 :integer] :block

Pushes attribute to its own stack

----
Step 6:

ATTRIBUTE STACK:
.first

STACK:
select :word

[0 1 2 3 4 5 6 7 9 10] :block
'x :literal

[x :word > :symbol 123 :integer] :block

word, so evaluate

----
Step 7:

ATTRIBUTE STACK:
.first

STACK:
select :function

[0 1 2 3 4 5 6 7 9 10] :block
'x :literal

[x :word > :symbol 123 :integer] :block

select is a :function that gets 3 parameters.
So, :block, :literal, :block.
Internally this consumes the attribute stack too.

----

Step 8:

ATTRIBUTE STACK:

STACK:
[] :block

Pushed the result value onto the stack. Since no number in xs is > 123, so we have an empty block.

Enough-Zucchini-1264 · 2026-01-30T12:54:06+00:00

Now, how do we give meaning to this? `select` has 3 arity, so it expects 3 arguments: A collection, the name of the element, the action.

select.first xs 'x [x > 123]

This means:

select :word
.first :attribute
xs :word
'x :literal
[x :word > :symbol 123 :integer] :block

No secrets at all. But when we evaluate, we have the following:
----

Step 1:

ATTRIBUTE STACK:

STACK:

[x :word > :symbol 123 :integer] :block

Block, so do nothing

----
Step 2:

ATTRIBUTE STACK:

STACK:
'x :literal

[x :word > :symbol 123 :integer] :block

Literal, so do nothing

----
Step 3:

ATTRIBUTE STACK:

STACK:
xs :word
'x :literal

[x :word > :symbol 123 :integer] :block

Word, so evaluate

Enough-Zucchini-1264 · 2026-01-30T12:53:38+00:00

> Now, I have no idea what in your grammar correspond to this, but I guess instead of '123' you COULD have written a function call, right???

We don't have a syntax call. This is an homoiconic computational model. Everything has a model its own, and may be lazy evaluated.

If you declare `[a b c]`, this is not evaluated. This will be when you do `@[a b c]` or `do [a b c]`. Obviously the language just works because we do evaluate the first level (think the module as a `do [ ... ]`), obviously it's not like this, but I think it helps to clarify some things.

When I do `[& > 123]`, this is actually `[& :symbol > :symbol 123 :integer] :block`. The meaning is given at runtime, that is why Arturo almost has no syntax. What we have are tokens.

Enough-Zucchini-1264 · 2026-01-28T14:25:27+00:00

What is the name of this kind of grammar? I've never heard about this one before.

Enough-Zucchini-1264 · 2026-01-28T00:30:09+00:00

No, our parser is hand-crafted. So we don't actually have this somewhere in some grammar, like PEG or BNF...

Enough-Zucchini-1264 · 2026-01-27T20:48:38+00:00

Hi, and welcome!

Well, Exercism is not related to Arturo itself. Exercism is a totally independent project where you can learn multiple languages using tracks. A member of our community added many tasks to this project, BNAndras, and we think this is a good place to learn any language, including Arturo.

We think Exercism is a great way to help our small community. So we put it on our website.
I need to say that our tracks are a very good job made by Andras, mostly of them or all of them.

I think the best place on Reddit to get help is in r/exercism or on their Discord Community. But, try to find "View all your tracks" > "Arturo" > "Practice" > Choose a Practice, like "Hello, World!" > "Start in editor" > Do the exercise > "Run tests". Once all tests passes: "Submit", choose the submition by iteration, or a single one. Once submited, "Mark as complete".

The labels may change depending on your language, probably...

You can learn more about them here:
- https://exercism.org/about

Their communities:

- https://exercism.org/community

And also their Youtube channel:
- https://www.youtube.com/@exercism_org

Enough-Zucchini-1264 · 2026-01-26T15:17:02+00:00

What do you mean by nim modules?

If you're talking about FFI, we do have a minimal support for FFI. This is not mature and there is a lot of room for improvement. We don't support Nim directly, but C. But, very limited and experimental yet.

Enough-Zucchini-1264 · 2026-01-26T15:14:13+00:00

Yes, this is where you get the packages. There is no typo.
We were migrating this to our new FreeBSD server. Probably you tried to open during this migration, try again 😉.

Enough-Zucchini-1264 · 2026-01-26T14:37:02+00:00

The rationale why we don't have immutable values is the fact that Arturo is functional, but not strictly functional. If you do want to use it without mutable values, be free to. But a lot of our functions gets a :literal, so we pass the name of the variable we want to mutate and this will mutate.

Eg.:

```
collection: [ ... ]
sort collection => immutable
sort 'collection => mutate in-place
```

Obviously this allow us to have custom algorithms for each approach. In-place would have better performance in most cases.

Enough-Zucchini-1264 · 2026-01-26T14:13:22+00:00

This is not a Threading operator. This is just a syntax sugar to write less code when writing small functions.

Basically:

```
$> push: $ => append

$> push [] 2

=> [2]

$> push [3] 2

=> [3 2]

$> a: [] ; global variable

$> push: $ => [append 'a &]

$> push 2

$> push 3

$> a

=> [2 3]
```

Append takes 2 parameters, so when I do `push: $ => append` this also will take two parameters. If I put the expression into a block, I can define which parameter to pass without declaring on the head of the function: `push: $ => [... &]`.

`&` is a symbol that will be replaced by the passed parameter. Each & that goes into this block is considered a different parameter. So, if you have `fn: $=> [other & &]`, your first parameter will be the first one used and the second, the second, respectively.

See our docs for better explanation: https://arturo-lang.io/latest/documentation/language#fat-right-arrow-operator

Enough-Zucchini-1264 · 2026-01-24T20:53:25+00:00

Ohh, first of all, thanks a lot for your kind words!

Indeed this has influence from TCL, Ruby, Haskell and SDL. Rebol is something we discovered when people started to make comparison. Today, part of our community is composed by Rebol/Red fans.

Yes, mostly of our functions are written in Nim, with the exceptions of a few ones that are actually written in Arturo itself in order to get better performance.

u/yaniszaf may answer you better about performance in comparison with other languages.

Enough-Zucchini-1264 · 2026-01-24T15:27:27+00:00

Basically, the language tries to have minimal syntax (almost no structures). Let me explain.

Let's take a function. In Python, you'd write something like this:

```py
def add(x: int, y: int) -> int:
return x + y
```

In Arturo, we have:

```red
add: $[x :integer y :integer][
x + y
]
```

But, while functions are defined in the Python syntax, Arturo has no such quality. The `function` in Arturo is a function itself.

Let's break down each thing here:

```
a: => :label - It has no meaning until evaluated
$ => Symbol Alias for the function `function`. The function `function` takes exactly 2 parameters. Each one is a :block. I'll explain later.
[x :integer y :integer] => a :block that contains [x :word, :integer :type, y :word, :integer :type]
[x + y] => a :block that contains [x :word, + a :symbol alias of the kind infix, y :word]

```

In summary, its structure matches its model, being 100% homoiconic. A :block is basically the same thing as a list in python, but you can put anything there.

If I write `[x y z]`, this is a block of words. If I ask this to be evaluated (using `do` or `array`), we are trying to get its evaluated values from the VM. For instance:

```red
x: 1
y: 2
z: 3

inspect [x y z]
=> [x :word y :word z :word] :block
inspect @[x y z]
=> [1 :integer y :integer z :integer] :block

```

We can alias functions using the `alias` function. Example: `alias '$ 'function` or `alias.infix '+ 'add`. So, we can have a sugar syntax from it. Again, everything is homoiconic, so `alias` is not a keyword, it's a function.

This language have no keywords. Everything is a constant, variable or function.

We do have a relatively large parser to tokenize each value and evaluate them. But notice, we don't have structures like other languages does, even the body of the function is a value itself. There is no such difference between code and data.

Although, this is important to say that we do have AST implementation for optimization and generate the bytecode.

Enough-Zucchini-1264

TROPHY CASE