scholarly journals Isolated Testing of Software Components in Distributed Software Systems

Author(s):  
François Thillen ◽  
Richard Mordinyi ◽  
Stefan Biffl
2007 ◽  
Vol 22 (4) ◽  
pp. 265-278 ◽  
Author(s):  
Julia Kotlarsky

This case study discusses two related aspects that are becoming increasingly important in today's software development practice: re-engineering of a monolithic system into a component-based system (the focus of this case) and globally distributed work. Component-based (software) development (CBD) involves (i) the development of software components and (ii) the building of software systems through the integration of preexisting software components (developed in-house or procured from the component market). For companies involved in software development, CBD offers agility in design by basing software development on methodologies that support the recombination of reusable components, being an approach that rapidly expands product variation and sustains the build-up of product families. It also promises significant improvements in software development through shorter time-to-market and reduced development costs. However, being an innovative approach to software development that emerged in the mid-1990s, the adoption of CBD requires companies to re-engineer existing software systems (products) or to develop new systems from scratch using component technologies and to deal with additional challenges associated with the management of CBD. LeCroy Corporation was one of the early adopters of CBD that decided to adopt CBD to gain competitive advantage in its markets. The case describes an actual situation at LeCroy Corporation, involving several decisions, challenges and opportunities faced by the managers of a globally distributed software development team over a period of time when they re-engineered a monolithic system into a component-based system.


1989 ◽  
Vol 12 (3) ◽  
pp. 317-356
Author(s):  
David C. Rine

Partitioning and allocating of software components are two important parts of software design in distributed software engineering. This paper presents two general algorithms that can, to a limited extent, be used as tools to assist in partitioning software components represented as objects in a distributed software design environment. One algorithm produces a partition (equivalence classes) of the objects, and a second algorithm allows a minimum amount of redundancy. Only binary relationships of actions (use or non-use) are considered in this paper.


2021 ◽  
Vol 11 (12) ◽  
pp. 5685
Author(s):  
Hosam Aljihani ◽  
Fathy Eassa ◽  
Khalid Almarhabi ◽  
Abdullah Algarni ◽  
Abdulaziz Attaallah

With the rapid increase of cyberattacks that presently affect distributed software systems, cyberattacks and their consequences have become critical issues and have attracted the interest of research communities and companies to address them. Therefore, developing and improving attack detection techniques are prominent methods to defend against cyberattacks. One of the promising attack detection methods is behaviour-based attack detection methods. Practically, attack detection techniques are widely applied in distributed software systems that utilise network environments. However, there are some other challenges facing attack detection techniques, such as the immutability and reliability of the detection systems. These challenges can be overcome with promising technologies such as blockchain. Blockchain offers a concrete solution for ensuring data integrity against unauthorised modification. Hence, it improves the immutability for detection systems’ data and thus the reliability for the target systems. In this paper, we propose a design for standalone behaviour-based attack detection techniques that utilise blockchain’s functionalities to overcome the above-mentioned challenges. Additionally, we provide a validation experiment to prove our proposal in term of achieving its objectives. We argue that our proposal introduces a novel approach to develop and improve behaviour-based attack detection techniques to become more reliable for distributed software systems.


2007 ◽  
Vol 15 (3) ◽  
pp. 265-281 ◽  
Author(s):  
Naveed Arshad ◽  
Dennis Heimbigner ◽  
Alexander L. Wolf

DYNA ◽  
2018 ◽  
Vol 85 (207) ◽  
pp. 74-83 ◽  
Author(s):  
Daniel Correa ◽  
Raúl Mazo ◽  
Gloria Lucia Giraldo Goméz

Software product lines facilitate the industrialization of software development. The main goal is to create a set of reusable software components for the rapid production of a software systems family. Many authors have proposed different approaches to design and implement the components of a product line. However, the construction and integration of these components continue to be a complex and time-consuming process. This paper introduces Fragment-oriented programming (FragOP), a framework to design and implement software product line domain components, and derive software products. FragOP is based on: (i) domain components, (ii) fragmentations points and (iii)fragments. FragOP was implemented in the VariaMos tool and using it we created a clothing stores software product line. We derivedfive different products, integrating automatically thousands of lines of code. On average, only three lines of code were manually modified;which provided preliminary evidence that using FragOP reduces manual intervention when integrating domain components.


2020 ◽  
pp. 53-108
Author(s):  
Christian Schlegel ◽  
Alex Lotz ◽  
Matthias Lutz ◽  
Dennis Stampfer

AbstractSuccessful engineering principles for building software systems rely on the separation of concerns for mastering complexity. However, just working on different concerns of a system in a collaborative way is not good enough for economically feasible tailored solutions. A successful approach for this is the composition of complex systems out of commodity building blocks. These come as is and can be represented as blocks with ports via data sheets. Data sheets are models and allow a proper selection and configuration as well as the prediction of the behavior of a building block in a specific context. This chapter explains how model-driven approaches can be used to support separation of roles and composition for robotics software systems. The models, open-source tools, open-source robotics software components and fully deployable robotics software systems shape a robotics software ecosystem.


Sign in / Sign up

Export Citation Format

Share Document