Search

Purpose Many REpresentational State Transfer (RESTful) Web services suffered from anti-patterns problem, which may diminish the sustainability of the services. The anti-patterns problem could happen in the code of the programme or the uniform resource identifiers (URIs) of RESTful Web services. This study aims to address the problem by proposing a technique and an algorithm for detecting anti-patterns in RESTful Web services. Specifically, the technique is designed based on URIs parsing process. Design/methodology/approach The study was conducted following the design science research process, which has six activities, namely, identifying problems, identifying solutions, design the solutions, demonstrate the solution, evaluation and communicate the solution. The proposed technique was embedded in an algorithm and evaluated in four phases covering the process of extracting the URIs, implementing the anti-pattern detection algorithm, detecting the anti-patterns and validating the results. Findings The results of the study suggested an acceptable level of accuracy for the anti-patterns detection with 82.30% of precision, 87.86% of recall and 84.93% of F-measure. Practical implications The technique and the algorithm can be used by developers of RESTful Web services to detect possible anti-pattern occurrences in the service-based systems. Originality/value The technique is personalised to detect amorphous URI and ambiguous name anti-patterns in which it scans the Web service URIs using specified rules and compares them with pre-determined syntax and corpus.

A ¿decision view¿ provides a useful addition and complement to more traditional sets of architectural views and viewpoints; it gives an explanatory perspective that illuminates the reasoning process itself and not solely its results. This decision view documents aspects of the architecture that are hard to reverse-engineer from the software itself and that are often left tacit. The decision view and the decisions that it captures embody high-level architectural knowledge that can be transferred to other practitioners, merged when systems are merged, and offer useful support for the maintenance of large and long-lived software-intensive systems. This article leads the reader through a succession of epiphanies: from design to architecture, then architecture representation to architecture design methods, and finally to architectural design decisions Ciencias de la Computación

Prognostics is a systems engineering discipline focused on predicting end-of-life of components and systems. As a relatively new and emerging technology, there are few fielded implementations of prognostics, due in part to practitioners perceiving a large hurdle in developing the models, algorithms, architecture, and integration pieces. Similarly, no open software frameworks for applying prognostics currently exist. This paper introduces the Generic Software Architecture for Prognostics (GSAP), an open-source, cross-platform, object-oriented software framework and support library for creating prognostics applications. GSAP was designed to make prognostics more accessible and enable faster adoption and implementation by industry, by reducing the effort and investment required to develop, test, and deploy prognostics. This paper describes the requirements, design, and testing of GSAP. Additionally, a detailed case study involving battery prognostics demonstrates its use.

Theory of scheduling and project planning is widely applied in diverse scientific and industrial areas. To effectively solve application-specific problems, it is necessary to state right objectives as well as to take into account a lot of factors, such as task execution models, precedence relationship between tasks, resource limitations, directive deadlines, working calendars, conditions for financial and logistics support of project tasks, specific spatio-temporal requirements, et al. Therefore, the development of scheduling applications becomes more and more complicated purposes, risky and costly ones. In this paper, we present an innovative object-oriented Scheduling Application Framework (SAF) designed to simplify and accelerate the software development processes. The presented SAF framework is a system of C++ classes that implement basic abstractions of the scheduling theory as well as provide ready-to-use components to build target applications of typical scheduling functionality. As a general-purpose mathematical library, the framework enables to set and solve so-called RCPSP problems (Resource-Constrained Project Scheduling Problem) in extended statements peculiar to popular project management systems. Branch and bound and linear dispatching algorithms have been implemented and included as a part of the framework. A dozen of heuristics has been implemented and has been provided by the framework too to solve large-scale problems more effectively. Thereby target application developers can adjust the application solver properly taking into account application-specific issues and making the search of suboptimum schedules more effective. As a software toolkit the framework enables developers to implement own components and to configure target applications in unified and flexible manner. Due to object-oriented paradigm, multi-layer architecture and class package organization, the application development takes relatively small efforts. The SAF framework has been successively validated during development of a software application intended for visual modeling and planning of projects under diverse spatial-temporal, resource and finance constraints. Due to achieved advantages, the framework looks promising for development of both sophisticated multi-disciplinary systems and effective domain-specific scheduling applications.

Context Software-intensive space systems can harbor defects and vulnerabilities that may enable external adversaries or malicious insiders to disrupt or disable system functions, risking mission compromise or loss. Mitigating this risk demands a sustained focus on the security and resiliency of the system architecture including software, hardware, and other components. Objective In this paper we offer methodical approaches for improving space system resiliency through software architecture design, system engineering, and increased software security, thereby reducing the risk of latent software defects and vulnerabilities. Method We conducted a systematic review of existing architectural practices, standards, security and coding practices, various threats, defects, and vulnerabilities that impact space systems from hundreds of relevant publications and interviews of subject matter experts. We expanded on the system-level body of knowledge for resiliency and identified a new software architecture framework and acquisition methodology to improve the resiliency of space systems from a software perspective with an emphasis on the early phases of the systems engineering life cycle. This methodology involves seven steps: 1) Define technical resiliency requirements, 1a) Identify standards/policy for software resiliency, 2) Develop a request for proposal (RFP)/statement of work (SOW) for resilient space systems software, 3) Define software resiliency goals for space systems, 4) Establish software resiliency quality attributes, 5) Perform architectural tradeoffs and identify risks, 6) Conduct architecture assessments as part of the procurement process, and 7) Ascertain space system software architecture resiliency metrics. Results Data illustrates that software vulnerabilities can lead to opportunities for malicious cyber activities, which could degrade the space mission capability for its user community. Reducing the number of vulnerabilities by improving architecture and software system engineering practices can contribute to making space systems more resilient. Conclusion Since cyber-attacks [1] are enabled by shortfalls in software, robust software engineering practices and an architectural design are foundational to resiliency, which is a quality that allows the system to take a hit to a critical component and recover in a known, bounded, and generally acceptable period of time. To achieve software resiliency for space systems, acquirers and suppliers must identify relevant factors and systems engineering practices to apply across the life cycle, in software requirements analysis, architecture development, design, implementation, verification and validation, and maintenance phases.

Many techniques have been proposed to automatically recover software architectures from software implementations. A thorough comparison among the recovery techniques is needed to understand their effectiveness and applicability. This study improves on previous studies in two ways. First, we study the impact of leveraging accurate symbol dependencies on the accuracy of architecture recovery techniques. In addition, we evaluate other factors of the input dependencies such as the level of granularity and the dynamic-bindings graph construction. Second, we recovered the architecture of a large system, Chromium, that was not available previously. Obtaining the ground-truth architecture of Chromium involved two years of collaboration with its developers. As part of this work, we developed a new submodule-based technique to recover preliminary versions of ground-truth architectures. The results of our evaluation of nine architecture recovery techniques and their variants suggest that (1) using accurate symbol dependencies has a major influence on recovery quality, and (2) more accurate recovery techniques are needed. Our results show that some of the studied architecture recovery techniques scale to very large systems, whereas others do not.

In software engineering, a scenario describes an anticipated usage of a software system. As scenarios are useful to understand the requirements and functionalities of a software system, the scenario-based analysis is widely used in various tasks, especially in the design stage of software architectures. Although researchers have proposed various scenario-based approaches to analyse software architecture, there are still limitations in this research field, and a key limitation is that scenarios are typically not formally defined and thus may contain ambiguities. As these ambiguities may lead to defects, it is desirable to reduce them as many as possible. In order to reduce ambiguity in scenario-based software architecture analysis, this paper introduces a creative computing approach to scenario-based software requirements analysis. Our work expands this idea in three directions. Firstly, we extend an architecture description language (ADL)-based language–Breeze/ADL to model the software architecture. Secondly, we use a creative rule–combinational rule (CR) to combine the vector clock algorithm for reducing the ambiguities in modelling scenarios. Then, another creative rule – transformational rule (TR) is employed to help to transform our Breeze/ADL model to a popular model – unified modelling language (UML) model. We implement our approach as a plugin of Breeze, and illustrate a running example of modelling a poetry to music system in our case study. Our results show the proposed creative approach is able to reduce ambiguities of the software architecture in practice.

Although the cloud computing domain is progressing rapidly, the deployment of various network intensive software utilities in the cloud is still a challenging task. The Quality of Service (QoS) for various gaming, simulations, videoconferencing, video streaming or even file uploading tasks may be significantly affected by the quality and geolocation of the selected underlying computing resources, which are available only when the specific functionality is required. This study presents a new architecture for geographic orchestration of network intensive software components which is designed for high QoS. Key elements of this architecture are a Global Cluster Manager operating within Software-Defined Data Centres (SDDCs), a runtime QoS Monitoring System, and a QoS Modeller and Decision Maker for automated orchestration of software utilities. The implemented system automatically selects the best geographically available computing resource within the SDDC according to the developed QoS model of the software component. This architecture is event-driven as the services are deployed and destroyed in real-time for every usage event. The utility of the implemented orchestration technology is verified qualitatively and in relation to the potential gains of selected QoS metrics by using two network intensive software utilities implemented as containers: an HTTP(S) File Upload service and a Jitsi Meet videoconferencing service. The study shows potential for QoS improvements in comparison to existing orchestration systems.

The integration of software services-oriented architecture (SOA) and hardware multiprocessor system-on-chip (MPSoC) has been pursued for several years. However, designing and implementing a service-oriented system for diverse applications on a single chip has posed significant challenges due to the heterogeneous architectures, programming interfaces, and software tool chains. To solve the problem, this paper proposes SoSoC, a service-oriented system-on-chip framework that integrates both embedded processors and software defined hardware accelerators s as computing services on a single chip. Modeling and realizing the SOA design principles, SoSoC provides well-defined programming interfaces for programmers to utilize diverse computing resources efficiently. Furthermore, SoSoC can provide task level parallelization and significant speedup to MPSoC chip design paradigms by providing out-of-order execution scheme with hardware accelerators. To evaluate the performance of SoSoC, we implemented a hardware prototype on Xilinx Virtex5 FPGA board with EEMBC benchmarks. Experimental results demonstrate that the service componentization over original version is less than 3 percent, while the speedup for typical software Benchmarks is up to 372x. To show the portability of SoSoC, we implement the convolutional neural network as a case study on both Xilinx Zynq and Altera DE5 FPGA boards. Results show the SoSoC outperforms state-of-the-art literature with great flexibility.

International audience; Software Product Line Engineering (SPLE) aims at applying a pre-planned systematic reuse of large-grained software artifacts to increase the software productivity and reduce the development cost. The idea of SPLE is to analyze the business domain of a family of products to identify the common and the variable parts between the products. However, it is common for companies to develop, in an ad-hoc manner (e.g. clone and own), a set of products that share common services and differ in terms of others. Thus, many contributions are proposed to re-engineer existing product variants to a software product line. Nevertheless, these contributions are mostly focused on managing the variability at the requirement level. Few contributions address the variability at the architectural level despite its major importance. Starting from this observation, we propose an approach to reverse engineer the architecture of a set of product variants. Our goal is to identify variability and dependencies among architectural-element variants. Our work relies on formal concept analysis to analyze the variability. To validate the proposed approach, we experimented on two families of open-source product variants; Mobile Media and Health Watcher. %The results show that our approach is able to identify the architectural variability and the dependencies.

Together with the recognition of successful knowledge transfer as an important growth strategy for small and medium-sized software firms, questions related to the knowledge-based resources have emerged, including what and where knowledge is and how capabilities may influence knowledge transfer in e-commerce software projects. This study provides a deeper understanding of the relevance of knowledge transfer in such projects. The research findings identify the challenges of transferring this tacit knowledge across such projects and even within the user organizations as well. In addition to the technology knowledge and the absorptive capabilities perspectives, this study considers the market knowledge and the associated marketing capabilities as the alternative input to such projects. Most importantly, it offers a clear guide to project managers in their team building and recruiting. By using rigorous theoretical deductions and empirical support from the case studies, the study provides significant research contributions to the academicians and the implications for the practitioners of software projects.

The interconnection among heterogeneous sensors and data acquisition equipment in cyber-physical systems have profound significance in achieving adaptability, flexibility, and transparency. Various middlewares have been developed in cyber-physical systems to collect, aggregate, correlate, and translate system monitoring data. Existing middleware solutions are normally highly customized, which face several challenges due to the highly dynamic and harsh production environments. The data generated by sensors can only be shared by specific applications, which prevents the reusability of sensors. Moreover, the lack of uniform access to sensors causes high cost and low efficiency in application development. To address these issues, a resource-oriented middleware architecture called ROMiddleware was proposed, and three key enabling technologies including heterogeneous sensor modeling and grouping, open application programming interfaces development, and token-based access right control mechanism have been developed. Under the guidance of the key enabling technologies, a prototype of ROMiddleware was implemented and its performance was evaluated. Finally, two applications were developed to stress the significance of ROMiddleware. The results show that ROMiddleware can meet the requirements of data acquisition in cyber-physical systems.

In recent years, research into software architecture (SA) has become an important topic within the domain of software engineering. Since architecture plays a dominant role, analysis of SA is more important. Aim of analysing SA is to predict the quality of that system before it has been built. Among many SA analysis methods available, architecture trade-off analysis method is the most desirable one. Pattern’s which has impact on quality attributes is also used in this paper. This paper analyses hospital management system case study as a major work and uses new patterns named creative innovative patterns for architecture analysis to analyse its architecture.

As a result of the research, two directions for development of software architecture for low-power general purpose microcontrollers (LPGPM) are identified. The first, classical approach is the development using standard State patterns. The second is the development of programs, algorithms and structures based on mathematical analysis. The first direction is chosen in the work. The variant of the implementation of a typical pattern for development of software architecture (SA) in the form of a finite state machine (FSM) is proposed to discussion. This pattern allows to divide the development of the architectural part of the program for LPGPM and programming the LPGPM hardware. This approach makes it possible to divide the work of the software architect and the work of LPGPM hardware specialists. Advantage of the solution in comparison with the real time operating system (RTOS) is the saving of LPGPM hardware resources. In addition, it improves the readability of code and good testing prospects. The resulting architecture makes it possible to easily accompany the software and switch to other types of microcontroller. The disadvantage is an increase in the required amount of RAM with an increase in the number of states. It is this disadvantage that requires the application not only of experimental and engineering-intuitive methods, but also to continue research in the second direction.

The transfer of IT and consumer-electronics technologies to the automotive domain will provide major opportunities. However, both these technologies and the automotive industry will require much adaptation.

Optimizing the energy consumption of today's Internet-scale systems will require a radical approach that considers the whole system. To address system-level energy efficiency, software architects can follow three simple design principles. A case study illustrates the possible savings.

Software evolution has been a necessary part of the software development, while software architecture evolution is an important issue of software evolution. Software architecture evolution is generally realized through some evolution operations such as adding components or connectors, removing components or connectors. However, when some evolution operations are applied to the same software architecture in parallel, they sometimes make conflicting modifications, which will hinder the correctness of software architecture evolution. Although different approaches have been proposed to describe and analyze software architecture evolution, little work has been made to address evolution conflicts of software architectures. Focusing on parallel evolution conflicts of software architectures, firstly the paper establishes definitions and characterizations of parallel evolution conflicts of software architectures based on hypergraph morphisms and set theories, and describes parallel evolution conflicts of software architectures through these definitions and characterizations. Secondly the paper constructs the critical pair definition of parallel evolution conflicts of software architectures based on hypergraphs and hypergraph morphisms, analyzes the completeness of the critical pair, designs and optimizes an algorithm to detect efficiently parallel evolution conflicts of software architectures using the critical pair. Finally, a tool support is used to evaluate the effectiveness of the proposed method.

An experience of designing integrated hardware and software solutions for high-performance computing in solving modern geophysical problems on the basis of full-wave inversion is described. Problems of designing mass high-performance software systems intended for extensive use in industry are discussed.

This paper relies on the resource-oriented architecture (ROA) to propose a middleware that shares resources (sensors, actuators and services) of one or more robots through the TCP/IP network, providing greater efficiency in the development of software applications for robotics. The proposed middleware consists of a set of web services that provides access to representational state of resources through simple and high-level interfaces to implement a software architecture for autonomous robots. The benefits of the proposed approach are manifold: i) full abstraction of complexity and heterogeneity of robotic devices through web services and uniform interfaces, ii) scalability and independence of the operating system and programming language, iii) secure control of resources for local or remote applications through the TCP/IP network, iv) the adoption of the Resource Description Framework (RDF), XML language and HTTP protocol, and v) dynamic configuration of the connections between services at runtime. The middleware was developed using the Linux operating system (Ubuntu), with some applications built as proofs of concept for the Android operating system. The architecture specification and the open source implementation of the proposed middleware are detailed in this article, as well as applications for robot remote control via wireless networks, voice command functionality, and obstacle detection and avoidance.

We apply cybernetics theory to control software behaviors in architecture-level.We propose Breeze/ADL to specify the self-adaptive architecture.We design a learning algorithm to derive feedbacks to adjust the architecture.We extend tool - Breeze to support our framework. Display Omitted The cloud computing era requires software architecture to be self-adaptive to the dynamic environment. This autonomous feature brings uncertainty and makes software behavior difficult to control. The uncontrollable behavior is caused by ill-defined architecture and might lead to system disruption. To address this problem, we propose a novel framework which applies software cybernetics to guide self-adaptive architecture evolution. In our framework, we formulate the architecture evolution process as a feedback control process. In the process, we take the self-adaptive architecture model and the model checking technique as the controlled object and controller, respectively. First, the self-adaptive architecture is specified by Breeze/ADL. Second, the framework leverages model checking to validate adaptive Breeze/ADL specifications. Third, a learning algorithm is designed to regulate validation results to generate feedback rules - Productions to guide the architecture evolution. A smart phone application example is chosen to demonstrate the feasibility of our framework. The results show that our framework facilitates architects to detect undesired states which are caused by error-prone adaptation rules.

No consolidated set of software engineering best practices for the Internet of Things (IoT) has yet emerged. Too often, the landscape resembles the Wild West, with unprepared programmers putting together IoT systems in ad hoc fashion and throwing them out into the market, often poorly tested. In addition, the academic sector is in danger of fragmenting into specialized, often unrelated research areas. This IEEE Software theme issue aims to help provide the basis for a set of best practices that will guide the industry through the challenges of software engineering for the IoT

Despite the progress in Internet of Things (IoT) research, a general software engineering approach for systematic development of IoT systems and applications is still missing. A synthesis of the state of the art in the area can help frame the key abstractions related to such development. Such a framework could be the basis for guidelines for IoT-oriented software engineering.

It has been well-documented that the software architecture of any system plays a critical role in success or failure of software intensive systems. In this paper, a method has been proposed to evaluate the software architecture’s fitness with respect to key quality attributes for a web-based system. To the end, a comparative analysis based on quality attributes scenarios and tactics is carried out to select an optimal software architecture that meets the system level requirements of a web-based system, namely, Student and Course Evaluation System (SCES). The comparative study was driven by study of quality attributes and tactics with the selected architectures to select the optimal one.

Even in the eighties, the need of managing software evolution has been detected as one of the most complex aspects of the software lifecycle. In this context, software architecture has been highlighted as an integral element of the software evolution process. However, no matter how much effort is put into the architecture, it must eventually be translated into source code. The potential misalignment between architecture and code can lead to failures in the evolution process in terms of economic impacts, failed expectations, and so on. In this article we report on a design science research study that we pursued to answer three research questions. First, we have studied whether and in how far it is possible to design an approach that both enforces the integration between software architecture and source code to avoid architectural erosion and architectural drift and, at the same time, provides automatic guidance to developers to carry out the required change tasks in each evolution steps. Second, we have studied whether this approach may be applied in realistic (open source) cases. Finally, we have analysed whether it is realizable at acceptable costs (in terms of development effort) in comparison to the overall development efforts roughly spent on the evolution of the projects in focus.

A look at the IEEE Software history website illustrates the practical value of historical data and offers a glimpse into the magazine's future.

The requirement for high reliability is no longer restricted to a few specialized and proven domains. Instead, ever more functions whose failure can hurt humans and damage property are cropping up in new areas. Avoiding problems and catastrophes in the new software reliability landscape is possible but won't be easy.

We introduce in this work a new software architecture design, based on well-established web communication protocols and scripting languages, for implementing spatially-indexed media in smart environments. We based our approach on specific design guidelines. Our concept of spatially-indexed media enables users to readily instantiate mappings between digital content and specific regions of the physical space. We present an implementation of the architecture using a motion capture system, a large visualization display, and several smart devices. We also present an experimental evaluation of our new software architecture by reporting response times function of changes in the complexity of physical-digital environment.

This paper presents a software architecture for micro-controllers based solutions that run in capture data cards for Internet of Things (IoT). The present approach describes the components of the software architecture and its interaction. Equally, the architecture allows the development of modular and configurable applications as is focused on the overall design and system specification. The evaluation was performed in a Fog Water Collection system.