1,199 research outputs found
SAGA: A project to automate the management of software production systems
The project to automate the management of software production systems is described. The SAGA system is a software environment that is designed to support most of the software development activities that occur in a software lifecycle. The system can be configured to support specific software development applications using given programming languages, tools, and methodologies. Meta-tools are provided to ease configuration. Several major components of the SAGA system are completed to prototype form. The construction methods are described
The Mystro system: A comprehensive translator toolkit
Mystro is a system that facilities the construction of compilers, assemblers, code generators, query interpretors, and similar programs. It provides features to encourage the use of iterative enhancement. Mystro was developed in response to the needs of NASA Langley Research Center (LaRC) and enjoys a number of advantages over similar systems. There are other programs available that can be used in building translators. These typically build parser tables, usually supply the source of a parser and parts of a lexical analyzer, but provide little or no aid for code generation. In general, only the front end of the compiler is addressed. Mystro, on the other hand, emphasizes tools for both ends of a compiler
Translating expert system rules into Ada code with validation and verification
The purpose of this ongoing research and development program is to develop software tools which enable the rapid development, upgrading, and maintenance of embedded real-time artificial intelligence systems. The goals of this phase of the research were to investigate the feasibility of developing software tools which automatically translate expert system rules into Ada code and develop methods for performing validation and verification testing of the resultant expert system. A prototype system was demonstrated which automatically translated rules from an Air Force expert system was demonstrated which detected errors in the execution of the resultant system. The method and prototype tools for converting AI representations into Ada code by converting the rules into Ada code modules and then linking them with an Activation Framework based run-time environment to form an executable load module are discussed. This method is based upon the use of Evidence Flow Graphs which are a data flow representation for intelligent systems. The development of prototype test generation and evaluation software which was used to test the resultant code is discussed. This testing was performed automatically using Monte-Carlo techniques based upon a constraint based description of the required performance for the system
MELT - a Translated Domain Specific Language Embedded in the GCC Compiler
The GCC free compiler is a very large software, compiling source in several
languages for many targets on various systems. It can be extended by plugins,
which may take advantage of its power to provide extra specific functionality
(warnings, optimizations, source refactoring or navigation) by processing
various GCC internal representations (Gimple, Tree, ...). Writing plugins in C
is a complex and time-consuming task, but customizing GCC by using an existing
scripting language inside is impractical. We describe MELT, a specific
Lisp-like DSL which fits well into existing GCC technology and offers
high-level features (functional, object or reflexive programming, pattern
matching). MELT is translated to C fitted for GCC internals and provides
various features to facilitate this. This work shows that even huge, legacy,
software can be a posteriori extended by specifically tailored and translated
high-level DSLs.Comment: In Proceedings DSL 2011, arXiv:1109.032
A distributed agent architecture for real-time knowledge-based systems: Real-time expert systems project, phase 1
We propose a distributed agent architecture (DAA) that can support a variety of paradigms based on both traditional real-time computing and artificial intelligence. DAA consists of distributed agents that are classified into two categories: reactive and cognitive. Reactive agents can be implemented directly in Ada to meet hard real-time requirements and be deployed on on-board embedded processors. A traditional real-time computing methodology under consideration is the rate monotonic theory that can guarantee schedulability based on analytical methods. AI techniques under consideration for reactive agents are approximate or anytime reasoning that can be implemented using Bayesian belief networks as in Guardian. Cognitive agents are traditional expert systems that can be implemented in ART-Ada to meet soft real-time requirements. During the initial design of cognitive agents, it is critical to consider the migration path that would allow initial deployment on ground-based workstations with eventual deployment on on-board processors. ART-Ada technology enables this migration while Lisp-based technologies make it difficult if not impossible. In addition to reactive and cognitive agents, a meta-level agent would be needed to coordinate multiple agents and to provide meta-level control
An Investigation Into the Generality of a Graphical Representation of Program Code for Source to Source Translation
This thesis addresses the problem of defining a source-to-source translation system for reusable software components. It describes the development of an interoperable language for writing software components, and presents a system to translate components written in the interoperable language to a set of compatible target languages. The common features in a set of popular programming languages are analyzed to inform the design of the interoperable language. An evaluation is performed by using the source-to-source translator to convert two well-known open source Java libraries to C++ and Python, and the accuracy and performance of the resulting translations are assessed
Working Notes from the 1992 AAAI Workshop on Automating Software Design. Theme: Domain Specific Software Design
The goal of this workshop is to identify different architectural approaches to building domain-specific software design systems and to explore issues unique to domain-specific (vs. general-purpose) software design. Some general issues that cut across the particular software design domain include: (1) knowledge representation, acquisition, and maintenance; (2) specialized software design techniques; and (3) user interaction and user interface
Action semantics of unified modeling language
The Uni ed Modeling Language or UML, as a visual and general purpose modeling
language, has been around for more than a decade, gaining increasingly wide application
and becoming the de-facto industrial standard for modeling software systems. However,
the dynamic semantics of UML behaviours are only described in natural languages.
Speci cation in natural languages inevitably involves vagueness, lacks reasonability and
discourages mechanical language implementation. Such semi-formality of UML causes
wide concern for researchers, including us.
The formal semantics of UML demands more readability and extensibility due to its
fast evolution and a wider range of users. Therefore we adopt Action Semantics (AS),
mainly created by Peter Mosses, to formalize the dynamic semantics of UML, because
AS can satisfy these needs advantageously compared to other frameworks.
Instead of de ning UML directly, we design an action language, called ALx, and
use it as the intermediary between a typical executable UML and its action semantics.
ALx is highly heterogeneous, combining the features of Object Oriented Programming
Languages, Object Query Languages, Model Description Languages and more complex
behaviours like state machines. Adopting AS to formalize such a heterogeneous language
is in turn of signi cance in exploring the adequacy and applicability of AS.
In order to give assurance of the validity of the action semantics of ALx, a prototype
ALx-to-Java translator is implemented, underpinned by our formal semantic description
of the action language and using the Model Driven Approach (MDA). We argue that
MDA is a feasible way of implementing this source-to-source language translator because
the cornerstone of MDA, UML, is adequate to specify the static aspect of programming
languages, and MDA provides executable transformation languages to model mapping
rules between languages.
We also construct a translator using a commonly-used conventional approach, in
i
which a tool is employed to generate the lexical scanner and the parser, and then
other components including the type checker, symbol table constructor, intermediate
representation producer and code generator, are coded manually. Then we compare the
conventional approach with the MDA. The result shows that MDA has advantages over
the conventional method in the aspect of code quality but is inferior to the latter in
terms of system performance
SAGA: A project to automate the management of software production systems
The SAGA system is a software environment that is designed to support most of the software development activities that occur in a software lifecycle. The system can be configured to support specific software development applications using given programming languages, tools, and methodologies. Meta-tools are provided to ease configuration. The SAGA system consists of a small number of software components that are adapted by the meta-tools into specific tools for use in the software development application. The modules are design so that the meta-tools can construct an environment which is both integrated and flexible. The SAGA project is documented in several papers which are presented
- …