Constructing an advanced software tool for planetary atmospheric modeling

Scientific model building can be an intensive and painstaking process, often involving the development of large and complex computer programs. Despite the effort involved, scientific models cannot be easily distributed and shared with other scientists. In general, implemented scientific models are complex, idiosyncratic, and difficult for anyone but the original scientist/programmer to understand. We believe that advanced software techniques can facilitate both the model building and model sharing process. In this paper, we describe a prototype for a scientific modeling software tool that serves as an aid to the scientist in developing and using models. This tool includes an interactive intelligent graphical interface, a high level domain specific modeling language, a library of physics equations and experimental datasets, and a suite of data display facilities. Our prototype has been developed in the domain of planetary atmospheric modeling, and is being used to construct models of Titan's atmosphere

Reusability in software engineering

This paper surveys recent work concerning reusability in software engineering. The current directions in software reusability are discussed, and the two major approaches of reusable building blocks and reusable patterns studied. An extensive bibliography, parts of which are annotated, is included

A rule based approach to program development

A rule based transformational model for program development and a metatool based on the above model is presented. The meta-tool can be instantiated to create various program development tools such as tools for building reusable software components, language directed editors, language to language translators, program instrumentation, structured document generator, and adaptive language based prettyprinters. This new rule based approach has two important features: 1) it is language independent and can be applied to various languages, and 2) provides a powerful escape mechanism for extending the semantics of the rules. Instances of the meta-tool for restructuring source programs for building abstract components and their refinement to concrete instances, source-to-source translation, and source contraction and expansion tools for improving readability and understanding are described

Artimis : a module indexing and source program reading and understanding environment

Artimis is part of an environment for software reuse consisting of two logically independent portions, 1) the indexing and retrieval facility called, GrabBag, for storage and subsequent retrieval of reusable modules, and 2) a set of tools called Browsers, which aid reading and understanding of source programs. GrabBag creates a highly simple and friendly interface for retrieval of viable candidates for reuse. Browser's tool set, The Module Interconnection Graph Builder, Procedure Call Graph Builder, and Module Abstractor create different levels of abstraction to help a programmer understand a source program.Keywords: Programming environment, program transformation, source code mutation, code fragments, code selection, program understanding, program reading, program maintenance

Arash : a re-structuring environment for building software systems from reusable components

Arash is a rule-based tool for re-structuring source programs in order to build software systems from reusable components. Arash incorporates a collection of Generalizers which transform source code modules into abstracted modules. Conversely, a collection of Refiners produce a concrete instance from an abstracted source module . Both Generalizers and Refiners operate on source code components called fragments to restructure existing programs, documentation, and associated text. The main significance of Arash is that it is a rule-based tool which can be applied to a family of programming languages, e.g. Pascal, Modula-2, and C. In this paper we describe how to use Arash to restructure Modula-2 source code modules taken from a programmer's database of reusable components in order to construct new software systems, quickly and correctly .Keywords : Programming environment, program transformation, source code mutation, syntax directed tools, code fragments, code selection, customizing, general software, generic systems, program generation, tailoring, reuse of software

Yashar : a ruled based meta-tool for program development

Yashar is a rule based meta-tool for rapidly producing tools to increase programming speed through automating restructuring of existing source code modules so they can be reused, generating of syntax-directed tools, language-to-language translation, automated document generation , and various debugging tools. The main significance of Yashar is that it can be tailored to a wide variety of applications through the specification of rules. In this paper we describe the rule processor, rule syntax, and how to create an instance of Yashar for translating Modula-2 source programs into equivalent C source programs, automatically. Finally, we conclude that Yashar is a generalized meta-tool which can be tailored to a wide variety of application-specific tools by hand-crafting a small number of application-specific interface and support routines.Keywords: Programming environment, program transformation, source code mutation, syntax directed tools, rapid prototyping, source language to source language translation

SAGA: A project to automate the management of software production systems

The Software Automation, Generation and Administration (SAGA) project is investigating the design and construction of practical software engineering environments for developing and maintaining aerospace systems and applications software. The research includes the practical organization of the software lifecycle, configuration management, software requirements specifications, executable specifications, design methodologies, programming, verification, validation and testing, version control, maintenance, the reuse of software, software libraries, documentation, and automated management

A Multi-Faceted Software Reusability Model: The Quintet Web.

Over the past decade, problems in software development and maintenance have increased rapidly. The size of software has grown explosively, complexity of software applications has increased, the nature of software applications has become more critical, and large quantities of software to be maintained have accumulated. During the same time, the productivity of individual software engineers has not improved proportionally. Software reusability is widely believed to be a key to help overcome the ongoing software crisis by improving software productivity and quality. However, the promise of software reusability has not yet been fulfilled. We present a multi-faceted software reusability model, a Quintet Web, that enables designers to reuse software artifacts from all phases. The Quintet Web consists of links of five types of reuse support information among existing document blocks: semantic, horizontal, hierarchical, syntactic, and alternative relationships. The five types of reuse support information are named the Semantic Web, the Horizontal Web, the Vertical Web, the Syntactic Web, and the Alternative Web. The Semantic Web defines the operational functionality of each software block. The Horizontal Web links functionally identical blocks of all phases. The Vertical Web identifies hierarchical relationships of software blocks. The Syntactic Web forms a chain from the declaration of each variable to its uses for all variables. The Alternative Web enables software developers to select an alternative algorithm for an identical functionality. The Quintet Web supports both software development and maintenance. When the Quintet Web is applied to development process, it provides software developers a means to check the consistency of the software being developed. The Quintet Web model is independent of a specific software development method

Multi-level Programming Paradigm and Its Support Environment for Software Reusability

Computer Scienc

Reusable Software Catalog Interface�

Computer Scienc