Browsing by Subject "Automatic programming"
Now showing 1 - 2 of 2
Results Per Page
Sort Options
Item Automatic generation of program code from descartes specifications(2011-05) Rattan, PraneetAutomatic programming can be defined as the synthesis of a program from a given specification. The history of automatic programming can be traced back from the 1950s where Admiral Grace Murray Hopper developed the concept of automatic programming with a compiling system by using words instead of mathematical symbols. Automatic programming is the systematic generation of a program from a given specification. The goal of automatic programming is to allow programmers to specify what a program should do, and let the system generate the program code describing how the given program will work. Programs can be specified using a constructible, formal, and comprehensible specification language. Descartes is one such formal specification language, based on the functional model and has the advantages of easy constructability and comprehensibility. In Descartes, specifications are described by defining the input and output data and relating the output data as a function of the input data. This research effort analyzed the various approaches towards automatic programming and reduces the gap between specification and implementation, by introducing a method to automatically transform a Descartes specification of a program into program code in Java. However, programming extends to all fields of computer science. Hence, the scope of this research was limited to automatic implementation of programs from the domain of arithmetic problems, involving basic mathematical functions only.Item The diagrammatic specification and automatic generation of geometry subroutines(2010-05) Li, Yulin, Ph. D.; Novak, Gordon S.; Porter, Bruce; Boyer, Robert; Gouda, Mohamed; Kant, ElaineProgramming has advanced a great deal since the appearance of the stored-program architecture. Through the successive generations of machine codes, assembly languages, high-level languages, and object-oriented languages, the drive has been toward program descriptions that express more meaning in a shorter space. This trend continues today with domain-specific languages. However, conventional languages rely on a textual formalism (commands, statements, lines of code) to capture the programmer's intent, which, regardless of its level of abstraction, imposes inevitable overheads. Before successful programming activities can take place, the syntax has to be mastered, names and keywords memorized, the library routines mastered, etc. Existing visual programming languages avoid some of these overheads, but do not release the programmer from the task of specifying the program logic, which consumes the main portion of programming time and also is the major source of difficult bugs. Our work aims to minimize the demands a formalism imposes on the programmer of geometric subroutines other than what is inherent in the problem itself. Our approach frees the programmer from syntactic constraints and generates logically correct programs automatically from program descriptions in the form of diagrams. To write a program, the programmer simply draws a few diagrams to depict the problem context and specifies all the necessary parameters through menu operations. Diagrams are succinct, easy to learn, and intuitive to use. They are much easier to modify than code, and they help the user visualize and analyze the problem, in addition to providing information to the computer. Furthermore, diagrams describe a situation rather than a task and thus are reusable for different tasks—in general, a single diagram can generate many programs. For these reasons, we have chosen diagrams as the main specification mechanism. In addition, we leverage the power of automatic inference to reason about diagrams and generic components—the building blocks of our programs—and discover the logic for assembling these components into correct programs. To facilitate inference, symbolic facts encode entities present in the diagrams, their spatial relationships, and the preconditions and effects of reusable components. We have developed a reference implementation and tested it on a number of real-world examples to demonstrate the feasibility and efficacy of our approach.