solomatov

Which is completely unsurprising since ROS (Reactive Oxygen Species) are used by organisms to kill cancer cells, bacteria and other foreign stuff in the body.

P.S. I am neither a doctor nor a biologist.

I don't exactly understand how you could use it for commercial use in the original license quoted in the thread:

>You may download or copy the Content (and other items displayed on the Services for download) for personal non-commercial use only, provided that you maintain all copyright and other notices contained in such Content. You shall not store any significant portion of any Content in any form.

Does personal non-commercial use allow use for work purposes somehow?

P.S. Just curious.

Are you aware of any easy to install distros with such kernels?

Is anyone aware of plans to port Asahi changes to make other linux distros, i.e. Ubuntu, and others, to be able to run without additional setup on M1 Macs?

I would call understanding what's the underlying mechanism behind LLMs and other deep models such a problem. I.e. what's the internal representation? How it emerges over training? What its failure modes.

There're two reasons:

- In order to substantially improve these models we need to understand what they do. Something similar happened with steam engines when thermodynamics helped to explain what they do and improve them substantially.

- We need to understand their failure modes in order to understand their safety profile. I.e. it's AI safety problem.

>Even if this does prove effective in humans, eventually cancer cell defenses will evolve to get around it.

Cancer becomes tolerant to drugs separately for each patient. I.e. initially it isn't resistant, but the drug used on a patient puts evolutionary pressure on the cancer to work around the drug. What this means is that people have more months or years to live, which is great. (I am not a doctor).

It's actually possible to do this. There's a thing which is called perpetual bonds, i.e. bonds which pay a fixed sum ad infinitum. Not surprisingly, they have a non infinite cost. (https://en.wikipedia.org/wiki/Perpetual_bond)

If you add a perpetual bonds with a coupon equal to the service charge, and the service price doesn't increase, you could create a perpetual "free" iCloud offering. However, I think the main problem there aren't that many people who are willing to pay for it.

Yep, I agree with you that it's better to be explicit than implicit here. Initialization/destruction order is often tricky, and source of obscure bugs.

> No destructors.

What's the logic behind this? It's nice to have a way to pair resource usage with disposal. Or does the linear type system allows not to forget about the resources which have to be closed.

Smalltalk has this "feature" and was doing fine. It was pretty popular at some point.

So as I see it, it's possible to teach SOTA LLM with prompts to emulate a state machine part of the Turing machine. Am I right?

Ok. I see. Sorry.

> Are large language models even Turing complete?

If you want to see where they have problem ask them to do something about deep hierarchical objects. For example, consider this prompt: "Draw me a complete binary tree with numbers from 1 to 128 using pseudographics"

In my experience, the deeper the structure, the more problematic it is for the current generation of LLMs.

You are mixing up LLMs with Transformers. Transformers with memory are Turing complete, but AFAIK, current state of the art LLMs aren't trained with any kind of memory.

It's possible to argue that there's no such a thing as infinite precision floats. I.e. all objects have limited "size", and real numbers is just a nice abstraction to simplify discrete world. (https://en.wikipedia.org/wiki/Finitism)

Turing machine is not such thing. At each moment in time, only finitely many cells of the tape are used. (The same applies to natural numbers, there are infinitely many of them, but each one of them has a finite description).

It's not realistically Turing complete. It assumes infinite precision.

IMO, it's a replacement for C/C++ with higher safety guarantees. Of course it's more suitable for ML, and Web, than C/C++, but if there're no hard perf requirements, there're better options.

Systems where you need to prove correctness at least informally. It’s much easier to prove correctness of a functional program than imperative one.

Something with intention to make you money and directly related to powerful machine, i.e. writing code, editing videos, images, etc. As opposed to casual use where you plan simple games, browse internet, etc.

> would make AR coding more productive than simply on a monitor

One obvious thing is much more space. I.e. unlimited number of extra monitors, or entities which work as such.

Not always, if you are connected to a source of electricity and doing something limited by speed performance is critical.

For me, Desktop use is almost perfect on Apple due to battery life and perf but professional use is much better on Intel/AMD+NVidia. Also you could get much more perf for $ on such machines

My understanding is that the book is based on this PhD dissertation.

There's a book which looks like it's based on this dissertation, which probably is a better source to read if you are interested in this topic: https://www.amazon.com/Purely-Functional-Data-Structures-Oka...

> Between the apparently-probabilistic nature of LLMs deciding which instructions ought to be followed

It's not that probabilistic if you want it to be. When sampling from LLMs, you put a temperature parameter, and if it's 0, it will just choose the output which just have the highest probability. It's very large search space, so in practice beam search is used.

- You could read about temperature here: https://nlp.stanford.edu/blog/maximum-likelihood-decoding-wi...)

- You could read about beam search here: https://en.wikipedia.org/wiki/Beam_search

It's not that simple. You couldn't just use any random GPU in the cloud, you need to connect them using the right kind of interconnect (Mellanox bough by NVidia) which is very expensive.

>In a completely manually managed language like C or C++, you can handle fragmentation problems yourself by writing your own allocators or doing object pools to reuse previously allocated memory. You have control over fragmentation.

It's done constantly in Rust. Create a vector of items you want to allocate. Reference to them by their id, i.e. int representing them. There're libraries supporting this style of development, for example, slab: https://crates.io/crates/slab

IMO, the problem is that it doesn't work. It could introduce other bugs, make incorrect changes, or mess up the code. If a good developer does this, it converges, with GPT I am not so sure.

We need to find a way for the system to iterate, debug, write unit tests, and repeat the loop. In theory it's doable, but we are yet to see the system which does this.

It's definitely useful, but IMO it's not 5x or 10x and of course not x1000 force multiplier. More like a very good and useful tool.

What the articles like this miss is that we understand pretty well how ChatGPT writes code. But what about maintenance, and particularly debugging? How would it make these tasks. And we know that these things take much much more time than writing code.

>I assume 10 cores would perform as well as 1 GPU

Transformers are very easily parallelizable.

Take a look at H100 https://www.nvidia.com/en-us/data-center/technologies/hopper... It has 18482 CUDA cores, which for the purposes of the discussion means 18482 multiplications in parallel. They also have tensor cores, which make everything faster several times, i.e. these are essentially special hardware for matrix multiplications.

We could use AVX512 to make many multiplications in parallel (i.e. 512/32 = 16 or 512/64 = 8) on each CPU core, but it wouldn't compare. GPU still wins.