It's more expensive than industrial solar farms.

Aesthetics over economics.

For sure they will read a pdf and not a google doc.

It's not ML, but it is AI

Are these just traditional distributed algorithms?

Chrome has tab search. In MacOS, Shift+Cmd+A

They do not leave out WebExtension support, they are working to get there:

> We're focusing on #2989 since it will allow running Nyxt on macOS and support WebExtensions. https://github.com/atlas-engineer/nyxt/issues/2875#issuecomm...

Like, they are working on it right now. Or the prerequisite, to get electron version of Nyxt working. https://github.com/atlas-engineer/nyxt/issues/3544

>The Cyc knowledge base involving ontological terms was largely created by hand axiom-writing

>An inference engine is a computer program that tries to derive answers from a knowledge base. The Cyc inference engine performs general logical deduction.[8] It also performs inductive reasoning, statistical machine learning and symbolic machine learning, and abductive reasoning. The Cyc inference engine separates the epistemological problem from the heuristicproblem. For the latter, Cyc used a community-of-agents architecture in which specialized modules, each with its own algorithm, became prioritized if they could make progress on the sub-problem.

Not really.

This does not seem correct. There was a vision of using M-expressions, (Metalanguage) but it never happened.

>In computer programming, M-expressions (or meta-expressions) were an early proposed syntax for the Lisp programming language, inspired by contemporary languages such as Fortran and ALGOL. The notation was never implemented into the language and, as such, it was never finalized https://en.wikipedia.org/wiki/M-expression

arr was defined to be an array of strings. How are you pushing a boolean there?

Because you've given the function no information on whether those two "things" are related. You're saying when it gets passed into that function it can be treated as either with type widening.

I understand it may be unwanted at first glance, but this is a contrived example for demo purposes. You wouldn't really make an "add to array" function like this so specifically. You would use generics, which would solve the exact issue that is posed.

    function add<T>(item: T, dst: T[]): void {
        dst.push(item);
      }

Now you can work with any array, and it will only add items with the right type.

If you really need it to be just <Thing>, you can do this

    function add<T extends Thing>(item: T, dst: T[]): void {
        dst.push(item);
    }

Now it knows that Item and DST are related but need to be Thing.

There's not a lot of languages with unions that handle this differently. F# discriminated unions make you specify which type you're using every time. For example, this doesn't even compile.

    type Thing =
        | A of int
        | B of bool
    let arr: Thing list = [1]  // Not an A or B type!

Can you clarify, are you also an LLM, or are you a human dev? > This readme is maintained by the readme-updater script.