Software engineering aspects of real-time programming concepts

Real-time programming is a discipline of great importance not only in process control, but also in fields like communication, office automation, interactive databases, interactive graphics and operating systems development.General concepts of concurrent programming and constructs for process-synchronization are discussed in detail. Tasking and synchronization concepts, methods of process communication, interrupt and timeout handling in systems based on semaphores, signals, conditional critical regions or on real-time languages like Concurrent PASCAL, MODULA, CHILL and ADA are explained and compared with each other.The second part deals with structuring and modularization of technical processes to build reliable and maintainable real time systems. Software-quality and software engineering aspects are considered throughout the paper.     

Patterns Approach to Product Information Systems Engineering

This paper deals with the application of the pattern approach to product information systems (PIS) engineering. Two kind of patterns are distinguished: business patterns used for specification and providing solutions for application field problems, and software patterns used for implementation and providing solutions for technical problems (software). Particular attention is given to identifying and specifying different business patterns. The main focus is on the activity of design for reuse, i.e. discovery of business patterns and their integration in a pattern catalogue. The first step consisted of a field analysis providing a common terminology and a semantic of the principal concepts managed in PIS and proposing various models to fix these concepts. It forms a basis for exploring the problems frequently occurring during PIS specification. A pattern catalogue is then proposed to solve the identified problems.     

An empirical research agenda for understanding formal methods productivity

ContextFormal methods, and particularly formal verification, is becoming more feasible to use in the engineering of large highly dependable software-based systems, but so far has had little rigorous empirical study. Its artefacts and activities are different to those of conventional software engineering, and the nature and drivers of productivity for formal methods are not yet understood.ObjectiveTo develop a research agenda for the empirical study of productivity in software projects using formal methods and in particular formal verification. To this end we aim to identify research questions about productivity in formal methods, and survey existing literature on these questions to establish face validity of these questions. And further we aim to identify metrics and data sources relevant to these questions.MethodWe define a space of GQM goals as an investigative framework, focusing on productivity from the perspective of managers of projects using formal methods. We then derive questions for these goals using Easterbrook et al.’s (2008) taxonomy of research questions. To establish face validity, we document the literature to date that reflects on these questions and then explore possible metrics related to these questions. Extensive use is made of literature concerning the L4.verified project completed within NICTA, as it is one of the few projects to achieve code-level formal verification for a large-scale industrially deployed software system.ResultsWe identify more than thirty research questions on the topic in need of investigation. These questions arise not just out of the new type of project context, but also because of the different artefacts and activities in formal methods projects. Prior literature supports the need for research on the questions in our catalogue, but as yet provides little evidence about them. Metrics are identified that would be needed to investigate the questions. Thus although it is obvious that at the highest level concepts such as size, effort, rework and so on are common to all software projects, in the case of formal methods, measurement at the micro level for these concepts will exhibit significant differences.ConclusionsEmpirical software engineering for formal methods is a large open research field. For the empirical software engineering community our paper provides a view into the entities and research questions in this domain. For the formal methods community we identify some of the benefits that empirical studies could bring to the effective management of large formal methods projects, and list some basic metrics and data sources that could support empirical studies. Understanding productivity is important in its own right for efficient software engineering practice, but can also support future research on cost-effectiveness of formal methods, and on the emerging field of Proof Engineering.     

The robotics experience

The classical engineering fields have evolved standards and techniques for developing complex systems. For example, both mechanical and electrical engineers have a wide variety of standard components, with defined capabilities, that they can draw upon (e.g., gears, transistors) in the design of complex systems. On the other hand, software engineering has struggled with the basic idea of reusability. Software engineering approaches, such as the use of components [1] that promote the concept of information hiding [2] and the introduction of structured programming languages [3], offer a roadmap to an improved software reuse. Unfortunately, their adoption by robotics researchers has been slow, impeded by the tradition of individual research groups crafting independent and incompatible solutions to common problems.     

NASA's exploration agenda and capability engineering

NASA is using model-based languages and risk analysis methodologies to raise software development to the level of hardware development. Ultimately, it hopes to achieve a fusion of systems and software engineering by replacing conventional software development techniques with capability engineering, which focuses on a system's full set of functionalities.     

An Application of Structural Modeling to Software Requirements Analysis and Design

In software development, it has been pointed out that software engineers must pay attention to software requirements definition. One of the important problems in software engineering is to rationalize the processes from requirements definition to design. Computer tools are most useful and efficient for this purpose. This paper proposes a computer-aided software design system (CASDS), which supports software engineers with a series of structural modeling. As is well-known in systems planning, structural modeling helps to extract concepts from many fuzzy requirements. This system contains three structural modeling methods. They are used 1) to determine functional terms from fuzzy software requirements, 2) to obtain modules by structuring the functions with respect to the data flows, and 3) to make a program skeleton by imposing control flows on the functional elements obtained by breaking down the modules.     

Designing service-based applications in the presence of non-functional properties: A mapping study

ContextThe development of distributed software systems has become an important problem for the software engineering community. Service-based applications are a common solution for this kind of systems. Services provide a uniform mechanism for discovering, integrating and using these resources. In the development of service based applications not only the functionality of services and compositions should be considered, but also conditions in which the system operates. These conditions are called non-functional requirements (NFR). The conformance of applications to NFR is crucial to deliver software that meets the expectations of its users.ObjectiveThis paper presents the results of a systematic mapping carried out to analyze how NFR have been addressed in the development of service-based applications in the last years, according to different points of view.MethodOur analysis applies the systematic mapping approach. It focuses on the analysis of publications organized by categories called facets, which are combined to answer specific research questions. The facets compose a classification schema which is part of the contribution and results.ResultsThis paper presents our findings on how NFR have been supported in the development of service-based applications by proposing a classification scheme consisting in five facets: (i) programming paradigm (object/service oriented); (ii) contribution (methodology, system, middleware); (iii) software process phase; (iv) technique or mathematical model used for expressing NFR; and (v) the types of NFR addressed by the papers, based on the classification proposed by the ISO/IEC 9126 specification. The results of our systematic mapping are presented as bubble charts that provide a quantitative analysis to show the frequencies of publications for each facet. The paper also proposes a qualitative analysis based on these plots. This analysis discusses how NFR (quality properties) have been addressed in the design and development of service-based applications, including methodologies, languages and tools devised to support different phases of the software process.ConclusionThis systematic mapping showed that NFR are not fully considered in all software engineering phases for building service based applications. The study also let us conclude that work has been done for providing models and languages for expressing NFR and associated middleware for enforcing them at run time. An important finding is that NFR are not fully considered along all software engineering phases and this opens room for proposing methodologies that fully model NFR. The data collected by our work and used for this systematic mapping are available in https://github.com/placidoneto/systematic-mapping_service-based-app_nfr.     

Build-level components

Reuse between software systems is often not optimal. An important reason is that while at the functional level well-known modularization principles are applied for structuring functionality in modules, this is not the case at the build level for structuring files in directories. This leads to a situation where files are entangled in directory hierarchies and build processes, making it hard to extract functionality and to make functionality suitable for reuse. Consequently, software may not come available for reuse at all, or only in rather large chunks of functionality, which may lead to extra software dependencies. In this paper, we propose to improve this situation by applying component-based software engineering (CBSE) principles to the build level. We discuss how existing software systems break CBSE principles, we introduce the notion of build-level components, and we define rules for developing such components. To make our techniques feasible, we define a reengineering process for semiautomatically transforming existing software systems into build-level components. Our techniques are demonstrated in two case studies where we decouple the source tree of Graphviz into 46 build-level components and analyze the source tree of Mozilla.     

A Systematic Approach to Metamodeling Environments and Model Transformation Systems in VMTS

Highly configurable metamodeling environments and graph transformation techniques have been applied successfully in software system modeling and other areas. In this paper a uniform treatment of these two methods is illustrated by a tool called Visual Modeling and Transformation System. The concepts of an n-layer metamodeling environment is outlined with the related topological and attribute issues. Built on metamodeling techniques two alternatives for model transformation are elaborated, namely, the traversal and the graph-rewriting approaches. In our implementation all of the aforementioned mechanisms use metamodel as a common formalism, which can be considered as a uniform basis for storing, creating and transforming visual languages. The feasibility of the approach is illustrated by a transformation which generates C/C++ code from UML statecharts.     

Toward a unified view of data base management,programming languages,and operating systems—A tutorial

This paper identifies some common concepts in programming languages, data base management, and operating systems. We present an approach to unifying these concepts based upon the notion of levels of abstract machines. Central to this approach is the utilization of homogeneous programming environments. The objective of this effort is to present a uniform view of an information processing system.     

An object design framework for structural engineering

Object-oriented principles have introduced several useful concepts for developing complex software systems. As a result, several methodologies have been suggested for the overall design of software systems based on these concepts. Methodologies and frameworks for designing objects that are to be part of the software systems are currently lacking. This paper proposes anobject design framework andmethodology, which utilizes the object-oriented concepts, for planning, organizing and designing structural engineering design objects. Design objects in an integrated structural engineering system are complex and often related to each other in various different ways. The paper also identifies several important relationships among structural engineering design objects. These relationships serve as communication channels through wich design objects send messages to and receive responses from each other. Several examples, drawn from reinforced concrete structures, will be presented to demonstrate the object design methodology and to illustrate how the framework is effective in reducing the complexity of design objects in an integrated structural engineering system.     

Structural modelling of information systems

Information systems have become increasingly complex over recent years, underscoring the challenge of designing systems which will provide the different functions in an organization with the information necessary for effective decision-making. With rapidly developing computer technology, it is natural that information systems evolve in a manner which is greatly dependent on computing hardware and software. Yet, there has been little development in the techniques of systems analysis and design to handle new and less well understood functions which are of increasing interest.

This paper discusses the basic mathematical concepts of structural modelling as related to information system analysis. In particular, its concern is with the structuring of information system networks utilizing these concepts as potentially useful tools in (1) partitioning a system into a set of subsystems; (2) specifying subsystems sufficiently to permit separate testing before total system tests ; and (3) eliminating redundant control information flow.     

MOD2-SCM: A model-driven product line for software configuration management systems

ContextSoftware Configuration Management (SCM) is the discipline of controlling the evolution of large and complex software systems. Over the years many different SCM systems sharing similar concepts have been implemented from scratch. Since these concepts usually are hard-wired into the respective program code, reuse is hardly possible.ObjectiveOur objective is to create a model-driven product line for SCM systems. By explicitly describing the different concepts using models, reuse can be performed on the modeling level. Since models are executable, the need for manual programming is eliminated. Furthermore, by providing a library of loosely coupled modules, we intend to support flexible composition of SCM systems.MethodWe developed a method and a tool set for model-driven software product line engineering which we applied to the SCM domain. For domain analysis, we applied the FORM method, resulting in a layered feature model for SCM systems. Furthermore, we developed an executable object-oriented domain model which was annotated with features from the feature model. A specific SCM system is configured by selecting features from the feature model and elements of the domain model realizing these features.ResultsDue to the orthogonality of both feature model and domain model, a very large number of SCM systems may be configured. We tested our approach by creating instances of the product line which mimic wide-spread systems such as CVS, GIT, Mercurial, and Subversion.ConclusionThe experiences gained from this project demonstrate the feasibility of our approach to model-driven software product line engineering. Furthermore, our work advances the state of the art in the domain of SCM systems since it support the modular composition of SCM systems at the model rather than the code level.     

From types to type requirements: genericity for model-driven engineering

Model-driven engineering (MDE) is a software engineering paradigm that proposes an active use of models during the development process. This paradigm is inherently type-centric, in the sense that models and their manipulation are defined over the types of specific meta-models. This fact hinders the reuse of existing MDE artefacts with other meta-models in new contexts, even if all these meta-models share common characteristics. To increase the reuse opportunities of MDE artefacts, we propose a paradigm shift from type-centric to requirement-centric specifications by bringing genericity into models, meta-models and model management operations. For this purpose, we introduce so-called concepts gathering structural and behavioural requirements for models and meta-models. In this way, model management operations are defined over concepts, enabling the application of the operations to any meta-model satisfying the requirements imposed by the concept. Model templates rely on concepts to define suitable interfaces, hence enabling the definition of reusable model components. Finally, similar to mixin layers, templates can be defined at the meta-model level as well, to define languages in a modular way, as well as layers of functionality to be plugged-in into other meta-models. These ideas have been implemented in MetaDepth, a multi-level meta-modelling tool that integrates action languages from the Epsilon family for model management and code generation.     

双重软件体系结构描述框架XYZ/ADL

体系结构设计在软件开发过程中扮演着重要角色.工程中常用图形语言为软件体系结构建模,它们有直观、半形式化的优点;但是语义不够精确,难以对它们表示的模型进行分析,在这方面,形式化方法可与之互补.但在工程使用中仅用形式化语言建模又不太现实,所以如何结合二者之长以提高软件的可靠性已成为工业界和学术界共同关心的问题.提出了双重软件体系结构描述框架XYZ/ADL:支持工程中软件体系结构的基本概念,前端用一般的体系结构框图作为结构描述,用UML活动图、状态图作为抽象行为表示;后端用既可表示系统动态语义又可表示系统静态语义的时序逻辑语言XYZ/E作为一致的语义基础.前端的图形语言便于软件工程师的交流和使用,后端的形式语言是进一步的形式化分析验证的基础.     

On interfaces

The nature of interfaces is discussed. It is recommended that modern software approaches to interfaces (such as abstract data types) be extended to interfaces of all kinds. These interfaces can and should be developed at the level of abstraction appropriate to the interacting elements, rather than at the level of their lowest common denominator, which is frequently the case. It is proposed that for an interface to exist at any level of abstraction, there must be an operational framework that implements that level of abstraction and within which the interfacing elements interact. Four tasks required for the development of interfaces are described. The traditional classification of interfaces as hardware/software, software/software, and hardware/hardware is found wanting and a new partitioning is suggested—structural or interpretive interfaces, symbolic interfaces, and physical interfaces. Standards and scientific and engineering theories are shown to define levels of abstraction for general interfaces in much the same way that programming languages do for software interfaces. Implications for software engineering and concurrent engineering are explored.