evomassiny

Could you duplicate `RECORD_INST` before each `INSTRUCTION_N`, so that:

```

   INSTRUCTION_1:
     // subroutine 1
     ip++;
     goto *dispatch_var[*ip];

   INSTRUCTION_2:
     // subroutine 2
     ip++;
     goto *dispatch_var[*ip];

becomes: ```

   RECORD_INST_1:
     // record logic
   INSTRUCTION_1:
     // subroutine 1
     ip++;
     goto *dispatch_var[*ip];

   RECORD_INST_2:
     // record logic
   INSTRUCTION_2:
     // subroutine 2
     ip++;
     goto *dispatch_var[*ip];

This way you could directly swap `dispatch_var` with an array populated with the `RECORD_INST_*` labels, and remove one step at runtime.

Or maybe this is what you are trying to avoid to reduce the binary size ?

Can't you solve it using hash trees (or Merkle trees) ?

You tag each computation nodes with a hash of its dependencies and some constant salt, that gives you an ID which identifies the results that the computation node would produce; before running it.

You can then use those IDs to index the computations results in a cache; whenever you query a computation results, as long as you update the IDs of each leaf of the computation graph, you will only re-compute the nodes that need to be updated

In the same vein, there is the "tournesol"[0] browser extension, which plugs its own recommandation algorithm into YouTube, to promote educational videos

[0] https://tournesol.app/

An interesting project, but it seems to be in its infancy :) I definitely want an actor based language to play with, and something with a strong type system would be perfect. gleam [1] and inko [2] look promising in this regard

[1]https://gleam.run/

[2]https://inko-lang.org/

I've nothing to add to the conversation, but I jump on this oportinity to tell you that i like the content you've made with Adam Barth on yt very much, have a great day :)

hyperref does this with the "\ref{}" command, it can link to any defined \label

I thought go binaries were purely static, aren't they ?

It doesn't really make sense to compare a 350T sail boat with a super tanker, a comparable diesel boat produce 36g per ton per km(according to the same report), the "grain de sail II" aims to replace those, and the gains are huge.

According to [0], a typical container ship generate 12.5 g of CO2 per ton per km, which means that one trip from France to NY with 350T of cargo would release about 35T of CO2 in the atmosphere.

I'm convinced that this sail boat generates an order of magnitude less of that (I can't find any estimate of it)

Whatever the initial CO2 cost of the construction of this boat is, I'm sure that it's a net benefits if it's used long enough

[0] https://www.ecsa.eu/sites/default/files/publications/2020%20...

I don't really understand how the yearly tonnage per person is relevant here

How is 360$ of fuel more eco-friendly than 0$ ? I don't get your argument

This is their second boat,and they already do exactly that. So far it's been quite successful

Could you elaborate on why this is not a method by which carbon emissions can be significantly reduced ?

This is only the second boat of a small company, they most likely don't have the ressources to get a bigger one. At this scale, the only way to make money is to move luxury products.

IMO it's a good start.

Population count is just one of many metrics when evaluating the "niceness" of a place. Maybe "destroyed" is not the best way of describing the effect of car dependency (my english is not that good) but a city that doesn't value walking sounds like hell to me.

Houston comes to mind, it has a very low walkbility index (see https://pedestriansfirst.itdp.org/).

This is a valid point, I don't know of any "bus only" highway but it could a good alternative.

a couple of reasons:

* cars destroy cities, they take huge chunks of the public space,

* air pollution,

* noise pollution,

* safety,

* fast floods favored by impermeable soil covers,

* social inequalities (not having a car make you less capable in a car centric environment),

* climate change

Agreed ! Plus, the ability submit a bunch of tasks, and to block until _one_ task completed (akin to `epoll_wait` of tokio's `select`) makes it quite useful. I don't know of a use case or `mutiprocessing.Pool` which is not covered by `concurrent.futures.ProcessPoolExecutor`; so I wonder why both exist

For a fair comparison, hybrid cars can easily do 50+ MPG. For instance the "toyota yaris hybrid" is supposed to run 62MPG (3.8L/100km).

Just like `zero | one | two` is not equivalent to `Option<one | two>`

Isn't it ? both cases represent a type than can express 3 variants

exaclty, whether you call it 'Nothing' or 'null' does not matter, as long as it represents a distinct type than 'true' or 'false'

the type `null | true | false` is different from `true | false`, a type checker can assert that you handle the `null` case before using a function that wants a boolean. This is how rust handles it (with the Option<T> type).

dataclasses document the full set of attribute they can hold, along with their type.