wolf4earth

The point of the argument is that meaning emerges in conversation. A session between human and AI is a conversation.

Current AI storage paradigms offer lateral memory across the time axis. What exists around me?

A bit branch is longitudinal memory across the time axis. What exists behind me?

Persist type checked decision trees within it. Your git history just became a tamper-proof, reproducible O(1) decision tree. Execution becomes a tree walk.

It works. And it's not production ready yet.

AI content is clearly marked as such.

The rest is written by me personally on my shoddy MacBook.

You don't understand my writing. Hence I must be stupid.

Interesting conclusion. ;)

Or people like the neuroqueer author.

It's a synthesis of multiple problem domains that thought they were special. When the truth is: they weren't.

It was fragmented? Good.

Welcome to reality. ;)

I wonder how Kubernetes would look like if it was built on top of the BEAM.

This talk by Saša Jurić (author of Elixir in Action) should answer most of your questions regarding the benefits of the BEAM (Erlang VM).

https://youtu.be/JvBT4XBdoUE

Seriously, if you're even the slightest bit curious you should watch the talk, I'm very confident that you'll find impressive what the BEAM brings to the table.

Just FYI `<>` is already the string concatenation operator. Just in case you're not aware. :)

That would be my guess as well.

Rust seems to be a good choice considering their initial reasoning behind choosing OCaml. It offers static typing with support for sum types and is reasonably fast, while certainly providing more in terms of libraries.

What's your take on dhall-lang[^1] for configuration?

[^1]: https://dhall-lang.org/

At the end of the day, what's the difference between restarting the app because you updated an environment variable, or restarting the repo?

In both cases you might have short service interruptions. So why not simply restart the app which is definitely more technology agnostic.

Now I feel like a fool.

There is another option, using a `Task`.

Using child specifications one can pass the function to be executed in the `Task` alongside:

  children = [
    Child1,
    Child2,
    {Task, &MyModule.run_on_start/0}
  ]

  # ...

Effectively does the same as using the `handle_continue` of a `GenServer` but in a more clear, straight forward manner.

I actually know the people behind Dropshare. They are former colleagues of mine.

Maybe I can get you in touch?

While that is true it does not make a difference for day to day programming, unless you are super accustomed to think about locks.

You can get very far in Elixir without considering the nitty gritty parts of OTP.

Performance is definitely not close to Ruby, this is just blatantly incorrect. Elixir and Erlang can easily hold their ground vs Go.

The BEAM was originally designed to run software for telephone switches. It's often referred to as soft realtime because it is so responsive. It has been battle-tested for now over 3 decades.

Where the BEAM falls flat is pure number crunching but it's blazing fast with binary processing (e.g. string parsing).

A fresh phoenix project where you render a nontrivial template easily reaches sub millisecond response times, without any kind of optimization.