Interactive control of prototyping process

This paper describes a case study to determine whether computer-aided prototyping techniques provide a cost-effective means for re-engineering legacy software. The case study consists of developing an object-oriented modular architecture for the existing US Army Janus combat simulation system, and validating the architecture via an executable prototype using the Computer Aided Prototyping System (CAPS), a research tool developed at the Naval Postgraduate School. The case study showed that prototyping can be a valuable aid in the re-engineering of legacy systems, particularly in cases where radical changes to system conceptualization and software structure are needed. The CAPS system enabled us to do this with a minimal amount of coding effort.

Prototyping languages form a new category in the computer language family. They are different from the commonly familiar computer languages because they are used to support a higher level of automation at early phases of software development as well as throughout the entire process. They are used to create mechanically processable and executable descriptions or models of proposed software systems. Prototyping languages are also used to firm up requirements via frequent modifications and demonstrations of the models in an iterative process of prototype evolution. The benefits of a prototyping language are fully realized when it is used with its computer-aided prototyping system (CAPS). In this paper, we describe the background, requirements, characteristics, computational features, and general principles for the design of prototyping languages. An example of a prototyping language design is used to illustrate these concepts.

CASE tool for reusable software component storage and retrieval in rapid prototyping

Design management systems have been developed and researched for traditional product and service industries. For interaction design little research has been performed on design management. The objective of this paper is to describe aspects of and provisions for industrial interaction design that influence approaches to design management within system and software development. We discuss whether there are specific conditions for design management of interaction design within the software and system development industries. The research is based on three short case studies from industrial software development. We identify some of these specific conditions; the difference between a usage and a product perspective, the design tools and practices, and the modularized and distributed processes. These issues point towards challenges facing design management within the software and system development context, as well as the need for interaction design to clarify its position as a strategic resource in software companies. The conclusions point towards the need for continued research on strategic possibilities and alternatives to organize and manage design work in software and system development.

Many regular business operations are transforming into digital services, increasing advanced multi-platforms, rapid operational alignment, flexibility, and environmental impact through energy consumption, hardware waste, and technology investments. Flexible and sustainable system development models emphasizing energy efficiency can help innovate software development as digital servicing applications shift. This research is motivated by the need to improve energy consumption in early software design and development due to rising technological efficiency and sustainability demands. Although effective in iterative development and stakeholder engagement, traditional Agile methodologies often struggle with long-term sustainability and energy efficiency. Extended Agile, combining Agile, layered architecture, and aspect-oriented frameworks (ALAI), promises to improve system modularity, flexibility, maintainability, and sustainability. This study’s findings are not just theoretical, but also practically relevant, as they explore the energy efficiency of ALAI software development methodologies, using graduate admission information system services (GAISS) as an example. GAISS is a complex system that handles the entire process of graduate admissions, from application submission to final decision. The study quantifies the energy usage of a student-list webpage by analyzing Microsoft IIS server logs from February 2022 to May 2024. Directly applicable findings show that the GAISS based on the ALAI framework reduces energy consumption by 10.7914% compared to traditional Agile software developments. ALAI used 892.80 kWh versus Agile’s 1000.80 kWh during operations, saving energy. These findings demonstrate the benefits of integrating aspect-oriented frameworks and layering approaches into Agile methodologies, contributing to sustainable software development discourse. The study emphasizes the importance of energy-efficient frameworks such as ALAI to reduce software systems’ environmental impact and promote software development sustainability. The findings of this study, with their practical relevance, assist software developers and organizations in choosing software design and development methods that maximize operational efficiency and environmental sustainability.

This paper presents a new approach, model theory approach, to small and medium scale transaction processing system (TPS) development. A TPS of this paper is an information system designed to process day-to-day business event data at operational level of an organization. The paper is not concerned with data base construction but with transaction processing. The model theory approach is not a software engineering approach but a systems theory approach. In the approach a model of the target system, which is called a user model, is constructed in set theory using a formal system structure of a TPS. The user model is, then, compiled into an extended Prolog (extProlog) model. The extProlog is an extension of Prolog to meet requirements for management information system development. On compilation a standardized user interface (UI) called internal UI is attached. The extProlog model with the internal UI is, then, executed under control of another standardized UI called an external UI. Implementation is an integral part of the approach. Because the UIs are designed for the formalized (abstract) structure of a TPS, they can be standardized and are provided as black box components to system development. Because a systems developer is required to only build a user model in set theory based on a model theoretic structure in the approach, it is called a model theory approach. Advantages of this approach are that it provides a theoretical structure to information systems development so that systems development can be made an engineering discipline, and facilitates rapid systems development.

The most current trends in the evolution of software development process are closely related with the increasing complexity of software systems. This motivates software engineers and system developers to find an alternative solution for software system design and development. In this case, the manner offered by OMG’s initiative, the Model Driven Architecture namely, represents a model-driven approach to software development. It also considers the further evolution of CASE tools, bringing their functionality to the next level. This paper investigates the variety of the CASE tools developed under an impact of MDA growing progress. The differences between Model Driven Architecture and Model Driven Development in the context of automatic capabilities for software development are also discussed in the paper. The example of possibility to define a set of tools proposed as a tool chain for development of software systems under the framework of MDA, the projection of two-hemisphere approach for object-oriented software development into authors’ developed component model of MDA is offered in the paper.

To improve the efficiency of the design engineer, the use of design automation systems is required. Currently, computeraided design tools are multifunctional and have an expanded user interface. Depending on the scope of the task to be solved and the level of training, the design engineer does not need all the means of computer-aided design systems. In this case, an adaptive interface can serve as a means of increasing labor productivity, which can be customized for a particular user, taking into account his experience and physiological features (system experience, computer literacy, experience working with such programs, typing, color blindness, memory, hand motility). The characteristics by which a user system is evaluated have different degrees of uncertainty, ambiguity, and internal inconsistency. These characteristics are difficult to formalize and they are very specific. To perform the evaluation, it is advisable to use intelligent systems based on fuzzy logic and fuzzy sets. The most acceptable in this case is the Mamdani method which uses a minimax composition of fuzzy sets. The proposed mechanism includes a sequence of actions: fuzzification, fuzzy inference, composition, defazzification. A software development system has been developed that allows you to form an interface part of the software taking into account the capabilities of a particular user. The implementation of the developed software system allows you to select a set of elements individually for each design engineer and form an adaptive prototype of the application program interface. In this case, it becomes possible to improve the interaction between a person and a computer, make it more comfortable, reduce the time to search for the necessary functions and the number of erroneous actions, and improve the quality of the work done.

Welcome to the International Conference on Software and Systems Process (ICSSP) held in Zurich, Switzerland, on June 2nd and 3rd, 2012. Having grown from a Software Process Workshop in 2005 to the International Conference on Software Process (ICSP) in 2007, and finally to the International Conference on Software and Systems Process (ICSSP) in 2011, this conference series has established its place in the software engineering community as a respected conference focusing on research and practice related to software and systems development process. Software and software systems development use processes as one major means for achieving and ensuring the quality of the final product. This leads to specific challenges regarding software processes such as simplicity, adaptability, standard conformance, the coordination of multiple domains and lifecycles, etc. Processes from other domains (e.g., health care, manufacturing, business, aerospace, automotive systems, and others) face similar challenges. Yet, they share interesting similarities with and differences to software processes. The question is: How can we in the software domain learn from other domains to meet our software process engineering challenges? The ICSSP conferences hence connect the traditional software and systems process community with outside views and insights, broadening its scope of software development processes to system development and explicitly including processes of other domains such as health care, business, and manufacturing. By sharing process development theories and practices from such domains, ICSSP 2012 is investigating novel solutions to today's process challenges. Correspondingly, the main theme of ICSSP 2012 is Beyond Software and Software Systems Processes, signaling our goal of learning from domains other than the traditional software process community.

With the introduction of the Industrial/sup IT/ vision at ABB, the coordination of hardware and software development is a crucial aspect that the organization needs to address. Software development and hardware production processes need to be coordinated into one coherent lifecycle model to optimize development. This paper presents some basic concepts in software and hardware development lifecycles and paves the road for a more comprehensive approach for a system development lifecycle.

In software development, the user interface(UI) design process involves the part from an imagination that begins on a piece of paper where designers share thoughts to the final prototype that is ready to implement. UI designers use a technique of paper prototyping in low-fidelity sketches to implement the conceptual design. Once a design is drawn, it is usually captured within a photograph, then converted to a high-level mockup, and manually translated into a working client-side code by developers. The process consumes considerable effort and also delays the design process. Recently, researchers attempted to recreate UI from their sketches using code generation techniques. In this paper, we present a system for automatic code generation that combines recent advances in computer vision and deep learning for translating a sketched wireframe into a UI skeleton code. The proposed system has two main components: component recognition and code generation. The component recognition learns to extract visual features and their spatial layouts from sketched UI images. The code generator creates the equivalent UI skeleton codes based on the information from the detection model. A layout algorithm has been developed to resolve the overlapping of components and structure the layout. The evaluation result of the component recognition model indicates that the Faster R-CNN with Inception ResNet v2 backbone model achieved a mean average precision (mAP) of 95.5 %, among the other trained models. To evaluate the generator, we conducted a user study based on visual similarities between input image and the rendered UI.

: This report contains the results of studying issues relating to the requirements development process. The goals, objectives, results and conclusions for three separate but related components, 1) a Requirements Engineering Panel study, 2) the development of a Very High Level Language Prototyping Tool, and 3) a Database Management Study are described. First, a panel of experts was formed whose goals were to understand the requirements engineering problem and define a long-range (10 year) Research and Development plan for the RADC Requirements Engineering Testbed (RET). The plan was to identify tools and methods that should be developed, evaluated and integrated. Second, the objective of the rapid prototyping system, Proto, was to develop a functional specification, prior to extensive design and coding effort in a large (C3I) software system. The approach includes defining a functional specification language for defining prototypes, developing and organizing a facility around the concept of reusability with the reusable components (both functions and data types) managed by an object manager, and develop a set of support tools to facilitate the construction and execution of prototypes. Finally, a study was performed to identify the data base management requirements for supporting an automated requirements engineering process.

A well-designed user interface is recognized as a benchmark for determining the success of a software product. The proliferation of user interface design guidelines, standards, prototyping tools, and techniques are indicative of the importance placed on quality user interfaces. However, even with the availability of the latest information, tools, and human factors practitioners to software developers, sub-optimal interfaces may result. This is because within a large multidisciplinary software design team, issues such as communication, responsibilities, and cost and schedule constraints may override the usability issues. This paper describes the implementation of concurrent engineering, used to successfully develop user interfaces for a large, complex system. Success is expressed in terms of quality and consistent user interfaces, positive influence of human factors on software development, and customer satisfaction.

The development of user interfaces (UIs) is one of the most time-consuming aspects in software development. In this context, the lack of proper reuse mechanisms for UIs is increasingly becoming manifest, especially as software development is more and more moving toward composite applications. In this paper we propose a framework for the integration of stand-alone modules or applications, where integration occurs at the presentation layer. Hence, the final goal is to reduce the effort required for UI development by maximizing reus. The design of the framework is inspired by lessons learned from application integration, appropriately modified to account for the specificity of the UI integration problem. We provide an abstract component model to specify characteristics and behaviors of presentation components and propose an event-based composition model to specify the composition logic. Components and composition are described by means of a simple XML-based language, which is interpreted by a runtime middleware for the execution of the resulting composite application. A proof-of-concept prototype allows us to show that the proposed component model can also easily be applied to existing presentation components, built with different languages and/or component technologies.

Software testing is an important process in software quality assurance(SQA). Software testing consumes the majority of the software developers' time and cost of all the phases of system development. An important problem in software testing is to determine whether a program has been tested enough with a testing criterion and when one could stop testing. On the other hand, software measurement is used to estimate the quality of a software. Complexity measures can be used to compare software quality and development cost. This paper proposes a new testing approach which choosing testing path based on path complexity. The process is to use a set of testing paths that satisfying all-uses testing criterion, and then choose the testing path with the most complexity to test. This process is continued until the program can be accepted. The proposed formula is used to determine if it is possible to stop testing before satisfying all-du-paths testing criterion. The main contribution of the paper is that software developers can choose a proper testing action with lower testing effort.