Numerical loops in Lua are inclusive:

    for i=1,#t do t[i]=0 end

With 0-based indexes, and that numerical loop format, it would be minus-one everywhere:

    for i=1,#t-1 do ...

To me it is more about expressiveness and usage of basic language features. For example here's how a text field is set up currently.

           ito.TextField(draft)
                :label("Name")
                :focused()
                :on_submit(function(value)
                    if value:match("%S") then
                        phase.value = "review"
                    end
                end)
                :on_cancel(function()
                    phase.value = "choose"
                end),

           ito.TextField(draft, {
                label = "Name",
                focused = true,
                on_submit = function(value)
                    if value:match("%S") then
                        phase.value = "review"
                    end
                end,
                on_cancel = function()
                    phase.value = "choose"
                end),
           })

           some_textfield.on_cancel = 

I would like us to find a way to live without killing our host.

We live in different worlds

It is not a joke! The naming is so bad so it sounds like a joke. So people like the author assume it is a joke and move on without suing them. They are counting on that.

I refuse to touch anything crypto with a ten-foot pole. I don't know if that makes me "paranoid", but it is certainly very easy. Just stay away from the thing doing drug markets, scams and rugpulls every month.

Everything must grow all the time because all we care about is compounding interest, and that can only exist with continuous growth.

Finite resources and time be dammed.

Yes part: LLMs have had the capability to generate code, including glue code, to do several steps in a single program.

No part: until some months ago, MCP servers were not prepared to use that glue code at all.

Your LLM could generate the code it wanted, and you could execute that code wherever you wanted, including letting the LLM run it. but every call to any of the tools exposed by the LLM is meant to be consumed by your LLM in the old paradigm. If said program makes 80 tool calls, your LLm would still have to send them, and parse their responses, consuming tokens.

In code mode the glue code is sent to the server, which executes it, and returns the final result. It’s a single invocation and a single response, instead of 80 like before

[1] https://www.youtube.com/watch?v=LNqqFhFa4dI

There's multiple kinds of olives, each producing different kinds of oil. The processing used also affects the end result (extra virgin olive oil comes from the first press, less quality oils from successive processing).

* Picual is the most popular one. It has a strong taste, that "bite" that you mention, and a long shelf life. This means that it is the most exported one. That is probably why you (and others) have associated olive oil with that strong profile. It is however not the only kind out there!

* Cornicabra is the second most popular one. It is milder than Picual in taste, but still strong and durable. You might find it in some specialist shops.

* Arbequina has less of that "bite" that you mention at the end. Unfortunately it has a shorter shelf life as well, which means that it also tends to be exported less.

Because of this is unlikely that you will find it outside of Spain. At the same time it would be the best kind for making mayonnaise, especially if you don't like the bite at the back of the throat (that some people actually enjoy).

And these are just the 3 more popular varieties. There's many more local, smaller ones.

1. Search: The server publishes its tools via a query interface and with gradual level of detail. This way an LLM can discover the tools it needs without loading the ones it doesn't into context. Saves context.

2. The LLM sends glue code when it needs to use multiple tools together. Said code gets executed by the MCP server itself, and it returns the result. Saves tool calls, which saves tokens.

On point 2: Imagine there's 2 tools in the server. One lists customers the other gives sales for a given customer. For a task like "add all the sales for the customers whose name begin with A".

With traditional MCP: the LLM has to use the MCP like a regular HTTP API: first get the customers (1 tool call). Then for every customer begining with A, get their sales (N tool cals). Then add all of the sales (potentially 1 tool call).

With code mode the LLM sends a single program. The program has code that does things like `customers = call_tool("get_customers"); for each c in customers do if customer.name.begins_with("A") then ...` etc etc. That code is sent to the server for execution. So for the LLM it counts as a single tool call.

On the downside, the "code execution" on the Server means that it is executing untrusted code coming directly from LLMs. In order to offer this confidently your MCP servers really needs a very tight sandbox in which to execute this "glue code".

Or when they are hit by any other privacy fuckup like that.

[1] https://futurism.com/facebook-beauty-targeted-ads [2] https://www.bbc.com/news/health-61320202 [3] https://tech.yahoo.com/general/articles/facebook-made-money-...