Well, if the revenue remains the same for the author, and it also doesn't decrease for Google, it is implied that their margin will have to also be paid by the person who donates, for else the calculation will not work.
There does seem to be a fairly strong correlation between excelling at competition and research mathematics respectively. The question remains whether this correlation generalizes to nonhuman cognition.
> They could have spun up a million parallel reasoning processes
But alas, they did not, and in fact nobody did (yet). Enumerating proofs is notoriously hard for deterministic systems. I strongly recommend reading Aaronson's paper about the intersection of philosophy and complexity theory that touches these points in more detail: [1]
I have always wondered about what could be recovered if the antecedent (i.e. in this case the Riemann hypothesis) does actually turn out to be false. Are the theorems completely useless? Can we still infer some knowledge or use some techniques? Same applies to SETH and fine-grained complexity theory.
So instead of contributing to authors, you need to altruistically donate a large proportion of your money to Google in exchange for replacing a single kind of advert? Unlike some other Google products I can very easily see why this was discontinued...
Dynamic optimality sounds like a very euphemistic description of Levin's Universal Search to me – it is definitely optimal, just in a very, hmm, dynamic, let's say, way.
This made me think – the fact that the underlying rule that nouns e.g. representing activities such as cooking can be formed from the corresponding verb via the suffix -er breaks in this case is just a historical / cultural artifact of languages, a type of completely unnecessary complication from the machines' standpoint. Maybe LLM hallucination might also partially be caused by this exception-based social modelling forced via our training data into all model architectures?
Modern neuroscience suggests that everything the human brain might be doing is basically a kind of predictive processing, i.e. hallucination based on inductive biases. I do not think this is the main bottleneck.
It may also come down to laptops being produced and sold mostly by US companies, which means that the general fact of most items (e.g. produce) being much more expensive in the US compared to, say, Europe doesn't really apply.
I would not subscribe to your certainty. With LLMs, even empty or nonsensical prompts yield answers, however faulty they may be. Based on its level of comprehension and ability to generalize between languages I would not be too surprised to see LLMs being able to communicate on a very superficial level in a language not part of the training data. Furthermore, the compression ratio seems to be much better with LLMs compared to Wikipedia, considering the generality of questions one can pose to e.g. Qwen that Wikipedia cannot answer even when knowing how to navigate the site properly. It could also come down to the classic dichotomy between symbolic expert systems and connectionist neural networks which has historically and empirically been decisively won by the latter.
It is true that any sufficiently complicated technology requires a certain skill level to use it adequately. The question remains whether the complexity of the technology is justified, and the author presents an argument why this might not be the case. Remarking their supposed lack of skill does not seem particularly productive.
Someone should create a DAG of programming languages with edges denoting contextual influence and changes in design and philosophy, such that every time a PL is critized for a feature (or lack thereof), the relevant alternatives exactly considering this would be readily available. It could even have a great interactive visualization.
It would not just be "confusing". It would be fundamentally unacceptable because there would just be no local reasoning anymore, and a single private field change might trigger a whole cascade of nonlocal borrowing errors.
Unfortunately, this behavior does sometimes occur with Send bounds in deeply nested async code, which is why I mostly restrain from using colored-function style asynchronous code at all in favor of explicit threadpool management which the borrow checker excels at compared to every other language I used.
Arc<Box<T>> is redundant, for the contents of the Arc are already stored on the heap. You may be thinking of Arc<Mutex<T>> for multithreaded access or Rc<RefCell<T>> for singlethreaded access. Both enable the same "feature" of moving the compile-time borrow checking to runtime (Mutex/RefCell) and using reference-counting instead of direct ownership (Arc/Rc).
Think of Rust as a kind of kernel guaranteeing correctness of your program, the rules of which your transpiler should not have to reimplement. This may be compared to how proof assistants are able to implement all sorts of complicated simplification and resolution techniques while not endangering correctness of the generated proofs at all due to them having a small kernel that implements all of verification, and as long as that kernel is satisfied with your chain of reasoning, the processes behind its generation can be entirely disregarded.
I believe that codebases written in Rust, with borrow checking in mind, are often very readable and allow local reasoning better than most other languages. The potential hardness might not stem from "making people better programmers" but from "making programmers write better code, perhaps at the cost of some level of convenience".
But in that case brand association is an empty signal. As a paying customer, I can't meaningfully infer anything from it, and would thus best disregard it entirely.
If one is calibrated to report proper percentages and assigns 8% to 25 distinct events, you should expect 2 of the events to occur; 4 in case of 16% and 22.5 in case of 90%. Assuming independence (as is sadly too often done) standard math of binomial distributions can be applied and used to distinguish the prediction's accuracy probabilistically despite no actual branching or experimental repetition taking place.
Exactly, this is what I meant. No matter how much or for which reasons one might dislike LLMs, you can't deny that they are the best general NLP tools we have right now.
Interesting idea. Surely one could write a weather command that would just forward $@ to a LLM to make a structured request. On the other hand, this doesn't seem useful enough to justify the needed compute.
However errors do not seem to commonly wrapped, tagged or contextualized as is the case in Rust. This might weight lower verbosity as more important than extremely structured error handling which definitely constitutes an interesting approach.