Software Engineering Principles Research Articles

The TAME project: towards improvement-oriented software environments

Experience from a dozen years of analyzing software engineering processes and products is summarized as a set of software engineering and measurement principles that argue for software engineering process models that integrate sound planning and analysis into the construction process. In the TAME (Tailoring A Measurement Environment) project at the University of Maryland, such an improvement-oriented software engineering process model was developed that uses the goal/question/metric paradigm to integrate the constructive and analytic aspects of software development. The model provides a mechanism for formalizing the characterization and planning tasks, controlling and improving projects based on quantitative analysis, learning in a deeper and more systematic way about the software process and product, and feeding the appropriate experience back into the current and future projects. The TAME system is an instantiation of the TAME software engineering process model as an ISEE (integrated software engineering environment). The first in a series of TAME system prototypes has been developed. An assessment of experience with this first limited prototype is presented including a reassessment of its initial architecture. >

MMAIM: a software development method for Ada

Traditional methods for software development fail to make use of Ada's unique features to support software engineering principles. Several methods have been proposed to overcome this problem, but shortcomings have been identified with all of them. A method for Ada software development is presented which avoids the shortcomings of existing methods. Further work required on the method is also discussed.

Development and documentation of computer programs in undergraduate computer science programs

Until recently, introductory programming classes in the Department of Computer Science, University of Minnesota, Duluth, concentrated on writing code. Not until the junior or senior year were students required to adhere to basic principles of software engineering. As might be expected, by their junior year students' bad habits, like coding while designing or inserting comments last, were firmly entrenched and difficult, if not impossible, to undo. The solution, it seemed to us, was to prevent bad habits right from the start. Consequently, we developed guidelines for designing and documenting the entire programming effort, from problem statement to post mortem. The guidelines include such steps as: algorithm development in high-level pseudocode with stepwise refinements, structure diagrams with data flow, detailed test descriptions, testing results, and a description of all known bugs. For a given assignment, the instructor chooses the steps to be completed, allowing for flexibility and appropriateness in the design and documentation. Results have been extremely positive. Students start earlier and produce better organized solutions. More students solve the problems correctly. Most importantly, students develop design and documentation skills in the freshman year that carry through and are improved over their four-year stay. Because of this initial success, our department has adopted these guidelines uniformly in all programming classes. In this paper we will describe our guidelines and give some details of their use. We will discuss the philosophy that led us to develop these guidelines and present our observations of their effectiveness.

Requirement methods: a graduate level course that integrates software engineering principles with information systems theory

Requirement methods: a graduate level course that integrates software engineering principles with information systems theory

Application of advanced computational technology to propulsion CFD

The Internal Fluid Mechanics Division of the NASA Lewis Research Center is combining the key elements of computational fluid dynamics, aerothennodynamic experiments, and advanced computational technology to bring internal computational fluid mechanics (ICFM) to a state of practical application for aerospace propulsion system design. This paper presents an overview of efforts underway at NASA Lewis to advance and apply computational technology to ICFM. These efforts include the use of modern, software engineering principles for code development, the development of an AI-based user-interface for large codes, the establishment of a high-performance, data communications network to link ICFM researchers and facilities, and the application of parallel processing to speed up computationally intensive and/or tune-critical ICFM problems. A multi-stage compressor flow physics program is cited as an example of efforts to use advanced computational technology to enhance a current NASA Lewis ICFM research program.

Combining Software Engineering and Instructional Design Principles in a New Type of Course for Educators

AbstractAn increasing number of education specialists are becoming involved in educational software development projects. A university-level course which provides appropriate training for this type of involvement is described. The course includes both instructional design concepts and software engineering principles combined in a project team orientation. The value of this type of course for secondary school computer science teachers as well as for educators involved in software development is discussed.

Implications of R&M 2000 on Software

This paper presents the implications on software of the US Air Force Reliability and Maintainability Action Plan: R&M 2000, whose objective is to improve defense system reliability and maintainability. These implications are very important, even though R&M 2000 does not explicitly mention software. However, Air Force Regulation 800-18, which implements R&M 2000, does state that ``system ... comprises both hardware and software elements'' and includes the requirement to ``integrate the development of reliable software into the overall system development and acquisition program.'' Further, the US Department of Defense (DoD) Software Initiatives, new DoD Directives, and other Air Force Regulations on software, together with industry/academic initiatives, are intended to result in policies, standards, and specifications which lead to defense system software with requisite reliability and maintainability. This difficult goal can be achieved provided that: •The DoD Software Initiatives successfully create new software technology and transfer it to industry. •Industry associations (eg, Electronic Industries Association [EIA], National Industrial Security Association INSIA]) and professional societies (eg, Institute of Electrical and Electronics Engineers [IEEE], American Institute of Aeronautics and Astronautics [AIAA]) create and improve software reliability and maintainability standards through effective committee work. •Industry/Academe upgrade software development procedures to be consistent with software engineering principles based on Ada® technology.

A Conceptual Analysis of the Draco Approach to Constructing Software Systems

This paper analyzes the concepts of software construction embodied in the Draco approach. The analysis relates specific aspects of Draco to particular software engineering (SE) principles and suggests future research needed to extend the approach. The purpose of this analysis is to help researchers understand Draco better and thus to enhance future research.

Structured analysis of knowledge

Traditional approaches to Expert Systems development have emphasized the use of exploratory programming techniques and moving as quickly as possible from conceptualisation to code. Our research demonstrates that implementation independent domain modelling is feasible and useful within the context of a methodology which aims at supporting good software engineering principles as applied to Expert Systems.

Recommendations for software engineering education

The increasing emphasis on software engineering in the computer science curricula directly correlates with the expansion of the area of software engineering. The increased occurrence of software engineering courses has produced significant discrepancies in the content of the courses at the undergraduate level. These discrepancies have percipitated the need for recommendations for the inclusion of software engineering in the curriculum. The recommendations presented in this paper include both the integration of software engineering principles throughout the undergraduate curriculum and the content of a separate software engineering course. The recommendations for course content are based on a survey of the contents of recently published software engineering textbooks.

Assessing programming languages for engineering applications: Should engineers implement the algorithms of the '80s in programming languages of the '50s?

The purpose of this article is twofold: first, to present the principles of software engineering as applied to the task of establishing criteria for selecting programming languages for engineering applications; and second, to provide a survey of current languages which, by comparison with the established criteria, will help determine which languages are most suitable for engineering applications.

Using Modem Design Practices to Upgrade Aging Software Systems

Modifying 100,000 lines of 20-year-old code, IBM-FSD successfully applied its software engineering principles to modernization of the FAA'S air traffic control system.

The STARTS programme

STARTS is a national programme aimed at improving the competitiveness of the UK real-time software systems supply industry by encouraging the widespread adoption of software engineering methods and tools. This is being pursued on two fronts: by harnessing purchasing power to accelerate the uptake of methods and tools by system suppliers, and by providing guidance and information about software engineering principles and methods and tools.

Technology transfer between VLSI design and software engineering: CAD tools and design methodologies

Recent research on the explicit transfer of technology used in computer-aided design (CAD) tools and design methodologies is reported. First, several examples are given of applications of these technologies to software engineering. Then, three research projects are described which focused on applying software engineering principles to the VLSI design process. They are: a methodology, language, and assessment tool for multilevel mixed-mode VLSI designs; a research project that explored the potential for transfer of software design methodologies for managing VLSI design complexity; and a specification technique for modules in a VLSI design that localizes the impact of changes to the design. Next, a CAD tool and design methodology are described which consider the design of software and hardware together, and apply common techniques to both. Finally, some observations are made on the appropriateness of technology transfer between VLSI design and software engineering.

Requirements for software engineering languages: Arndt von Staa and Peter Freeman: Information and Computer Science, University of California, 1985

Author(s): Staa, Arndt von; Freeman, Peter | Abstract: This paper analyzes the concepts of software construction embodied in the Draco system. The analysis relates specific mechanisms in Draco to particular software engineering (SE) principles and suggests future research needed to extend the approach. The purpose of the analysis is to help researchers understand Draco better and thus be able to direct in productive directions future research on this type of software engineering tool.

System 75:The Oryx/Pecos Operating System

The System 75 Office Communication System is the first field application of the Oryx/Pecos operating system, a message-based system which supports real-time, distributed applications. Its interprocess communications mechanisms provide a structuring tool similar to monitors, capabilities, and abstract data types. This paper describes the principal concepts implemented in the operating system kernel, and presents the essential system processes. Support for application design techniques is discussed and related to proven software engineering principles, including information hiding and modularity. Specific examples are drawn from System 75 for call processing and maintenance.

A methodology for protocol design and specification based on an extended state transition model

A lot of effort is being dedicated world-wide to defining Open Systems Interconnection (OSI) protocol standards and tools for formally describing them. However, little work is done in developing methods for applying these tools to the development of new protocols. This paper presents such a methodology based on OSI and software engineering principles. It provides general guidelines for designing protocols based on an extended state transition formal description technique (FDT). It emphasizes a systematic, analytical and algorithmic approach to achieve completeness of protocol specification during the protocol design process. Its possible application to the development of OSI protocol standards is discussed and suggested for study by the standards community.

Abstract types, ADA packages, and the teaching of data structures

This paper describes a course in Data Structures offered to upper-division undergraduates and beginning graduate students. In addition to the usual data-structures topics, Computer Science 159 places a strong emphasis on software engineering principles, especially the implementation of abstract data types using Ada packages. Two programming project series are presented; documentation requirements are described in some detail. Attention is paid to the problem of translating high-level design concepts, as embodied in Ada, into the more limited data structures and modularization features of earlier languages.

Seven basic principles of software engineering

This paper attempts to distill the large number of individual aphorisms on good software engineering into a small set of basic principles. Seven principles have been determined which form a reasonably independent and complete set. These are: 1. (1) manage using a phased life-cycle plan. 2. (2) perform continuous validation. 3. (3) maintain disciplined product control. 4. (4) use modern programming practices. 5. (5) maintain clear accountability for results. 6. (6) use better and fewer people. 7. (7) maintain a commitment to improve the process. The overall rationale behind this set of principles is discussed, followed by a more detailed discussion of each of the principles.

X3J4 should define compiler directing features

: The objective of this paper is to clarify the major concepts related to architecture and design of patient identity management software systems so that an implementor looking to solve a specific integration problem in the context of a Master Patient Index (MPI) and a deduplication engine can address the relevant issues.: The ideas presented are illustrated in the context of a reference use case from Integrating the Health Enterprise Patient Identifier Cross-referencing (IHE PIX) profile. Sound software engineering principles using the latest design paradigm of model driven architecture (MDA) are applied to define different views of the architecture.: The main contribution of the paper is a clear software architecture roadmap for implementors of patient identity management systems. Conceptual design in terms of static and dynamic views of the interfaces is provided as an example of platform independent model. This makes the roadmap applicable to any specific solutions of MPI, deduplication library or software platform.: Stakeholders in need of integration of MPIs and deduplication engines can evaluate vendor specific solutions and software platform technologies in terms of fundamental concepts and can make informed decisions that preserve investment. This also allows freedom from vendor lock-in and the ability to kick-start integration efforts based on a solid architecture.