Prototypes, products and open-source

Difference between an open-source prototype and an open-source product

Often, a real innovation is discussed openly, for instance the Transformers article. In hindsight, it would have been better for Google to not publish such article. But for Google, it was worth it to publish most of its AI research up to the Transformers article. How to know in a context where it is worth it to publish most research, that one specific article will be very successful and therefore should not be published? It is very unlikely to get this right, because the success of an idea depends on how it can be customized to the real-world. And this no one really knows, because this depends not only on the idea (which must make idealized assumptions), but also on the real-world (which is complex and dynamic). When an idea is discussed publicly and fully, this speeds up the process of customization of the idea to the real-world, such process is required to produce a successful idea. A prototype serves testing/demonstration purposes, thus it is a relevant tool to discuss publicly an idea. Often, all the details of a prototype are made public.

If an idea is successful, this often leads to customized products. However, if we want to update an idea, or compose it with more ideas, then the details of the previous customized products are largely irrelevant if we know the details of the prototypes. Customization produces commercial value, but it introduces noise that dilutes the innovation.

Since no product is successful forever without upgrades, in the long term only the details of the prototype survive, not those of the product. This has always been the case, for most existing products.

In the last few decades, there is the rise of open-source software products. While in principle such product can contain all the details of the prototype, in practice this is not so, If we want to significantly change the software, there is not enough information available, this creates dependency on the software creators, which was the goal of distributing the open-source software.

That does not make the "open" (in open-source software products) useless, but it is certainly not much relevant for customization.

Specification language vs. theoretical physics

An open-source prototype is usually defined by a specification, written in some specification language. Certainly, the prototype is much more than its written specification, but the specification is the irreducible core of the prototype, in the sense that as long as the specification exists, then the prototype is reproducible and thus it already "exists". Note that a prototype is necessarily reproducible since it serves testing/demonstration purposes.

But do we need to invent a specification language? Certainly, a specification language includes mathematics and theoretical physics is an example of a specification language (since it is the language of engineering). The boundaries of physics are those of real events: an event is real if there is enough evidence of it, accordingly to some Bayesian prior. This includes all reproducible events. Thus any specification language (in the context of a prototype) is theoretical physics.

Note that it is debatable whether theoretical physics is more than a specification language (in the context of a prototype). For instance, Cosmology studies the beginning of the Universe, which is virtually impossible to reproduce in practice, but then no event can be exactly reproduced and based on some prior we can claim that we can reproduce the beginning of the Universe "well enough".

This also establishes the relation between Artificial Intelligence and Physics. Models of Artificial Intelligence are prototypes, defined by specifications. Moreover, Language models process (that is, transform or improve) specifications, written in a specification Language.