It is well known that software maintenance and evolution are expensive activities, both in
terms ... more It is well known that software maintenance and evolution are expensive activities, both in terms of invested time and money. Reverse engineering activities support the obtainment of abstractions and views from a target system that should help the engineers to maintain, evolve and eventually re-engineer it. Two important tasks pursued by reverse engineering are design pattern detection and software architecture reconstruction, whose main objectives are the identification of the design patterns that have been used in the implementation of a system as well as the generation of views placed at different levels of abstractions, which let the practitioners focus on the overall architecture of the system without worrying about the programming details it has been implemented with. In this context we propose an Eclipse plug-in called MARPLE (Metrics and Architecture Reconstruction Plug-in for Eclipse), which supports both the detection of design patterns and software architecture reconstruction activities through the use of basic elements and metrics that are mechanically extracted from the source code. The development of this platform is mainly based on the exploitation of the Eclipse framework and plug-ins as well as of different Java libraries for data access and graph management and visualization. In this paper we focus our attention on the design pattern detection process
On the one hand, design patterns are solutions to recurring design problems,
aimed at increasing ... more On the one hand, design patterns are solutions to recurring design problems, aimed at increasing reuse, flexibility, and maintainability. However, much prior work found that some patterns, such as the Observer and Singleton, are correlated with large code structures and argued that they are more likely to be fault prone. On the other hand, anti-patterns describe poor solutions to design and implementation problems that highlight weaknesses in the design of software systems and that may slow down maintenance and increase the risk of faults. They have been found to negatively impact change and fault-proneness. Classes participating in design patterns and anti-patterns have dependencies with other classes, e.g., static and co-change dependencies, that may propagate problems to other classes. We investigate the impact of such dependencies in object-oriented systems by studying the relations between the presence of static and co-change dependencies and (1) the fault-proneness, (2) the types of changes, and (3) the types of faults that these classes exhibit. We analyze six design patterns and 10 anti-patterns in 39 releases of ArgoUML, JFreeChart, and XercesJ, and investigate to what extent classes having dependencies with design patterns or antipatterns have higher odds of faults than other classes
Long-living software systems are sustainable if they can be
cost-efficiently maintained and evolv... more Long-living software systems are sustainable if they can be cost-efficiently maintained and evolved over their entire lifecycle. The quality of software architectures determines sustainability to a large extent. Scenario-based software architecture evaluation methods can support sustainability analysis, but they are still reluctantly used in practice. They are also not integrated with architecture-level metrics when evaluating implemented systems, which limits their capabilities. Existing literature reviews for architecture evaluation focus on scenario-based methods, but do not provide a critical reflection of the applicability of such methods for sustainability evaluation. Our goal is to measure the sustainability of a software architecture both during early design using scenarios and during evolution using scenarios and metrics, which is highly relevant in practice. We thus provide a systematic literature review assessing scenario-based methods for sustainability support and categorize more than 40 architecture-level metrics according to several design principles. Our review identifies a need for further empirical research, for the integration of existing methods, and for the more efficient use of formal architectural models.
Code and design smells are poor solutions to recurring
implementation and design problems. They m... more Code and design smells are poor solutions to recurring implementation and design problems. They may hinder the evolution of a system by making it hard for software engineers to carry out changes. We propose three contributions to the research field related to code and design smells: (1) DECOR, a method that embodies and defines all the steps necessary for the specification and detection of code and design smells; (2) DETEX, a detection technique that instantiates this method; and (3) an empirical validation in terms of precision and recall of DETEX. The originality of DETEX stems from the ability for software engineers to specify smells at a high-level of abstraction using a consistent vocabulary and domain-specific language for automatically generating detection algorithms. Using DETEX, we specify four well-known design smells: the antipatterns Blob, Functional Decomposition, Spaghetti Code, and Swiss Army Knife, and their 15 underlying code smells, and we automatically generate their detection algorithms. We apply and validate the detection algorithms in terms of precision and recall on XERCES v2.7.0, and discuss the precision of these algorithms on 11 opensource systems.
The presence of code and design smells can have
a severe impact on the quality of a program. Cons... more The presence of code and design smells can have a severe impact on the quality of a program. Consequently, their detection and correction have drawn the attention of both researchers and practitioners who have proposed various approaches to detect code and design smells in programs. However, none of these approaches handle the inherent uncertainty of the detection process. We propose a Bayesian approach to manage this uncertainty. First, we present a systematic process to convert existing state-of-the-art detection rules into a probabilistic model. We illustrate this process by generating a model to detect occurrences of the Blob antipattern. Second, we present results of the validation of the model: we built this model on two open-source programs, GanttProject v1.10.2 and Xerces v2.7.0, and measured its accuracy. Third, we compare our model with another approach to show that it returns the same candidate classes while ordering them to minimise the quality analysts’ effort. Finally, we show that when past detection results are available, our model can be calibrated using machine learning techniques to offer an improved, context-specific detection.
Code smells represent symptoms of poor implementation
choices. Previous studies found that these ... more Code smells represent symptoms of poor implementation choices. Previous studies found that these smells make source code more difficult to maintain, possibly also increasing its fault-proneness. There are several approaches that identify smells based on code analysis techniques. However, we observe that many code smells are intrinsically characterized by how code elements change over time. Thus, relying solely on structural information may not be sufficient to detect all the smells accurately. We propose an approach to detect five different code smells, namely Divergent Change, Shotgun Surgery, Parallel Inheritance, Blob, and Feature Envy, by exploiting change history information mined from versioning systems. We applied approach, coined as HIST (Historical Information for Smell deTection), to eight software projects written in Java, and wherever possible compared with existing state-of-the-art smell detectors based on source code analysis. The results indicate that HIST’s precision ranges between 61% and 80%, and its recall ranges between 61% and 100%. More importantly, the results confirm that HIST is able to identify code smells that cannot
This paper presents Clio, an approach that detects modularity
violations, which can cause softwar... more This paper presents Clio, an approach that detects modularity violations, which can cause software defects, modularity decay, or expensive refactorings. Clio computes the discrepancies between how components should change together based on the modular structure, and how components actually change together as revealed in version history. We evaluated Clio using 15 releases of Hadoop Common and 10 releases of Eclipse JDT. The results show that hundreds of violations identified using Clio were indeed recognized as design problems or refactored by the developers in later versions. The identified violations exhibit multiple symptoms of poor design, some of which are not easily detectable using existing approaches.
In order to support the maintenance of an objectoriented
software system, the quality of its desi... more In order to support the maintenance of an objectoriented software system, the quality of its design must be evaluated using adequate quantification means. In spite of the current extensive use of metrics, if used in isolation metrics are oftentimes too fine grained to quantify comprehensively an investigated design aspect (e.g., distribution of system’s intelligence among classes). To help developers and maintainers detect and localize design problems in a system, we propose a novel mechanism – called detection strategy – for formulating metrics-based rules that capture deviations from good design principles and heuristics. Using detection strategies an engineer can directly localize classes or methods affected by a particular design flaw (e.g., God Class), rather than having to infer the real design problem from a large set of abnormal metric values. We have defined such detection strategies for capturing around ten important flaws of object-oriented design found in the literature and validated the appr
Certain design fragments in software architectures can
have a negative impact on system maintaina... more Certain design fragments in software architectures can have a negative impact on system maintainability. Examples of such fragments include applying a design solution in an inappropriate context, mixing design fragments that have undesirable emergent behaviors, and applying design abstractions at the wrong level of granularity. In this paper, we introduce the concept of architectural “bad smells,” which are frequently recurring software designs that can have non-obvious and significant detrimental effects on system lifecycle properties, such as understandability, testability, extensibility, and reusability. We define architectural smells and differentiate them from related concepts, such as architectural antipatterns and code smells. We also describe in detail a set of four representative architectural smells we encountered in the context of reverse-engineering and re-engineering two large industrial systems and from our search through case studies in research literature. For each of these architectural smells, we provide illustrative examples and demonstrate the impact on system lifecycle properties.
Recovering design patterns can enhance existing source
code analysis tools by bringing program un... more Recovering design patterns can enhance existing source code analysis tools by bringing program understanding to the design level. This paper presents a new, fully automated pattern detection approach. The new approach is based on our reclassification of the GoF patterns by their pattern intent. We argue that the GoF pattern catalog classifies design patterns in the forward-engineering sense; our reclassification is better suited for reverse engineering. Our approach uses lightweight static program analysis techniques to capture program intent. This paper also describes our tool, PINOT, that implements this new approach. PINOT detects all the GoF patterns that have concrete definitions driven by code structure or system behavior. Our tool is faster, more accurate, and targets more patterns than existing pattern detection tools. PINOT has been used successfully in detecting patterns in Java AWT, JHotDraw, Swing, Apache Ant, and many other programs and packages.
Design patterns are micro architectures that have proved
to be reliable, easy-to implement and ro... more Design patterns are micro architectures that have proved to be reliable, easy-to implement and robust. There is a need in science and industry for recognizing these patterns. We present a new method for discovering design patterns in the source code. This method provides a precise specification of how the patterns work by describing basic structural information like inheritance, composition, aggregation and association, and as an indispensable part, by defining call delegation, object creation and operation overriding. We introduce a new XML–based language, the Design Pattern Markup Language (DPML), which provides an easy way for the users to modify pattern descriptions to suit their needs, or even to define their own patterns or just classes in certain relations they wish to find. We tested our method on four open-source systems, and found it effective in discovering design pattern instances.
Software defects often lead to bugs, runtime errors and software maintenance
difficulties. They s... more Software defects often lead to bugs, runtime errors and software maintenance difficulties. They should be systematically prevented, found, removed or fixed all along the software lifecycle. However, detecting and fixing these defects is still, to some extent, a difficult, time-consuming and manual process. In this paper, we propose a two-step automated approach to detect and then to correct various types of maintainability defects in source code. Using Genetic Programming, our approach allows automatic generation of rules to detect defects, thus relieving the designer from a fastidious manual rule definition task. Then, we correct the detected defects while minimizing the correction effort. A correction solution is de- fined as the combination of refactoring operations that should maximize as much as possible the number of corrected defects with minimal code modification effort. We use the Non-dominated Sorting Genetic Algorithm (NSGA-II) to find the best compromise. For six open source projects, we succeeded in detecting the majority of known defects, and the proposed corrections fixed most of them with minimal effort
The identification of design patterns as part of the reengineering process can convey important i... more The identification of design patterns as part of the reengineering process can convey important information to the designer. However, existing pattern detection methodologies generally have problems in dealing with one or more of the following issues: Identification of modified pattern versions, search space explosion for large systems and extensibility to novel patterns. In this paper, a design pattern detection methodology is proposed that is based on similarity scoring between graph vertices. Due to the nature of the underlying graph algorithm, this approach has the ability to also recognize patterns that are modified from their standard representation. Moreover, the approach exploits the fact that patterns reside in one or more inheritance hierarchies, reducing the size of the graphs to which the algorithm is applied. Finally, the algorithm does not rely on any pattern-specific heuristic, facilitating the extension to novel design structures. Evaluation on three open-source projects demonstrated the accuracy and the efficiency of the proposed method.
Software architecture describes the structure of a system, enabling more effective design, progra... more Software architecture describes the structure of a system, enabling more effective design, program understanding, and formal analysis. However, existing approaches decouple implementation code from architecture, allowing inconsistencies, causing confusion, violating architectural properties, and inhibiting software evolution. ArchJava is an extension to Java that seamlessly unifies software architecture with implementation,
ensuring that the implementation conforms to architectural
constraints. A case study applying ArchJava to a circuit-design
application suggests that ArchJava can express architectural
structure effectively within an implementation, and that it can aid in program understanding and software evolution.
Knowledge management technologies have been employed across software engineering activities
for m... more Knowledge management technologies have been employed across software engineering activities for more than two decades. Knowledge-based approaches can be used to facilitate software architecting activities (e.g., architectural evaluation). However, there is no comprehensive understanding on how various knowledge-based approaches (e.g., knowledge reuse) are employed in software architecture. Objective: This work aims to collect studies on the application of knowledge-based approaches in software architecture and make a classification and thematic analysis on these studies, in order to identify the gaps in the existing application of knowledge-based approaches to various architecting activities, and promising research directions.
Charmy is a framework for designing and validating architectural
specifications. In the early sta... more Charmy is a framework for designing and validating architectural specifications. In the early stages of the software development process, the Charmy framework assists the software architect in the design and validation phases. To increase its usability in an industrial context, the tool allows the use of UML-like notations to graphically design the system. Once the design is done, a formal prototype is automatically created for simulation and analysis purposes. The framework provides extensibility mechanisms to enable the introduction of new design and analysis features
Introduced in the early stages of software development, the CHARMY framework assists the software... more Introduced in the early stages of software development, the CHARMY framework assists the software architect in making
and evaluating architectural choices. Rarely, the software architecture of a system can be established once and forever. Most likely poorly defined and understood architectural constraints and requirements force the software architect to accept ambiguities and move
forward to the construction of a suboptimal software architecture. CHARMY aims to provide an easy and practical tool for supporting the iterative modeling and evaluation of software architectures. From an UML-based architectural design, an executable prototype is automatically created. CHARMY simulation and model checking features help in understanding the functioning of the system and discovering potential inconsistencies of the design. When a satisfactory and stable software architecture is reached, Java code conforming to structural software architecture constraints is automatically generated through suitable transformations. The overall approach is tool supported.
In the last 15 years, software architecture has emerged as an important field of software enginee... more In the last 15 years, software architecture has emerged as an important field of software engineering for managing the development and maintenance of large, software-intensive systems.
We compare five industrial software architecture design methods and we extract from their commona... more We compare five industrial software architecture design methods and we extract from their commonalities a general software architecture design approach. Using this general approach, we compare across the five methods the artifacts and activities they use or recommend, and we pinpoint similarities and differences. Once we get beyond the great variance in terminology and description, we find that the five approaches have a lot in common and match more or less the ''ideal'' pattern we introduced. From the ideal pattern we derive an evaluation grid that can be used for further method comparisons.
It is well known that software maintenance and evolution are expensive activities, both in
terms ... more It is well known that software maintenance and evolution are expensive activities, both in terms of invested time and money. Reverse engineering activities support the obtainment of abstractions and views from a target system that should help the engineers to maintain, evolve and eventually re-engineer it. Two important tasks pursued by reverse engineering are design pattern detection and software architecture reconstruction, whose main objectives are the identification of the design patterns that have been used in the implementation of a system as well as the generation of views placed at different levels of abstractions, which let the practitioners focus on the overall architecture of the system without worrying about the programming details it has been implemented with. In this context we propose an Eclipse plug-in called MARPLE (Metrics and Architecture Reconstruction Plug-in for Eclipse), which supports both the detection of design patterns and software architecture reconstruction activities through the use of basic elements and metrics that are mechanically extracted from the source code. The development of this platform is mainly based on the exploitation of the Eclipse framework and plug-ins as well as of different Java libraries for data access and graph management and visualization. In this paper we focus our attention on the design pattern detection process
On the one hand, design patterns are solutions to recurring design problems,
aimed at increasing ... more On the one hand, design patterns are solutions to recurring design problems, aimed at increasing reuse, flexibility, and maintainability. However, much prior work found that some patterns, such as the Observer and Singleton, are correlated with large code structures and argued that they are more likely to be fault prone. On the other hand, anti-patterns describe poor solutions to design and implementation problems that highlight weaknesses in the design of software systems and that may slow down maintenance and increase the risk of faults. They have been found to negatively impact change and fault-proneness. Classes participating in design patterns and anti-patterns have dependencies with other classes, e.g., static and co-change dependencies, that may propagate problems to other classes. We investigate the impact of such dependencies in object-oriented systems by studying the relations between the presence of static and co-change dependencies and (1) the fault-proneness, (2) the types of changes, and (3) the types of faults that these classes exhibit. We analyze six design patterns and 10 anti-patterns in 39 releases of ArgoUML, JFreeChart, and XercesJ, and investigate to what extent classes having dependencies with design patterns or antipatterns have higher odds of faults than other classes
Long-living software systems are sustainable if they can be
cost-efficiently maintained and evolv... more Long-living software systems are sustainable if they can be cost-efficiently maintained and evolved over their entire lifecycle. The quality of software architectures determines sustainability to a large extent. Scenario-based software architecture evaluation methods can support sustainability analysis, but they are still reluctantly used in practice. They are also not integrated with architecture-level metrics when evaluating implemented systems, which limits their capabilities. Existing literature reviews for architecture evaluation focus on scenario-based methods, but do not provide a critical reflection of the applicability of such methods for sustainability evaluation. Our goal is to measure the sustainability of a software architecture both during early design using scenarios and during evolution using scenarios and metrics, which is highly relevant in practice. We thus provide a systematic literature review assessing scenario-based methods for sustainability support and categorize more than 40 architecture-level metrics according to several design principles. Our review identifies a need for further empirical research, for the integration of existing methods, and for the more efficient use of formal architectural models.
Code and design smells are poor solutions to recurring
implementation and design problems. They m... more Code and design smells are poor solutions to recurring implementation and design problems. They may hinder the evolution of a system by making it hard for software engineers to carry out changes. We propose three contributions to the research field related to code and design smells: (1) DECOR, a method that embodies and defines all the steps necessary for the specification and detection of code and design smells; (2) DETEX, a detection technique that instantiates this method; and (3) an empirical validation in terms of precision and recall of DETEX. The originality of DETEX stems from the ability for software engineers to specify smells at a high-level of abstraction using a consistent vocabulary and domain-specific language for automatically generating detection algorithms. Using DETEX, we specify four well-known design smells: the antipatterns Blob, Functional Decomposition, Spaghetti Code, and Swiss Army Knife, and their 15 underlying code smells, and we automatically generate their detection algorithms. We apply and validate the detection algorithms in terms of precision and recall on XERCES v2.7.0, and discuss the precision of these algorithms on 11 opensource systems.
The presence of code and design smells can have
a severe impact on the quality of a program. Cons... more The presence of code and design smells can have a severe impact on the quality of a program. Consequently, their detection and correction have drawn the attention of both researchers and practitioners who have proposed various approaches to detect code and design smells in programs. However, none of these approaches handle the inherent uncertainty of the detection process. We propose a Bayesian approach to manage this uncertainty. First, we present a systematic process to convert existing state-of-the-art detection rules into a probabilistic model. We illustrate this process by generating a model to detect occurrences of the Blob antipattern. Second, we present results of the validation of the model: we built this model on two open-source programs, GanttProject v1.10.2 and Xerces v2.7.0, and measured its accuracy. Third, we compare our model with another approach to show that it returns the same candidate classes while ordering them to minimise the quality analysts’ effort. Finally, we show that when past detection results are available, our model can be calibrated using machine learning techniques to offer an improved, context-specific detection.
Code smells represent symptoms of poor implementation
choices. Previous studies found that these ... more Code smells represent symptoms of poor implementation choices. Previous studies found that these smells make source code more difficult to maintain, possibly also increasing its fault-proneness. There are several approaches that identify smells based on code analysis techniques. However, we observe that many code smells are intrinsically characterized by how code elements change over time. Thus, relying solely on structural information may not be sufficient to detect all the smells accurately. We propose an approach to detect five different code smells, namely Divergent Change, Shotgun Surgery, Parallel Inheritance, Blob, and Feature Envy, by exploiting change history information mined from versioning systems. We applied approach, coined as HIST (Historical Information for Smell deTection), to eight software projects written in Java, and wherever possible compared with existing state-of-the-art smell detectors based on source code analysis. The results indicate that HIST’s precision ranges between 61% and 80%, and its recall ranges between 61% and 100%. More importantly, the results confirm that HIST is able to identify code smells that cannot
This paper presents Clio, an approach that detects modularity
violations, which can cause softwar... more This paper presents Clio, an approach that detects modularity violations, which can cause software defects, modularity decay, or expensive refactorings. Clio computes the discrepancies between how components should change together based on the modular structure, and how components actually change together as revealed in version history. We evaluated Clio using 15 releases of Hadoop Common and 10 releases of Eclipse JDT. The results show that hundreds of violations identified using Clio were indeed recognized as design problems or refactored by the developers in later versions. The identified violations exhibit multiple symptoms of poor design, some of which are not easily detectable using existing approaches.
In order to support the maintenance of an objectoriented
software system, the quality of its desi... more In order to support the maintenance of an objectoriented software system, the quality of its design must be evaluated using adequate quantification means. In spite of the current extensive use of metrics, if used in isolation metrics are oftentimes too fine grained to quantify comprehensively an investigated design aspect (e.g., distribution of system’s intelligence among classes). To help developers and maintainers detect and localize design problems in a system, we propose a novel mechanism – called detection strategy – for formulating metrics-based rules that capture deviations from good design principles and heuristics. Using detection strategies an engineer can directly localize classes or methods affected by a particular design flaw (e.g., God Class), rather than having to infer the real design problem from a large set of abnormal metric values. We have defined such detection strategies for capturing around ten important flaws of object-oriented design found in the literature and validated the appr
Certain design fragments in software architectures can
have a negative impact on system maintaina... more Certain design fragments in software architectures can have a negative impact on system maintainability. Examples of such fragments include applying a design solution in an inappropriate context, mixing design fragments that have undesirable emergent behaviors, and applying design abstractions at the wrong level of granularity. In this paper, we introduce the concept of architectural “bad smells,” which are frequently recurring software designs that can have non-obvious and significant detrimental effects on system lifecycle properties, such as understandability, testability, extensibility, and reusability. We define architectural smells and differentiate them from related concepts, such as architectural antipatterns and code smells. We also describe in detail a set of four representative architectural smells we encountered in the context of reverse-engineering and re-engineering two large industrial systems and from our search through case studies in research literature. For each of these architectural smells, we provide illustrative examples and demonstrate the impact on system lifecycle properties.
Recovering design patterns can enhance existing source
code analysis tools by bringing program un... more Recovering design patterns can enhance existing source code analysis tools by bringing program understanding to the design level. This paper presents a new, fully automated pattern detection approach. The new approach is based on our reclassification of the GoF patterns by their pattern intent. We argue that the GoF pattern catalog classifies design patterns in the forward-engineering sense; our reclassification is better suited for reverse engineering. Our approach uses lightweight static program analysis techniques to capture program intent. This paper also describes our tool, PINOT, that implements this new approach. PINOT detects all the GoF patterns that have concrete definitions driven by code structure or system behavior. Our tool is faster, more accurate, and targets more patterns than existing pattern detection tools. PINOT has been used successfully in detecting patterns in Java AWT, JHotDraw, Swing, Apache Ant, and many other programs and packages.
Design patterns are micro architectures that have proved
to be reliable, easy-to implement and ro... more Design patterns are micro architectures that have proved to be reliable, easy-to implement and robust. There is a need in science and industry for recognizing these patterns. We present a new method for discovering design patterns in the source code. This method provides a precise specification of how the patterns work by describing basic structural information like inheritance, composition, aggregation and association, and as an indispensable part, by defining call delegation, object creation and operation overriding. We introduce a new XML–based language, the Design Pattern Markup Language (DPML), which provides an easy way for the users to modify pattern descriptions to suit their needs, or even to define their own patterns or just classes in certain relations they wish to find. We tested our method on four open-source systems, and found it effective in discovering design pattern instances.
Software defects often lead to bugs, runtime errors and software maintenance
difficulties. They s... more Software defects often lead to bugs, runtime errors and software maintenance difficulties. They should be systematically prevented, found, removed or fixed all along the software lifecycle. However, detecting and fixing these defects is still, to some extent, a difficult, time-consuming and manual process. In this paper, we propose a two-step automated approach to detect and then to correct various types of maintainability defects in source code. Using Genetic Programming, our approach allows automatic generation of rules to detect defects, thus relieving the designer from a fastidious manual rule definition task. Then, we correct the detected defects while minimizing the correction effort. A correction solution is de- fined as the combination of refactoring operations that should maximize as much as possible the number of corrected defects with minimal code modification effort. We use the Non-dominated Sorting Genetic Algorithm (NSGA-II) to find the best compromise. For six open source projects, we succeeded in detecting the majority of known defects, and the proposed corrections fixed most of them with minimal effort
The identification of design patterns as part of the reengineering process can convey important i... more The identification of design patterns as part of the reengineering process can convey important information to the designer. However, existing pattern detection methodologies generally have problems in dealing with one or more of the following issues: Identification of modified pattern versions, search space explosion for large systems and extensibility to novel patterns. In this paper, a design pattern detection methodology is proposed that is based on similarity scoring between graph vertices. Due to the nature of the underlying graph algorithm, this approach has the ability to also recognize patterns that are modified from their standard representation. Moreover, the approach exploits the fact that patterns reside in one or more inheritance hierarchies, reducing the size of the graphs to which the algorithm is applied. Finally, the algorithm does not rely on any pattern-specific heuristic, facilitating the extension to novel design structures. Evaluation on three open-source projects demonstrated the accuracy and the efficiency of the proposed method.
Software architecture describes the structure of a system, enabling more effective design, progra... more Software architecture describes the structure of a system, enabling more effective design, program understanding, and formal analysis. However, existing approaches decouple implementation code from architecture, allowing inconsistencies, causing confusion, violating architectural properties, and inhibiting software evolution. ArchJava is an extension to Java that seamlessly unifies software architecture with implementation,
ensuring that the implementation conforms to architectural
constraints. A case study applying ArchJava to a circuit-design
application suggests that ArchJava can express architectural
structure effectively within an implementation, and that it can aid in program understanding and software evolution.
Knowledge management technologies have been employed across software engineering activities
for m... more Knowledge management technologies have been employed across software engineering activities for more than two decades. Knowledge-based approaches can be used to facilitate software architecting activities (e.g., architectural evaluation). However, there is no comprehensive understanding on how various knowledge-based approaches (e.g., knowledge reuse) are employed in software architecture. Objective: This work aims to collect studies on the application of knowledge-based approaches in software architecture and make a classification and thematic analysis on these studies, in order to identify the gaps in the existing application of knowledge-based approaches to various architecting activities, and promising research directions.
Charmy is a framework for designing and validating architectural
specifications. In the early sta... more Charmy is a framework for designing and validating architectural specifications. In the early stages of the software development process, the Charmy framework assists the software architect in the design and validation phases. To increase its usability in an industrial context, the tool allows the use of UML-like notations to graphically design the system. Once the design is done, a formal prototype is automatically created for simulation and analysis purposes. The framework provides extensibility mechanisms to enable the introduction of new design and analysis features
Introduced in the early stages of software development, the CHARMY framework assists the software... more Introduced in the early stages of software development, the CHARMY framework assists the software architect in making
and evaluating architectural choices. Rarely, the software architecture of a system can be established once and forever. Most likely poorly defined and understood architectural constraints and requirements force the software architect to accept ambiguities and move
forward to the construction of a suboptimal software architecture. CHARMY aims to provide an easy and practical tool for supporting the iterative modeling and evaluation of software architectures. From an UML-based architectural design, an executable prototype is automatically created. CHARMY simulation and model checking features help in understanding the functioning of the system and discovering potential inconsistencies of the design. When a satisfactory and stable software architecture is reached, Java code conforming to structural software architecture constraints is automatically generated through suitable transformations. The overall approach is tool supported.
In the last 15 years, software architecture has emerged as an important field of software enginee... more In the last 15 years, software architecture has emerged as an important field of software engineering for managing the development and maintenance of large, software-intensive systems.
We compare five industrial software architecture design methods and we extract from their commona... more We compare five industrial software architecture design methods and we extract from their commonalities a general software architecture design approach. Using this general approach, we compare across the five methods the artifacts and activities they use or recommend, and we pinpoint similarities and differences. Once we get beyond the great variance in terminology and description, we find that the five approaches have a lot in common and match more or less the ''ideal'' pattern we introduced. From the ideal pattern we derive an evaluation grid that can be used for further method comparisons.
Uploads
Papers by Asma Labadi
terms of invested time and money. Reverse engineering activities support the obtainment
of abstractions and views from a target system that should help the engineers to maintain,
evolve and eventually re-engineer it. Two important tasks pursued by reverse engineering
are design pattern detection and software architecture reconstruction, whose main objectives
are the identification of the design patterns that have been used in the implementation
of a system as well as the generation of views placed at different levels of abstractions,
which let the practitioners focus on the overall architecture of the system without worrying
about the programming details it has been implemented with.
In this context we propose an Eclipse plug-in called MARPLE (Metrics and Architecture
Reconstruction Plug-in for Eclipse), which supports both the detection of design patterns
and software architecture reconstruction activities through the use of basic elements and
metrics that are mechanically extracted from the source code. The development of this
platform is mainly based on the exploitation of the Eclipse framework and plug-ins as well
as of different Java libraries for data access and graph management and visualization. In
this paper we focus our attention on the design pattern detection process
aimed at increasing reuse, flexibility, and maintainability. However, much prior work found
that some patterns, such as the Observer and Singleton, are correlated with large code structures
and argued that they are more likely to be fault prone. On the other hand, anti-patterns
describe poor solutions to design and implementation problems that highlight weaknesses
in the design of software systems and that may slow down maintenance and increase the risk
of faults. They have been found to negatively impact change and fault-proneness. Classes
participating in design patterns and anti-patterns have dependencies with other classes, e.g.,
static and co-change dependencies, that may propagate problems to other classes. We investigate
the impact of such dependencies in object-oriented systems by studying the relations
between the presence of static and co-change dependencies and (1) the fault-proneness, (2)
the types of changes, and (3) the types of faults that these classes exhibit. We analyze six
design patterns and 10 anti-patterns in 39 releases of ArgoUML, JFreeChart, and XercesJ,
and investigate to what extent classes having dependencies with design patterns or antipatterns
have higher odds of faults than other classes
cost-efficiently maintained and evolved over their entire lifecycle.
The quality of software architectures determines sustainability
to a large extent. Scenario-based software architecture
evaluation methods can support sustainability analysis,
but they are still reluctantly used in practice. They
are also not integrated with architecture-level metrics when
evaluating implemented systems, which limits their capabilities.
Existing literature reviews for architecture evaluation
focus on scenario-based methods, but do not provide a critical
reflection of the applicability of such methods for sustainability
evaluation. Our goal is to measure the sustainability
of a software architecture both during early design using
scenarios and during evolution using scenarios and metrics,
which is highly relevant in practice. We thus provide a
systematic literature review assessing scenario-based methods
for sustainability support and categorize more than 40
architecture-level metrics according to several design principles.
Our review identifies a need for further empirical
research, for the integration of existing methods, and for
the more efficient use of formal architectural models.
implementation and design problems. They may hinder the
evolution of a system by making it hard for software engineers
to carry out changes. We propose three contributions to the
research field related to code and design smells: (1) DECOR,
a method that embodies and defines all the steps necessary for
the specification and detection of code and design smells; (2)
DETEX, a detection technique that instantiates this method; and
(3) an empirical validation in terms of precision and recall of
DETEX. The originality of DETEX stems from the ability for
software engineers to specify smells at a high-level of abstraction
using a consistent vocabulary and domain-specific language for
automatically generating detection algorithms. Using DETEX, we
specify four well-known design smells: the antipatterns Blob,
Functional Decomposition, Spaghetti Code, and Swiss Army
Knife, and their 15 underlying code smells, and we automatically
generate their detection algorithms. We apply and validate the
detection algorithms in terms of precision and recall on XERCES
v2.7.0, and discuss the precision of these algorithms on 11 opensource
systems.
a severe impact on the quality of a program. Consequently,
their detection and correction have drawn
the attention of both researchers and practitioners who
have proposed various approaches to detect code and
design smells in programs. However, none of these
approaches handle the inherent uncertainty of the detection
process. We propose a Bayesian approach to
manage this uncertainty. First, we present a systematic
process to convert existing state-of-the-art detection
rules into a probabilistic model. We illustrate this
process by generating a model to detect occurrences of
the Blob antipattern. Second, we present results of the
validation of the model: we built this model on two
open-source programs, GanttProject v1.10.2 and Xerces
v2.7.0, and measured its accuracy. Third, we compare
our model with another approach to show that it returns
the same candidate classes while ordering them to minimise
the quality analysts’ effort. Finally, we show that
when past detection results are available, our model can
be calibrated using machine learning techniques to offer
an improved, context-specific detection.
choices. Previous studies found that these smells make
source code more difficult to maintain, possibly also increasing
its fault-proneness. There are several approaches that identify
smells based on code analysis techniques. However, we observe
that many code smells are intrinsically characterized by how code
elements change over time. Thus, relying solely on structural
information may not be sufficient to detect all the smells
accurately.
We propose an approach to detect five different code smells,
namely Divergent Change, Shotgun Surgery, Parallel Inheritance,
Blob, and Feature Envy, by exploiting change history information
mined from versioning systems. We applied approach, coined as
HIST (Historical Information for Smell deTection), to eight software
projects written in Java, and wherever possible compared
with existing state-of-the-art smell detectors based on source
code analysis. The results indicate that HIST’s precision ranges
between 61% and 80%, and its recall ranges between 61% and
100%. More importantly, the results confirm that HIST is able to
identify code smells that cannot
violations, which can cause software defects, modularity
decay, or expensive refactorings. Clio computes the discrepancies
between how components should change together
based on the modular structure, and how components actually
change together as revealed in version history. We
evaluated Clio using 15 releases of Hadoop Common and
10 releases of Eclipse JDT. The results show that hundreds
of violations identified using Clio were indeed recognized as
design problems or refactored by the developers in later versions.
The identified violations exhibit multiple symptoms
of poor design, some of which are not easily detectable using
existing approaches.
software system, the quality of its design must be
evaluated using adequate quantification means. In spite of
the current extensive use of metrics, if used in isolation metrics
are oftentimes too fine grained to quantify comprehensively
an investigated design aspect (e.g., distribution
of system’s intelligence among classes). To help developers
and maintainers detect and localize design problems
in a system, we propose a novel mechanism – called detection
strategy – for formulating metrics-based rules that
capture deviations from good design principles and heuristics.
Using detection strategies an engineer can directly
localize classes or methods affected by a particular design
flaw (e.g., God Class), rather than having to infer
the real design problem from a large set of abnormal metric
values. We have defined such detection strategies for
capturing around ten important flaws of object-oriented design
found in the literature and validated the appr
have a negative impact on system maintainability. Examples
of such fragments include applying a design solution
in an inappropriate context, mixing design fragments that
have undesirable emergent behaviors, and applying design
abstractions at the wrong level of granularity. In this paper,
we introduce the concept of architectural “bad smells,”
which are frequently recurring software designs that can
have non-obvious and significant detrimental effects on system
lifecycle properties, such as understandability, testability,
extensibility, and reusability. We define architectural
smells and differentiate them from related concepts, such
as architectural antipatterns and code smells. We also describe
in detail a set of four representative architectural
smells we encountered in the context of reverse-engineering
and re-engineering two large industrial systems and from
our search through case studies in research literature. For
each of these architectural smells, we provide illustrative
examples and demonstrate the impact on system lifecycle
properties.
code analysis tools by bringing program understanding to
the design level. This paper presents a new, fully automated
pattern detection approach. The new approach is based on
our reclassification of the GoF patterns by their pattern intent.
We argue that the GoF pattern catalog classifies design
patterns in the forward-engineering sense; our reclassification
is better suited for reverse engineering. Our approach
uses lightweight static program analysis techniques
to capture program intent. This paper also describes our
tool, PINOT, that implements this new approach. PINOT
detects all the GoF patterns that have concrete definitions
driven by code structure or system behavior. Our tool is
faster, more accurate, and targets more patterns than existing
pattern detection tools. PINOT has been used successfully
in detecting patterns in Java AWT, JHotDraw, Swing,
Apache Ant, and many other programs and packages.
to be reliable, easy-to implement and robust. There is a
need in science and industry for recognizing these patterns.
We present a new method for discovering design patterns in
the source code. This method provides a precise specification
of how the patterns work by describing basic structural
information like inheritance, composition, aggregation and
association, and as an indispensable part, by defining call
delegation, object creation and operation overriding. We
introduce a new XML–based language, the Design Pattern
Markup Language (DPML), which provides an easy way for
the users to modify pattern descriptions to suit their needs,
or even to define their own patterns or just classes in certain
relations they wish to find. We tested our method on
four open-source systems, and found it effective in discovering
design pattern instances.
difficulties. They should be systematically prevented, found, removed or
fixed all along the software lifecycle. However, detecting and fixing these defects
is still, to some extent, a difficult, time-consuming and manual process. In this paper,
we propose a two-step automated approach to detect and then to correct various
types of maintainability defects in source code. Using Genetic Programming,
our approach allows automatic generation of rules to detect defects, thus relieving
the designer from a fastidious manual rule definition task. Then, we correct the detected
defects while minimizing the correction effort. A correction solution is de-
fined as the combination of refactoring operations that should maximize as much
as possible the number of corrected defects with minimal code modification effort.
We use the Non-dominated Sorting Genetic Algorithm (NSGA-II) to find the best
compromise. For six open source projects, we succeeded in detecting the majority
of known defects, and the proposed corrections fixed most of them with minimal
effort
However, existing pattern detection methodologies generally have problems in dealing with one or more of the following issues:
Identification of modified pattern versions, search space explosion for large systems and extensibility to novel patterns. In this paper, a design pattern detection methodology is proposed that is based on similarity scoring between graph vertices. Due to the nature of the underlying graph algorithm, this approach has the ability to also recognize patterns that are modified from their standard representation. Moreover, the approach exploits the fact that patterns reside in one or more inheritance hierarchies, reducing the size of the graphs to which the algorithm is applied. Finally, the algorithm does not rely on any pattern-specific heuristic, facilitating the extension to novel design structures. Evaluation on three open-source projects demonstrated the accuracy and the efficiency of the proposed method.
ensuring that the implementation conforms to architectural
constraints. A case study applying ArchJava to a circuit-design
application suggests that ArchJava can express architectural
structure effectively within an implementation, and that it can aid in program understanding and software evolution.
for more than two decades. Knowledge-based approaches can be used to facilitate software architecting
activities (e.g., architectural evaluation). However, there is no comprehensive understanding on how
various knowledge-based approaches (e.g., knowledge reuse) are employed in software architecture.
Objective: This work aims to collect studies on the application of knowledge-based approaches in software
architecture and make a classification and thematic analysis on these studies, in order to identify
the gaps in the existing application of knowledge-based approaches to various architecting activities,
and promising research directions.
specifications. In the early stages of the software
development process, the Charmy framework assists
the software architect in the design and validation phases.
To increase its usability in an industrial context, the tool
allows the use of UML-like notations to graphically design
the system. Once the design is done, a formal prototype is
automatically created for simulation and analysis purposes.
The framework provides extensibility mechanisms to enable
the introduction of new design and analysis features
and evaluating architectural choices. Rarely, the software architecture of a system can be established once and forever. Most likely poorly defined and understood architectural constraints and requirements force the software architect to accept ambiguities and move
forward to the construction of a suboptimal software architecture. CHARMY aims to provide an easy and practical tool for supporting the iterative modeling and evaluation of software architectures. From an UML-based architectural design, an executable prototype is automatically created. CHARMY simulation and model checking features help in understanding the functioning of the system and discovering potential inconsistencies of the design. When a satisfactory and stable software architecture is reached, Java code conforming to structural software architecture constraints is automatically generated through suitable transformations. The overall approach is tool supported.
terms of invested time and money. Reverse engineering activities support the obtainment
of abstractions and views from a target system that should help the engineers to maintain,
evolve and eventually re-engineer it. Two important tasks pursued by reverse engineering
are design pattern detection and software architecture reconstruction, whose main objectives
are the identification of the design patterns that have been used in the implementation
of a system as well as the generation of views placed at different levels of abstractions,
which let the practitioners focus on the overall architecture of the system without worrying
about the programming details it has been implemented with.
In this context we propose an Eclipse plug-in called MARPLE (Metrics and Architecture
Reconstruction Plug-in for Eclipse), which supports both the detection of design patterns
and software architecture reconstruction activities through the use of basic elements and
metrics that are mechanically extracted from the source code. The development of this
platform is mainly based on the exploitation of the Eclipse framework and plug-ins as well
as of different Java libraries for data access and graph management and visualization. In
this paper we focus our attention on the design pattern detection process
aimed at increasing reuse, flexibility, and maintainability. However, much prior work found
that some patterns, such as the Observer and Singleton, are correlated with large code structures
and argued that they are more likely to be fault prone. On the other hand, anti-patterns
describe poor solutions to design and implementation problems that highlight weaknesses
in the design of software systems and that may slow down maintenance and increase the risk
of faults. They have been found to negatively impact change and fault-proneness. Classes
participating in design patterns and anti-patterns have dependencies with other classes, e.g.,
static and co-change dependencies, that may propagate problems to other classes. We investigate
the impact of such dependencies in object-oriented systems by studying the relations
between the presence of static and co-change dependencies and (1) the fault-proneness, (2)
the types of changes, and (3) the types of faults that these classes exhibit. We analyze six
design patterns and 10 anti-patterns in 39 releases of ArgoUML, JFreeChart, and XercesJ,
and investigate to what extent classes having dependencies with design patterns or antipatterns
have higher odds of faults than other classes
cost-efficiently maintained and evolved over their entire lifecycle.
The quality of software architectures determines sustainability
to a large extent. Scenario-based software architecture
evaluation methods can support sustainability analysis,
but they are still reluctantly used in practice. They
are also not integrated with architecture-level metrics when
evaluating implemented systems, which limits their capabilities.
Existing literature reviews for architecture evaluation
focus on scenario-based methods, but do not provide a critical
reflection of the applicability of such methods for sustainability
evaluation. Our goal is to measure the sustainability
of a software architecture both during early design using
scenarios and during evolution using scenarios and metrics,
which is highly relevant in practice. We thus provide a
systematic literature review assessing scenario-based methods
for sustainability support and categorize more than 40
architecture-level metrics according to several design principles.
Our review identifies a need for further empirical
research, for the integration of existing methods, and for
the more efficient use of formal architectural models.
implementation and design problems. They may hinder the
evolution of a system by making it hard for software engineers
to carry out changes. We propose three contributions to the
research field related to code and design smells: (1) DECOR,
a method that embodies and defines all the steps necessary for
the specification and detection of code and design smells; (2)
DETEX, a detection technique that instantiates this method; and
(3) an empirical validation in terms of precision and recall of
DETEX. The originality of DETEX stems from the ability for
software engineers to specify smells at a high-level of abstraction
using a consistent vocabulary and domain-specific language for
automatically generating detection algorithms. Using DETEX, we
specify four well-known design smells: the antipatterns Blob,
Functional Decomposition, Spaghetti Code, and Swiss Army
Knife, and their 15 underlying code smells, and we automatically
generate their detection algorithms. We apply and validate the
detection algorithms in terms of precision and recall on XERCES
v2.7.0, and discuss the precision of these algorithms on 11 opensource
systems.
a severe impact on the quality of a program. Consequently,
their detection and correction have drawn
the attention of both researchers and practitioners who
have proposed various approaches to detect code and
design smells in programs. However, none of these
approaches handle the inherent uncertainty of the detection
process. We propose a Bayesian approach to
manage this uncertainty. First, we present a systematic
process to convert existing state-of-the-art detection
rules into a probabilistic model. We illustrate this
process by generating a model to detect occurrences of
the Blob antipattern. Second, we present results of the
validation of the model: we built this model on two
open-source programs, GanttProject v1.10.2 and Xerces
v2.7.0, and measured its accuracy. Third, we compare
our model with another approach to show that it returns
the same candidate classes while ordering them to minimise
the quality analysts’ effort. Finally, we show that
when past detection results are available, our model can
be calibrated using machine learning techniques to offer
an improved, context-specific detection.
choices. Previous studies found that these smells make
source code more difficult to maintain, possibly also increasing
its fault-proneness. There are several approaches that identify
smells based on code analysis techniques. However, we observe
that many code smells are intrinsically characterized by how code
elements change over time. Thus, relying solely on structural
information may not be sufficient to detect all the smells
accurately.
We propose an approach to detect five different code smells,
namely Divergent Change, Shotgun Surgery, Parallel Inheritance,
Blob, and Feature Envy, by exploiting change history information
mined from versioning systems. We applied approach, coined as
HIST (Historical Information for Smell deTection), to eight software
projects written in Java, and wherever possible compared
with existing state-of-the-art smell detectors based on source
code analysis. The results indicate that HIST’s precision ranges
between 61% and 80%, and its recall ranges between 61% and
100%. More importantly, the results confirm that HIST is able to
identify code smells that cannot
violations, which can cause software defects, modularity
decay, or expensive refactorings. Clio computes the discrepancies
between how components should change together
based on the modular structure, and how components actually
change together as revealed in version history. We
evaluated Clio using 15 releases of Hadoop Common and
10 releases of Eclipse JDT. The results show that hundreds
of violations identified using Clio were indeed recognized as
design problems or refactored by the developers in later versions.
The identified violations exhibit multiple symptoms
of poor design, some of which are not easily detectable using
existing approaches.
software system, the quality of its design must be
evaluated using adequate quantification means. In spite of
the current extensive use of metrics, if used in isolation metrics
are oftentimes too fine grained to quantify comprehensively
an investigated design aspect (e.g., distribution
of system’s intelligence among classes). To help developers
and maintainers detect and localize design problems
in a system, we propose a novel mechanism – called detection
strategy – for formulating metrics-based rules that
capture deviations from good design principles and heuristics.
Using detection strategies an engineer can directly
localize classes or methods affected by a particular design
flaw (e.g., God Class), rather than having to infer
the real design problem from a large set of abnormal metric
values. We have defined such detection strategies for
capturing around ten important flaws of object-oriented design
found in the literature and validated the appr
have a negative impact on system maintainability. Examples
of such fragments include applying a design solution
in an inappropriate context, mixing design fragments that
have undesirable emergent behaviors, and applying design
abstractions at the wrong level of granularity. In this paper,
we introduce the concept of architectural “bad smells,”
which are frequently recurring software designs that can
have non-obvious and significant detrimental effects on system
lifecycle properties, such as understandability, testability,
extensibility, and reusability. We define architectural
smells and differentiate them from related concepts, such
as architectural antipatterns and code smells. We also describe
in detail a set of four representative architectural
smells we encountered in the context of reverse-engineering
and re-engineering two large industrial systems and from
our search through case studies in research literature. For
each of these architectural smells, we provide illustrative
examples and demonstrate the impact on system lifecycle
properties.
code analysis tools by bringing program understanding to
the design level. This paper presents a new, fully automated
pattern detection approach. The new approach is based on
our reclassification of the GoF patterns by their pattern intent.
We argue that the GoF pattern catalog classifies design
patterns in the forward-engineering sense; our reclassification
is better suited for reverse engineering. Our approach
uses lightweight static program analysis techniques
to capture program intent. This paper also describes our
tool, PINOT, that implements this new approach. PINOT
detects all the GoF patterns that have concrete definitions
driven by code structure or system behavior. Our tool is
faster, more accurate, and targets more patterns than existing
pattern detection tools. PINOT has been used successfully
in detecting patterns in Java AWT, JHotDraw, Swing,
Apache Ant, and many other programs and packages.
to be reliable, easy-to implement and robust. There is a
need in science and industry for recognizing these patterns.
We present a new method for discovering design patterns in
the source code. This method provides a precise specification
of how the patterns work by describing basic structural
information like inheritance, composition, aggregation and
association, and as an indispensable part, by defining call
delegation, object creation and operation overriding. We
introduce a new XML–based language, the Design Pattern
Markup Language (DPML), which provides an easy way for
the users to modify pattern descriptions to suit their needs,
or even to define their own patterns or just classes in certain
relations they wish to find. We tested our method on
four open-source systems, and found it effective in discovering
design pattern instances.
difficulties. They should be systematically prevented, found, removed or
fixed all along the software lifecycle. However, detecting and fixing these defects
is still, to some extent, a difficult, time-consuming and manual process. In this paper,
we propose a two-step automated approach to detect and then to correct various
types of maintainability defects in source code. Using Genetic Programming,
our approach allows automatic generation of rules to detect defects, thus relieving
the designer from a fastidious manual rule definition task. Then, we correct the detected
defects while minimizing the correction effort. A correction solution is de-
fined as the combination of refactoring operations that should maximize as much
as possible the number of corrected defects with minimal code modification effort.
We use the Non-dominated Sorting Genetic Algorithm (NSGA-II) to find the best
compromise. For six open source projects, we succeeded in detecting the majority
of known defects, and the proposed corrections fixed most of them with minimal
effort
However, existing pattern detection methodologies generally have problems in dealing with one or more of the following issues:
Identification of modified pattern versions, search space explosion for large systems and extensibility to novel patterns. In this paper, a design pattern detection methodology is proposed that is based on similarity scoring between graph vertices. Due to the nature of the underlying graph algorithm, this approach has the ability to also recognize patterns that are modified from their standard representation. Moreover, the approach exploits the fact that patterns reside in one or more inheritance hierarchies, reducing the size of the graphs to which the algorithm is applied. Finally, the algorithm does not rely on any pattern-specific heuristic, facilitating the extension to novel design structures. Evaluation on three open-source projects demonstrated the accuracy and the efficiency of the proposed method.
ensuring that the implementation conforms to architectural
constraints. A case study applying ArchJava to a circuit-design
application suggests that ArchJava can express architectural
structure effectively within an implementation, and that it can aid in program understanding and software evolution.
for more than two decades. Knowledge-based approaches can be used to facilitate software architecting
activities (e.g., architectural evaluation). However, there is no comprehensive understanding on how
various knowledge-based approaches (e.g., knowledge reuse) are employed in software architecture.
Objective: This work aims to collect studies on the application of knowledge-based approaches in software
architecture and make a classification and thematic analysis on these studies, in order to identify
the gaps in the existing application of knowledge-based approaches to various architecting activities,
and promising research directions.
specifications. In the early stages of the software
development process, the Charmy framework assists
the software architect in the design and validation phases.
To increase its usability in an industrial context, the tool
allows the use of UML-like notations to graphically design
the system. Once the design is done, a formal prototype is
automatically created for simulation and analysis purposes.
The framework provides extensibility mechanisms to enable
the introduction of new design and analysis features
and evaluating architectural choices. Rarely, the software architecture of a system can be established once and forever. Most likely poorly defined and understood architectural constraints and requirements force the software architect to accept ambiguities and move
forward to the construction of a suboptimal software architecture. CHARMY aims to provide an easy and practical tool for supporting the iterative modeling and evaluation of software architectures. From an UML-based architectural design, an executable prototype is automatically created. CHARMY simulation and model checking features help in understanding the functioning of the system and discovering potential inconsistencies of the design. When a satisfactory and stable software architecture is reached, Java code conforming to structural software architecture constraints is automatically generated through suitable transformations. The overall approach is tool supported.