2. INTRODUCTION In the last several years our industry has undergone a significant transition in our approach to the use of existing commercial-off-the-shelf (COTS) products in building systems. The government, for example, has shifted from discouraging the use of commercial products to actively encouraging their use. This shift is based on a number of factors, not the least of which is the spiraling cost of customdeveloped software. More and more, solutions are built by integrating COTS products rather than building “from scratch”. In response to this emphasis, increasing numbers of COTS products are available, and industry is beginning to address the issue of making them interoperable.
{"title":"A lifecycle process for the effective reuse of commercial off-the-shelf (COTS) software","authors":"C. Braun","doi":"10.1145/303008.303015","DOIUrl":"https://doi.org/10.1145/303008.303015","url":null,"abstract":"2. INTRODUCTION In the last several years our industry has undergone a significant transition in our approach to the use of existing commercial-off-the-shelf (COTS) products in building systems. The government, for example, has shifted from discouraging the use of commercial products to actively encouraging their use. This shift is based on a number of factors, not the least of which is the spiraling cost of customdeveloped software. More and more, solutions are built by integrating COTS products rather than building “from scratch”. In response to this emphasis, increasing numbers of COTS products are available, and industry is beginning to address the issue of making them interoperable.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"13 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115648126","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
At Boeing, the large, multiple-release Define and Control Airplane ConfigurationlManufacturing Resource Management (DCACYMRM) data conversion effort had to develop a complete conversion system that could: 1) load data extremely quickly, 2) handle large data volumes of legacy extracts, 3) adapt to architectural changes simply and easily, and 4) be used by programmers with no special training. The phased nature of the loads required reusable loading techniques, and the changing target architectures required adaptable techniques. In this paper, we discuss our approach to loading large volumes of data efficiently into a system during three distinct releases. As part of the solution, we implemented a repeatable software engineering process, in part because of the many shortcomings of using commercial-off-the-shelf (COTS) vendor’s approaches to creating the software. This paper will trace the adaptive capabilities of our software reuse techniques through the three releases. We highlight factors that allow the same reuse techniques to be used for repeatable processes in large industrial settings. Finally, we present observations about software reuse gathered from our experience. For Boeing to succeed, we had to employ a reuse approach to our software development. We settled on using adaptive frames to create accurate logic decisions in the code, and by optimizing the efficiency of the resulting code.
{"title":"Software reuse: data conversion experiences and issues","authors":"James H. Illback","doi":"10.1145/303008.303012","DOIUrl":"https://doi.org/10.1145/303008.303012","url":null,"abstract":"At Boeing, the large, multiple-release Define and Control Airplane ConfigurationlManufacturing Resource Management (DCACYMRM) data conversion effort had to develop a complete conversion system that could: 1) load data extremely quickly, 2) handle large data volumes of legacy extracts, 3) adapt to architectural changes simply and easily, and 4) be used by programmers with no special training. The phased nature of the loads required reusable loading techniques, and the changing target architectures required adaptable techniques. In this paper, we discuss our approach to loading large volumes of data efficiently into a system during three distinct releases. As part of the solution, we implemented a repeatable software engineering process, in part because of the many shortcomings of using commercial-off-the-shelf (COTS) vendor’s approaches to creating the software. This paper will trace the adaptive capabilities of our software reuse techniques through the three releases. We highlight factors that allow the same reuse techniques to be used for repeatable processes in large industrial settings. Finally, we present observations about software reuse gathered from our experience. For Boeing to succeed, we had to employ a reuse approach to our software development. We settled on using adaptive frames to create accurate logic decisions in the code, and by optimizing the efficiency of the resulting code.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"95 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115173313","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
One way to support development and maintenance of a software system family is to design a generic software architecture for a family. A generic architecture captures requirements common to all (or most of) the family members. Then, we develop specific software systems, members of a family, by customizing a generic architecture. During customization, we address variant requirements to be met by a specific system we wish to implement. In this paper, we describe how we applied frame technology an advanced form of pre-processing to design a mechanism for customizing generic software architectures. Customization of a generic architecture involves selecting architecture components, customization of connectors and customization of components’ code. We turn architecture components and connectors into frames and map variant requirements into sequences of customization activities. The frame processor and Perl scripts automate the customization process. Our customization method can be applied to a wide range of generic architectures. It can be used together with other customization techniques such as inheritance (in Object-Oriented frameworks), table-driven techniques (in compiler-compilers) or parameterization. The overall objective of the work described in this paper is to create formal links between requirements for system families and the process of customizing a generic architecture during architecture-based system engineering. Ideally, a system engineer would define only novel requirements for a specific system (based on a domain model) and an automated engineering environment would actively guide him/her in obtaining the architecture and code for the specific system. This paper describes some of the techniques that lead towards this objective.
{"title":"Frame-based method for customizing generic software architectures","authors":"Y. C. Cheong, S. Jarzabek","doi":"10.1145/303008.303043","DOIUrl":"https://doi.org/10.1145/303008.303043","url":null,"abstract":"One way to support development and maintenance of a software system family is to design a generic software architecture for a family. A generic architecture captures requirements common to all (or most of) the family members. Then, we develop specific software systems, members of a family, by customizing a generic architecture. During customization, we address variant requirements to be met by a specific system we wish to implement. In this paper, we describe how we applied frame technology an advanced form of pre-processing to design a mechanism for customizing generic software architectures. Customization of a generic architecture involves selecting architecture components, customization of connectors and customization of components’ code. We turn architecture components and connectors into frames and map variant requirements into sequences of customization activities. The frame processor and Perl scripts automate the customization process. Our customization method can be applied to a wide range of generic architectures. It can be used together with other customization techniques such as inheritance (in Object-Oriented frameworks), table-driven techniques (in compiler-compilers) or parameterization. The overall objective of the work described in this paper is to create formal links between requirements for system families and the process of customizing a generic architecture during architecture-based system engineering. Ideally, a system engineer would define only novel requirements for a specific system (based on a domain model) and an automated engineering environment would actively guide him/her in obtaining the architecture and code for the specific system. This paper describes some of the techniques that lead towards this objective.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"38 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126867219","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Reusing SAP R/3 business requirements has been recognized as the most promising strategy to shorten the time-to-production and increase the quality of the conceptual design in R/3 implementation projects. However, very little research has been conducted to actually quantify and really estimate the results from SAP R/3 requirement reuse the customers have achieved. This paper deals with the identification and the measurement of reuse in the requirements conceptualization phase of the SAP R/3 component configuration cycle. We present a systematic approach based on standard functional size measurement practices. We introduce two key concepts: SAP requirements reuse levels and reuse indicators. The reuse levels serve to classify SAP requirements based on the extent to which the requirements are reused in a R/3 implementation project. The reuse indicators are then built to quantify the requirement reuse the company has achieved. An experimental case study illustrates the applicability of the approach. Finally, some validation issues are addressed.
{"title":"Measuring reuse of SAP requirements: a model-based approach","authors":"M. Daneva","doi":"10.1145/303008.303069","DOIUrl":"https://doi.org/10.1145/303008.303069","url":null,"abstract":"Reusing SAP R/3 business requirements has been recognized as the most promising strategy to shorten the time-to-production and increase the quality of the conceptual design in R/3 implementation projects. However, very little research has been conducted to actually quantify and really estimate the results from SAP R/3 requirement reuse the customers have achieved. This paper deals with the identification and the measurement of reuse in the requirements conceptualization phase of the SAP R/3 component configuration cycle. We present a systematic approach based on standard functional size measurement practices. We introduce two key concepts: SAP requirements reuse levels and reuse indicators. The reuse levels serve to classify SAP requirements based on the extent to which the requirements are reused in a R/3 implementation project. The reuse indicators are then built to quantify the requirement reuse the company has achieved. An experimental case study illustrates the applicability of the approach. Finally, some validation issues are addressed.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"29 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116465103","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
One of the hardest tasks to be fulfilled during the analysis of legacy systems is how to determine the precise semantics of program components. Investigating the internal data and control structures is difficult due to the huge number of possible implementation variants for the same problem. To facilitate the task we propose to use components kept and described in a repository of reusable concepts as reference points. This becomes possible when behavior sampling is used as classification/retrieval strategy. In matching the results of isolated components from a legacy system against already executed components in a repository, one can tackle the problem of classifying legacy components without considering there internal structure. As a side effect, the population of the reuse repository is increased. In this paper we propose a model to reuse the knowledge containd in a behavior based reuse repository for analyzing, classifying and understanding isolated executable components from a legacy system. Components not yet classfied will augment the repository.
{"title":"Support of semantics recovery during code scavenging using repository classification","authors":"Heinz Pozewaunig, Dominik Rauner-Reithmayer","doi":"10.1145/303008.303029","DOIUrl":"https://doi.org/10.1145/303008.303029","url":null,"abstract":"One of the hardest tasks to be fulfilled during the analysis of legacy systems is how to determine the precise semantics of program components. Investigating the internal data and control structures is difficult due to the huge number of possible implementation variants for the same problem. To facilitate the task we propose to use components kept and described in a repository of reusable concepts as reference points. This becomes possible when behavior sampling is used as classification/retrieval strategy. In matching the results of isolated components from a legacy system against already executed components in a repository, one can tackle the problem of classifying legacy components without considering there internal structure. As a side effect, the population of the reuse repository is increased. In this paper we propose a model to reuse the knowledge containd in a behavior based reuse repository for analyzing, classifying and understanding isolated executable components from a legacy system. Components not yet classfied will augment the repository.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"19 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133994449","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
One important facet of software reuse is the reuse of autonomous and distributed computational services. Components or applications offering services stay at the provider's site, where they are developed, kept securely, operated, maintained, and updated. Instead of purchasing software components, the customer buys services by invoking methods provided by these remote applications over the Internet. Due to the autonomy of the services, this reuse model causes specific requirements that differ from those where one builds one's own system from components. These requirements have led to the definition of CPAM, a protocol for reusing remote and autonomous services. CPAM can be used on top of various distribution systems, and offers features like presetting of attributes, run-time estimation of costs and having several calls for setup, invocation and result extraction. The CPAM protocol has been successfully used within CHAIMS, a reuse environment that supports the generation of client applications based on CPAM.
{"title":"A reuse and composition protocol for services","authors":"D. Beringer, L. Melloul, G. Wiederhold","doi":"10.1145/303008.303027","DOIUrl":"https://doi.org/10.1145/303008.303027","url":null,"abstract":"One important facet of software reuse is the reuse of autonomous and distributed computational services. Components or applications offering services stay at the provider's site, where they are developed, kept securely, operated, maintained, and updated. Instead of purchasing software components, the customer buys services by invoking methods provided by these remote applications over the Internet. Due to the autonomy of the services, this reuse model causes specific requirements that differ from those where one builds one's own system from components. These requirements have led to the definition of CPAM, a protocol for reusing remote and autonomous services. CPAM can be used on top of various distribution systems, and offers features like presetting of attributes, run-time estimation of costs and having several calls for setup, invocation and result extraction. The CPAM protocol has been successfully used within CHAIMS, a reuse environment that supports the generation of client applications based on CPAM.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"13 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121292898","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
This paper describes research into the design of reusable and extensible software architectures for families of systems. The approach is illustrated by an example of a federation of client/server software systems. The architecture, which is specified in an Architecture Description Language, is organized at three levels of software reuse, application domain independent, domain specific, and application specific. The architecture is composed of reusable domain specific black box architecture patterns and extensible domain specific white box architecture patterns. The paper describes the different levels of reuse in the software architecture and how the architecture may be extended.
{"title":"A reusable architecture for federated client/server systems","authors":"H. Gomaa, G. A. Farrukh","doi":"10.1145/303008.303061","DOIUrl":"https://doi.org/10.1145/303008.303061","url":null,"abstract":"This paper describes research into the design of reusable and extensible software architectures for families of systems. The approach is illustrated by an example of a federation of client/server software systems. The architecture, which is specified in an Architecture Description Language, is organized at three levels of software reuse, application domain independent, domain specific, and application specific. The architecture is composed of reusable domain specific black box architecture patterns and extensible domain specific white box architecture patterns. The paper describes the different levels of reuse in the software architecture and how the architecture may be extended.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"79 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"127070648","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The paper describes a technique for building a closed loop reuse environment obtained by polling user feedback about selected reuse components in order to enhance the system effectiveness. Polling of user choices is exploited in two ways: to tune the retrieval of the software reuse environment and as a basis for a reward system to encourage reuse. Both feedback and reward are made dependent of the user typology through a user profile. An application of the proposed approach to ameliorate the quality of a descriptor based reuse system is illustrated, and some simulation results against a sample component repository are reported.
{"title":"User opinions and rewards in a reuse-based development system","authors":"C. Bellettini, E. Damiani, M. Fugini","doi":"10.1145/303008.303071","DOIUrl":"https://doi.org/10.1145/303008.303071","url":null,"abstract":"The paper describes a technique for building a closed loop reuse environment obtained by polling user feedback about selected reuse components in order to enhance the system effectiveness. Polling of user choices is exploited in two ways: to tune the retrieval of the software reuse environment and as a basis for a reward system to encourage reuse. Both feedback and reward are made dependent of the user typology through a user profile. An application of the proposed approach to ameliorate the quality of a descriptor based reuse system is illustrated, and some simulation results against a sample component repository are reported.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"100 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124741512","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
W. Curry, G. Succi, Michael R. Smith, Eric Liu, Raymond Wong
In recent years, there have been several proposals for amount-ofreuse metrics. However, it is not often clear if these metrics measure anything different than already used software metrics, or what the relations between these metrics really are. Without this, the true added value provided by each metric is unknown. In this paper, an analysis of the existing amount-of-reuse metrics is presented and a portion of them are selected on the basis of their industrial applicability. These metrics are then applied to a collection of public domain software products, to obtain an understanding of the level of correlation that exists between them and other well known software metrics such as cyclomatic complexity, volume and lines of code. Through this process we find that a subset of the selected amount-of-reuse metrics provide a relatively independent view of the analyzed code.
{"title":"Empirical analysis of the correlation between amount-of-reuse metrics in the C programming language","authors":"W. Curry, G. Succi, Michael R. Smith, Eric Liu, Raymond Wong","doi":"10.1145/303008.303066","DOIUrl":"https://doi.org/10.1145/303008.303066","url":null,"abstract":"In recent years, there have been several proposals for amount-ofreuse metrics. However, it is not often clear if these metrics measure anything different than already used software metrics, or what the relations between these metrics really are. Without this, the true added value provided by each metric is unknown. In this paper, an analysis of the existing amount-of-reuse metrics is presented and a portion of them are selected on the basis of their industrial applicability. These metrics are then applied to a collection of public domain software products, to obtain an understanding of the level of correlation that exists between them and other well known software metrics such as cyclomatic complexity, volume and lines of code. Through this process we find that a subset of the selected amount-of-reuse metrics provide a relatively independent view of the analyzed code.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"56 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121198719","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Joachim Bayer, Oliver Flege, Peter Knauber, Roland Laqua, Dirk Muthig, Klaus Schmid, Tanya Widen, Jean-Marc DeBaud
Software product lines have recently been introduced as one of the most promising advances for efficient software development. Yet upon close examination, there are few guidelines or methodologies available to develop and deploy product lines beyond existing domain engineering approaches. The latter have had mixed success within commercial enterprises because of their deployment complexity, lack of customizability, and especially their misplaced focus, that is on domains as opposed to products. To tackle these problems we developed the PuLSETM (Product Line Software Engineering) methodology for the purpose of enabling the conception and deployment of software product lines within a large variety of enterprise contexts. This is achieved via product-centric focus throughout the phases of PuLSETM, customizability of its components, incremental introduction capability, maturity scale for structured evolution, and adaptations to a few main product development situations. PuLSETM is the result of a bottom-up effort: the methodology captures and leverages the results (the lessons learned) from our technology transfer activities with our industrial customers. We present in this paper the main ideas behind PuLSETM and illustrate the methodology with a running example taken from our transfer experience.
{"title":"PuLSE: a methodology to develop software product lines","authors":"Joachim Bayer, Oliver Flege, Peter Knauber, Roland Laqua, Dirk Muthig, Klaus Schmid, Tanya Widen, Jean-Marc DeBaud","doi":"10.1145/303008.303063","DOIUrl":"https://doi.org/10.1145/303008.303063","url":null,"abstract":"Software product lines have recently been introduced as one of the most promising advances for efficient software development. Yet upon close examination, there are few guidelines or methodologies available to develop and deploy product lines beyond existing domain engineering approaches. The latter have had mixed success within commercial enterprises because of their deployment complexity, lack of customizability, and especially their misplaced focus, that is on domains as opposed to products. To tackle these problems we developed the PuLSETM (Product Line Software Engineering) methodology for the purpose of enabling the conception and deployment of software product lines within a large variety of enterprise contexts. This is achieved via product-centric focus throughout the phases of PuLSETM, customizability of its components, incremental introduction capability, maturity scale for structured evolution, and adaptations to a few main product development situations. PuLSETM is the result of a bottom-up effort: the methodology captures and leverages the results (the lessons learned) from our technology transfer activities with our industrial customers. We present in this paper the main ideas behind PuLSETM and illustrate the methodology with a running example taken from our transfer experience.","PeriodicalId":270366,"journal":{"name":"ACM SIGSOFT Symposium on Software Reusability","volume":"19 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1999-05-21","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"132875585","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
京公网安备 11010802042870号
京ICP备2023020795号-1
扫码关注我们
求助内容：
应助结果提醒方式：