Future AI systems ought to be able to write their own code. Zoea has the potential to make that possible.
Making a computer do anything involves software and that software has to come from somewhere. Most software is currently written by people but in the future that may change. It isn't unreasonable to expect that future AI systems will also to be able to produce software. Understanding how this could be achieved involves a quick recap of various approaches to software development.
Conventional software is written in a programming language. A compiler translates the source code to an executable program.
The classical approach to AI involves writing programs that represent knowledge. Instead of writing instructions about how to perform a task an AI developer produces data (or symbols) that represent concepts. It is then up to some specialist AI software to work out what steps are required from the concepts. This is what is called symbolic AI.
Another approach to AI involves using software that simulates brain cells and their connections. Instead of writing a program, neural network software is trained with lots of example data until it behaves correctly enough of the time. This approach has become dominant in recent years because it is easier and computers are now fast enough to make it possible. However, both approaches to AI are useful and will be necessary going forward.
Its also worth mentioning genetic algorithms which sort of sit on the boundary between AI and conventional software. These simulate evolution and natural selection by mutating and combining members of a population of initially random programs until a suitable solution eventually turns up.
The things that all these approaches have in common are specifications, data and software. Conventional programming languages and symbolic AI turn specifications into software. Neural AI turns data into software and genetic algorithms turn software into other software.
What's clearly missing here is that none of these approaches actually produce their own specifications. However, producing new specifications is one of the key functional mechanisms in Zoea.
Zoea is an AI system that produces software from specifications that resemble a set of test cases. As such a Zoea program consists almost entirely of static data that describes how the required program should behave in terms of inputs and outputs. Internally, the specification is processed by creating a large number of additional specifications (or synthetic test cases) that are often simpler. Each of these is processed in the same way leading to the creation of further generations of specifications. When solutions for the simpler problems have been produced these are combined taking account of any required transformations to produce the software for the original specification.
For Zoea working at the level of specifications rather than that of code makes problems much more tractable. In processing and transforming specifications Zoea is effectively working with abstractions. It is also more transparent and explainable for users.
In order for another AI to use Zoea to produce software it simply has to provide a set of test cases that describe the problem. This is much simpler than trying to produce software directly or describing it through some form of model.
Producing AI systems that write their own code will likely be a watershed in software development. Zoea brings this a step closer.