A software synthesis system is a computer program that takes as input a high-level description of a desired behavior or function and produces as output a lower-level implementation of that functionality in some form of code. The term “synthesis” refers to the process of creating something from scratch, using only basic materials. In the context of software development, synthesis systems are often used to generate code from specifications written in some formal language.
The most well-known example of a software synthesis system is probably the compiler, which takes as input source code written in a programming language and produces as output machine code that can be executed by a computer. However, there are many other types of synthesis systems that have been developed for various purposes. For instance, there are systems that automatically generate test cases from specifications, or that generate hardware designs from high-level descriptions.
Software synthesis systems can be classified according to various criteria. One common distinction is between static and dynamic synthesis systems. A static system generates all its outputs (e.g., code or tests) upfront, before any inputs are provided at runtime. A dynamic system, on the other hand, generates its outputs on demand, based on inputs provided at runtime.
Another common criterion for classifying software synthesis systems is the level of abstraction at which they operate. Low-level synthesizers work with concrete representations of data and functionality (e.g., machine instructions), whereas high-level synthesizers deal with more abstract concepts (e.g., data structures or algorithms). High-level synthesizers are sometimes also referred to as domain-specific synthesizers because they are designed to work with a specific domain (or set of domains) rather than being general purpose tools.
The use of software synthesis systems can offer several benefits over traditional manual coding approaches. First, because they allow for automation, they can potentially save considerable amounts of time and effort during development activities. Second, by working at higher levels of abstraction, they can make it easier to reason about complex behaviors or design problems (since these can be described in terms familiar to humans rather than having to be translated into low-level representations). Finally, since different types of analysis can be performed on generated code (including verification activities), using synthesis methods can help improve the quality and reliability of final implementations