The paper presents a novel ecosystem for software-intensive embedded systems as an alternative to integration-centric software development. A set of necessary qualities is identified for the embedded platform enabling the ecosystem, i.e. deployability of new functions, maintainability over time, and configurability according to hardware within the product family. The embedded platform must support composability of software from different development stakeholders, such as the original equipment manufacturer, strategic and 3rd-party developers. The paper presents some key mechanisms for implementing the necessary certification in the platform that facilitates composability while still preserving dependability. A theoretical example of how this would look like in the automotive domain is presented, and an actual case of an in-vehicle platform implementing some of the mechanisms is shown.
{"title":"Using architecture for multiple levels of access to an ecosystem platform","authors":"Ulrik Eklund, J. Bosch","doi":"10.1145/2304696.2304720","DOIUrl":"https://doi.org/10.1145/2304696.2304720","url":null,"abstract":"The paper presents a novel ecosystem for software-intensive embedded systems as an alternative to integration-centric software development. A set of necessary qualities is identified for the embedded platform enabling the ecosystem, i.e. deployability of new functions, maintainability over time, and configurability according to hardware within the product family. The embedded platform must support composability of software from different development stakeholders, such as the original equipment manufacturer, strategic and 3rd-party developers. The paper presents some key mechanisms for implementing the necessary certification in the platform that facilitates composability while still preserving dependability. A theoretical example of how this would look like in the automotive domain is presented, and an actual case of an in-vehicle platform implementing some of the mechanisms is shown.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"56 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115690566","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}
Software evolution is omnipresent and only with adequate flexibility it can be mastered in time and budget. Flexibility is supported by many architectural mechanisms, but more methodological support for a life-cycle-phases bridging approach of flexibility is still desirable. Therefore, in this paper we contribute a life-cycle-phases bridging approach for flexibility. Our approach supports architects during system design to achieve flexibility and during system evolution to exploit flexibility. We build on existing flexibility analysis techniques and extend them to give architects specific guidance and tool-support. For architecture design, we introduce an automated flexibility analysis with real-time feedback in architecture tools. For software evolution we provide a flexibility exploitation analysis which builds up on the results of the design time analysis and enables effective utilization of provided flexibility by deriving flexibility-aware work-plans. We demonstrate our approach by applying it to a checkin system, report first validation results from an empirical study and propose further validation activities.
{"title":"Architectural flexibility in a software-system's life-cycle: systematic construction and exploitation of flexibility","authors":"Matthias Naab, J. Stammel","doi":"10.1145/2304696.2304701","DOIUrl":"https://doi.org/10.1145/2304696.2304701","url":null,"abstract":"Software evolution is omnipresent and only with adequate flexibility it can be mastered in time and budget. Flexibility is supported by many architectural mechanisms, but more methodological support for a life-cycle-phases bridging approach of flexibility is still desirable. Therefore, in this paper we contribute a life-cycle-phases bridging approach for flexibility. Our approach supports architects during system design to achieve flexibility and during system evolution to exploit flexibility. We build on existing flexibility analysis techniques and extend them to give architects specific guidance and tool-support. For architecture design, we introduce an automated flexibility analysis with real-time feedback in architecture tools. For software evolution we provide a flexibility exploitation analysis which builds up on the results of the design time analysis and enables effective utilization of provided flexibility by deriving flexibility-aware work-plans. We demonstrate our approach by applying it to a checkin system, report first validation results from an empirical study and propose further validation activities.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"129735348","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}
Jian Yu, Jun Han, Jean-Guy Schneider, Cameron M. Hine, Steven Versteeg
Modern enterprise software systems often need to interact with a large number of heterogeneous systems in an enterprise IT environment. The distributedness, large-scale-ness, and heterogeneity of such environment makes it difficult to test a system's quality attributes such as performance and scalability before it is actually deployed in the environment. In this paper, we present a Coloured Petri nets (CPN) based system behaviour emulation approach and a lightweight virtual testing framework for provisioning the deployment testing environment of an enterprise system so that its quality attributes, especially scalability, can be evaluated without physically connecting to the real production environment. This testing environment is scalable and has a flexible pluggable architecture to support the emulation of the behaviour of heterogeneous systems in the environment. To validate the feasibility of this approach, a CPN emulation model for LDAP has been developed and applied in testing the scalability of a real-life identity management system. An in-lab performance study has been conducted to demonstrate the effectiveness of this approach.
{"title":"A virtual deployment testing environment for enterprise software systems","authors":"Jian Yu, Jun Han, Jean-Guy Schneider, Cameron M. Hine, Steven Versteeg","doi":"10.1145/2304696.2304714","DOIUrl":"https://doi.org/10.1145/2304696.2304714","url":null,"abstract":"Modern enterprise software systems often need to interact with a large number of heterogeneous systems in an enterprise IT environment. The distributedness, large-scale-ness, and heterogeneity of such environment makes it difficult to test a system's quality attributes such as performance and scalability before it is actually deployed in the environment. In this paper, we present a Coloured Petri nets (CPN) based system behaviour emulation approach and a lightweight virtual testing framework for provisioning the deployment testing environment of an enterprise system so that its quality attributes, especially scalability, can be evaluated without physically connecting to the real production environment. This testing environment is scalable and has a flexible pluggable architecture to support the emulation of the behaviour of heterogeneous systems in the environment. To validate the feasibility of this approach, a CPN emulation model for LDAP has been developed and applied in testing the scalability of a real-life identity management system. An in-lab performance study has been conducted to demonstrate the effectiveness of this approach.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"41 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124292008","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}
Despite receiving much research attention, the extraction of runtime architecture remains hard. One approach, SCHOLIA, relies on adding typecheckable annotations to the code, and uses static analysis to extract a global, hierarchical Ownership Object Graph (OOG). The OOG provides architectural abstraction by ownership hierarchy and by types, and can be abstracted into a run-time architecture represented in an architectural description language, for documentation or conformance analysis. We report on our experience in analyzing a medium-sized object-oriented system undergoing maintenance to: (1) extract an OOG; and (2) refine the OOG based on the maintainers' feedback. We evaluate the effectiveness of abstraction by ownership hierarchy and by types to extract an OOG that the system maintainers understand. We measure the extraction effort to be about 1~hour/KLOC. An evaluation with the lead maintainer confirms that he understands abstraction by ownership hierarchy and by types. Finally, we illustrate how to incrementally refine an extracted OOG (without starting all over) to better match the maintainer's mental model.
{"title":"Extraction of ownership object graphs from object-oriented code: an experience report","authors":"Marwan Abi-Antoun, Nariman Ammar, Zeyad Hailat","doi":"10.1145/2304696.2304719","DOIUrl":"https://doi.org/10.1145/2304696.2304719","url":null,"abstract":"Despite receiving much research attention, the extraction of runtime architecture remains hard. One approach, SCHOLIA, relies on adding typecheckable annotations to the code, and uses static analysis to extract a global, hierarchical Ownership Object Graph (OOG). The OOG provides architectural abstraction by ownership hierarchy and by types, and can be abstracted into a run-time architecture represented in an architectural description language, for documentation or conformance analysis.\u0000 We report on our experience in analyzing a medium-sized object-oriented system undergoing maintenance to: (1) extract an OOG; and (2) refine the OOG based on the maintainers' feedback.\u0000 We evaluate the effectiveness of abstraction by ownership hierarchy and by types to extract an OOG that the system maintainers understand. We measure the extraction effort to be about 1~hour/KLOC. An evaluation with the lead maintainer confirms that he understands abstraction by ownership hierarchy and by types. Finally, we illustrate how to incrementally refine an extracted OOG (without starting all over) to better match the maintainer's mental model.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"321 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133836831","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}
Architecting software systems is an integral part of the software development lifecycle. However, often the implementation of the resultant software ends up diverging from the designed architecture due to factors such as time pressures on the development team during implementation/evolution, or the lack of architectural awareness on the part of (possibly new) programmers. In such circumstances, the quality requirements addressed by the as-designed architecture are likely to be unaddressed by the as-implemented system. This paper reports on in-vivo case studies of the ACTool, a tool which supports real-time Reflexion Modeling for architecture recovery and on-going consistency. It describes our experience conducting architectural recovery sessions on three deployed, commercial software systems in two companies with the tool, as a first step towards ongoing architecture consistency in these systems. Our findings provide the first in-depth characterization of real-time Reflexion-based architectural recovery in practice, highlighting the architectural recovery agendas at play, the modeling approaches employed, the mapping approaches employed and characterizing the inconsistencies encountered. Our findings also discuss the usefulness of the ACTool for these companies.
{"title":"Characterizing real-time reflexion-based architecture recovery: an in-vivo multi-case study","authors":"Nour Ali, Jacek Rosik, J. Buckley","doi":"10.1145/2304696.2304702","DOIUrl":"https://doi.org/10.1145/2304696.2304702","url":null,"abstract":"Architecting software systems is an integral part of the software development lifecycle. However, often the implementation of the resultant software ends up diverging from the designed architecture due to factors such as time pressures on the development team during implementation/evolution, or the lack of architectural awareness on the part of (possibly new) programmers. In such circumstances, the quality requirements addressed by the as-designed architecture are likely to be unaddressed by the as-implemented system.\u0000 This paper reports on in-vivo case studies of the ACTool, a tool which supports real-time Reflexion Modeling for architecture recovery and on-going consistency. It describes our experience conducting architectural recovery sessions on three deployed, commercial software systems in two companies with the tool, as a first step towards ongoing architecture consistency in these systems. Our findings provide the first in-depth characterization of real-time Reflexion-based architectural recovery in practice, highlighting the architectural recovery agendas at play, the modeling approaches employed, the mapping approaches employed and characterizing the inconsistencies encountered. Our findings also discuss the usefulness of the ACTool for these companies.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"14 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126750535","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}
Identifying and removing the causes of poor performance in software systems are complex problems due to a variety of factors to take into account. Nowadays these problems are usually tackled after the software deployment only with human-based means, which frequently boil down to developer skills and previous experiences. Performance antipatterns can be used to cope with these problems since they capture typical design patterns that are known leading to performance problems, as well as refactoring actions that can be taken to remove them. The goal of this paper is to introduce an approach that allows the refactoring of architectural models, based on antipatterns, that aims at providing performance improvement. To this end, we use a Role-Based Modeling Language to represent: (i) antipattern problems as Source Role Models (SRMs), and (ii) antipattern solutions as Target Role Models (TRMs). Hence, SRM-TRM pairs represent new instruments in the hands of developers to achieve architectural model refactorings aimed at removing sources of performance problems. Model refactoring for antipattern removal can be in fact obtained by replacing an SRM with the corresponding TRM. This approach has been applied to a case study in the e-commerce domain, whose experimental results demonstrate its effectiveness.
{"title":"Antipattern-based model refactoring for software performance improvement","authors":"Davide Arcelli, V. Cortellessa, Catia Trubiani","doi":"10.1145/2304696.2304704","DOIUrl":"https://doi.org/10.1145/2304696.2304704","url":null,"abstract":"Identifying and removing the causes of poor performance in software systems are complex problems due to a variety of factors to take into account. Nowadays these problems are usually tackled after the software deployment only with human-based means, which frequently boil down to developer skills and previous experiences. Performance antipatterns can be used to cope with these problems since they capture typical design patterns that are known leading to performance problems, as well as refactoring actions that can be taken to remove them.\u0000 The goal of this paper is to introduce an approach that allows the refactoring of architectural models, based on antipatterns, that aims at providing performance improvement. To this end, we use a Role-Based Modeling Language to represent: (i) antipattern problems as Source Role Models (SRMs), and (ii) antipattern solutions as Target Role Models (TRMs). Hence, SRM-TRM pairs represent new instruments in the hands of developers to achieve architectural model refactorings aimed at removing sources of performance problems. Model refactoring for antipattern removal can be in fact obtained by replacing an SRM with the corresponding TRM. This approach has been applied to a case study in the e-commerce domain, whose experimental results demonstrate its effectiveness.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"32 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"117302765","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}
Romina Eramo, V. Cortellessa, A. Pierantonio, Michele Tucci
The generation of performance models from architectural models has been tackled with well-founded approaches in the last decade, whereas there is a clear lack of automation in the backward path that brings the analysis results back to the software architecture. It is common to iteratively modify a (generated) performance model until performance indices meet the requirements. However, propagating the performance model modifications back to the original architectural model is a complex problem. In this paper we make a first step in this direction, in that we use the JTL language for specifying a bidirectional model transformation between UML models and Queueing Networks, so working towards an automated round-trip process between software architectural models and performance models.
{"title":"Performance-driven architectural refactoring through bidirectional model transformations","authors":"Romina Eramo, V. Cortellessa, A. Pierantonio, Michele Tucci","doi":"10.1145/2304696.2304707","DOIUrl":"https://doi.org/10.1145/2304696.2304707","url":null,"abstract":"The generation of performance models from architectural models has been tackled with well-founded approaches in the last decade, whereas there is a clear lack of automation in the backward path that brings the analysis results back to the software architecture. It is common to iteratively modify a (generated) performance model until performance indices meet the requirements. However, propagating the performance model modifications back to the original architectural model is a complex problem. In this paper we make a first step in this direction, in that we use the JTL language for specifying a bidirectional model transformation between UML models and Queueing Networks, so working towards an automated round-trip process between software architectural models and performance models.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"38 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131834865","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}
In this paper we present an approach for supporting the semi-automated abstraction of architectural models throughout the software lifecycle. It addresses the problem that the design and the implementation of a software system often drift apart as software systems evolve, leading to architectural knowledge evaporation. Our approach provides concepts and tool support for the semi-automatic abstraction of architectural knowledge from implemented systems and keeping the abstracted architectural knowledge up-to-date. In particular, we propose architecture abstraction concepts that are supported through a domain-specific language (DSL). Our main focus is on providing architectural abstraction specifications in the DSL that only need to be changed, if the architecture changes, but can tolerate non-architectural changes in the underlying source code. The DSL and its tools support abstracting the source code into UML component models for describing the architecture. Once the software architect has defined an architectural abstraction in the DSL, we can automatically generate UML component models from the source code and check whether the architectural design constraints are fulfilled by the models. Our approach supports full traceability between source code elements and architectural abstractions, and allows software architects to compare different versions of the generated UML component model with each other. We evaluate our research results by studying the evolution of architectural abstractions in different consecutive versions and the execution times for five existing open source systems.
{"title":"DSL-based support for semi-automated architectural component model abstraction throughout the software lifecycle","authors":"Thomas Haitzer, Uwe Zdun","doi":"10.1145/2304696.2304709","DOIUrl":"https://doi.org/10.1145/2304696.2304709","url":null,"abstract":"In this paper we present an approach for supporting the semi-automated abstraction of architectural models throughout the software lifecycle. It addresses the problem that the design and the implementation of a software system often drift apart as software systems evolve, leading to architectural knowledge evaporation. Our approach provides concepts and tool support for the semi-automatic abstraction of architectural knowledge from implemented systems and keeping the abstracted architectural knowledge up-to-date. In particular, we propose architecture abstraction concepts that are supported through a domain-specific language (DSL). Our main focus is on providing architectural abstraction specifications in the DSL that only need to be changed, if the architecture changes, but can tolerate non-architectural changes in the underlying source code. The DSL and its tools support abstracting the source code into UML component models for describing the architecture. Once the software architect has defined an architectural abstraction in the DSL, we can automatically generate UML component models from the source code and check whether the architectural design constraints are fulfilled by the models. Our approach supports full traceability between source code elements and architectural abstractions, and allows software architects to compare different versions of the generated UML component model with each other. We evaluate our research results by studying the evolution of architectural abstractions in different consecutive versions and the execution times for five existing open source systems.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"23 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"123955895","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}
Virtually all software systems of significant size and longevity eventually undergo changes to their basic architectural structure. Such changes may be prompted by new feature requests, new quality attribute requirements, changing technology, or other reasons. Whatever the cause, software architecture evolution is commonplace in real-world software projects. However, research in this area has suffered from problems of validation; previous work has tended to make heavy use of toy examples and hypothetical scenarios and has not been well supported by real-world examples. To help address this problem, this paper presents a case study of an ongoing effort at the Jet Propulsion Laboratory to rearchitect the Advanced Multimission Operations System used to operate NASA's deep-space and astrophysics missions. Based on examination of project documents and interviews with project personnel, I describe the goals and approach of this evolution effort, then demonstrate how approaches and formal methods from previous research in architecture evolution may be applied to this evolution while using languages and tools already in place at the Jet Propulsion Laboratory.
{"title":"NASA's advanced multimission operations system: a case study in software architecture evolution","authors":"Jeffrey M. Barnes","doi":"10.1145/2304696.2304700","DOIUrl":"https://doi.org/10.1145/2304696.2304700","url":null,"abstract":"Virtually all software systems of significant size and longevity eventually undergo changes to their basic architectural structure. Such changes may be prompted by new feature requests, new quality attribute requirements, changing technology, or other reasons. Whatever the cause, software architecture evolution is commonplace in real-world software projects. However, research in this area has suffered from problems of validation; previous work has tended to make heavy use of toy examples and hypothetical scenarios and has not been well supported by real-world examples. To help address this problem, this paper presents a case study of an ongoing effort at the Jet Propulsion Laboratory to rearchitect the Advanced Multimission Operations System used to operate NASA's deep-space and astrophysics missions. Based on examination of project documents and interviews with project personnel, I describe the goals and approach of this evolution effort, then demonstrate how approaches and formal methods from previous research in architecture evolution may be applied to this evolution while using languages and tools already in place at the Jet Propulsion Laboratory.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"19 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"126842726","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}
Y. Dajsuren, M. Brand, Alexander Serebrenik, R. Huisman
Over the last decade, Architecture Description Languages (ADLs) are attracting considerable attention by automotive companies because they consider them as one of the key solutions to improve the quality of automotive electronic and software systems. Automotive ADLs like EAST-ADL, AADL, TADL, and AML are being defined to address not only the architectural description or the representation issues but also as a method to enable requirements traceability and early analysis of a system. Besides the automotive specific ADLs, SysML and MARTE are emerging as viable modeling approaches for automotive systems engineering domain as well. However, all these modeling approaches lack the capability of ensuring the architectural quality. This paper identifies an architectural inconsistency between the different architectural levels as one of the key issues regarding architectural quality of automotive systems and proposes a rule-based method to enforce consistency between these levels. Since there is no standard ADL for automotive systems, we first evaluated a set of modeling approaches based on the automotive specific modeling requirements and selected SysML mainly due to its flexibility, and mature and accessible tool support. We modeled a Cruise Control system to demonstrate modeling of an automotive system in SysML and to evaluate the method for the architectural consistency checking using SysML.
{"title":"Automotive ADLS: a study on enforcing consistency through multiple architectural levels","authors":"Y. Dajsuren, M. Brand, Alexander Serebrenik, R. Huisman","doi":"10.1145/2304696.2304710","DOIUrl":"https://doi.org/10.1145/2304696.2304710","url":null,"abstract":"Over the last decade, Architecture Description Languages (ADLs) are attracting considerable attention by automotive companies because they consider them as one of the key solutions to improve the quality of automotive electronic and software systems. Automotive ADLs like EAST-ADL, AADL, TADL, and AML are being defined to address not only the architectural description or the representation issues but also as a method to enable requirements traceability and early analysis of a system. Besides the automotive specific ADLs, SysML and MARTE are emerging as viable modeling approaches for automotive systems engineering domain as well. However, all these modeling approaches lack the capability of ensuring the architectural quality. This paper identifies an architectural inconsistency between the different architectural levels as one of the key issues regarding architectural quality of automotive systems and proposes a rule-based method to enforce consistency between these levels. Since there is no standard ADL for automotive systems, we first evaluated a set of modeling approaches based on the automotive specific modeling requirements and selected SysML mainly due to its flexibility, and mature and accessible tool support. We modeled a Cruise Control system to demonstrate modeling of an automotive system in SysML and to evaluate the method for the architectural consistency checking using SysML.","PeriodicalId":110790,"journal":{"name":"International ACM SIGSOFT Conference on Quality of Software Architectures","volume":"39 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2012-06-25","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"131821165","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
扫码关注我们
求助内容：
应助结果提醒方式：