At source{d} we believe that neural networks have opened the possibility for programs to write their own code and for new forms of automatic programming to emerge.

We believe that for systems to be able to understand and write source code, we first need to understand developers through the code they have written. This is because we see programming as a creative craft, similar to painting or writing (read our manifesto). Programming languages were created by people to have an easier and higher level abstraction on top of the 1s and 0s that are interpreted by the machine. Therefore we are designing neural network architectures that learn from the millions of developers who combined have already written trillions of lines of code.

In the last few years, neural networks have made a comeback. They are systems that can be self-learning and trained, instead of programmed. Since early on in the history of neural networks, this has raised the question: if systems can be self-learning, can they also write and optimize their own code? Can a neural network design itself?

We have formulated several steps we believe need to be sequentially conquered:

Step #1: Build representations of source code, developers and projects.

By building representations for source code, developers and projects, we aim to capture style, semantics, syntax and other sets of features that allow us to cluster based on similarity. We consider this important because we want our systems to learn programming by emulating human developers, and to be able to successfully do that, we need to understand first the different styles and approaches to programming.

To bring real value to the world and to understand if our representations are meaningful, we will launch a platform where every developer can claim their public code and connect their private code to be able to find teams and projects they want to collaborate with.

Step #2: Build Artificial Intelligence that does real-time assisted programming

Emulating the work of human developers means must have built an understanding of the different ways a piece of code can be written.

Let’s consider a simple piece of code written by a developer: a function that has well defined inputs and outputs and no side-effects, and you imagine how a machine might be able to write this.

One of the ways is a program that is trained to write all possible programs that generate the expected outputs for the defined inputs. This universe of all possible programs grows larger the more complex the function is. We could then compute every function and understand its performance by evaluating its execution time, computational resources and space used (memory/disk) and choose the most optimal one.

If you imagine how a developer writes this same simple program, you start seeing the notion of intuition and experience. All of this experience is captured in the trillions of lines of code that have already been written by developers. However, as programs stop being so simple, the definition of the “right” code blurs. Performance is no longer the only notion that defines the right program, such others may be: simplicity, elegance, readability, extensibility, etc.

The practical application is technology that can suggest you code, rewrite your code, change your code’s style, optimize code and applications we haven’t yet thought off.

Steps #3: Achieve AI that is self-programming and self-learning in its environment

The final step: Can we come close to replacing ourselves as developers? Can we achieve this without artificial general intelligence? We are willing to find that out.

This post was written by Eiso Kant. Follow him on Twitter: @eisokant.