Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913220
T. Mikkonen, Eero Liihde, Juhapekka Niemi, Marko Siiskonen
Software-intensive systems evolve. Properties embedded in them seldom benefit from this, as the modifications needed for supporting new features do not always match with software structures that originally constitute the system. This results in special cases and exceptions for intended abstractions, and consequently creates problems for the future evolution of the system. In order to improve the facilities that enable the management of the evolution of telecommunications system software, we have introduced the notion of services. The purpose of the service concept is to enable an abstract description of conceptual properties of the system disregarding their final relation to underlying software components of the implementation. Therefore, services provide a view of the system where the focus can be shifted from individual implementation components to their collaboration at varying levels of abstraction. Based on this collaboration, we then define a virtual architecture that helps in managing software evolution. We introduce the basic notion of services, and present experiences on employing the concept in practice.
{"title":"Managing software evolution with the service concept","authors":"T. Mikkonen, Eero Liihde, Juhapekka Niemi, Marko Siiskonen","doi":"10.1109/ISPSE.2000.913220","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913220","url":null,"abstract":"Software-intensive systems evolve. Properties embedded in them seldom benefit from this, as the modifications needed for supporting new features do not always match with software structures that originally constitute the system. This results in special cases and exceptions for intended abstractions, and consequently creates problems for the future evolution of the system. In order to improve the facilities that enable the management of the evolution of telecommunications system software, we have introduced the notion of services. The purpose of the service concept is to enable an abstract description of conceptual properties of the system disregarding their final relation to underlying software components of the implementation. Therefore, services provide a view of the system where the focus can be shifted from individual implementation components to their collaboration at varying levels of abstraction. Based on this collaboration, we then define a virtual architecture that helps in managing software evolution. We introduce the basic notion of services, and present experiences on employing the concept in practice.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"27 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115012892","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}
Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913226
Xiaodong Liu, Hongji Yang, H. Zedan, A. Cau
Software reengineering is an essential part of software evolution. Two important issues faced by software reengineering techniques are the time involved and the ability to cope with the scale of software systems. Unless these two issues have been addressed properly, the real use of any reengineering technique is limited. Our observation shows that these two issues mainly occur at the reverse engineering stage of reengineering, i.e., the stage to understand the existing software systems. We propose an approach to address these two issues through executable stepwise abstraction. A semi-automatic tool environment is built to abstract the target system into higher level views more quickly to improve the efficiency, and to stepwise abstract the sub-systems of the target system first and then to further abstract the higher level view of the sub-systems into the full view of the target system. Since full automation of reengineering is not possible yet, which is a well accepted view by the community, a set of abstraction patterns are developed to acquire expert observations of the target system as abstraction pattern assertions. Our approach attempts to maximise the automation with the assistance of abstraction rules and abstraction pattern assertions.
{"title":"Speed and scale up software reengineering with abstraction patterns and rules","authors":"Xiaodong Liu, Hongji Yang, H. Zedan, A. Cau","doi":"10.1109/ISPSE.2000.913226","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913226","url":null,"abstract":"Software reengineering is an essential part of software evolution. Two important issues faced by software reengineering techniques are the time involved and the ability to cope with the scale of software systems. Unless these two issues have been addressed properly, the real use of any reengineering technique is limited. Our observation shows that these two issues mainly occur at the reverse engineering stage of reengineering, i.e., the stage to understand the existing software systems. We propose an approach to address these two issues through executable stepwise abstraction. A semi-automatic tool environment is built to abstract the target system into higher level views more quickly to improve the efficiency, and to stepwise abstract the sub-systems of the target system first and then to further abstract the higher level view of the sub-systems into the full view of the target system. Since full automation of reengineering is not possible yet, which is a well accepted view by the community, a set of abstraction patterns are developed to acquire expert observations of the target system as abstraction pattern assertions. Our approach attempts to maximise the automation with the assistance of abstraction rules and abstraction pattern assertions.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"37 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"117075175","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}
Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913239
Yang Li, Hongji Yang, W. Chu
Business software systems without exception need to be evolved to cater for new/changed market requirements, or to adapt to a new operating environment. One of the most significant problems in current software evolution practice is that software maintainers usually find it quite difficult to locate the program sections in the source code which need to be modified and to identify the extent to which the changes in these program sections could affect the rest of the software system. In this paper, we propose a knowledge engineering-based approach to solving this problem. In particular, we match a software program with a pre-defined domain knowledge base in the representation of a simplified semantic network that we have proposed in order to link the source program with its domain-level interpretation. The domain knowledge base contains only important domain knowledge where potential evolutions could occur; this reduces the size of the knowledge base. Moreover, a domain-oriented program partitioning method is also proposed in order to partition a program into self-contained modules of manageable size. In these ways, the computational complexity involved in generating the linkage is significantly reduced, which makes this approach usable. An example shows that software evolution can be carried out easily as the domain knowledge that it links with evolves.
{"title":"Generating linkage between source code and evolvable domain knowledge for the ease of software evolution","authors":"Yang Li, Hongji Yang, W. Chu","doi":"10.1109/ISPSE.2000.913239","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913239","url":null,"abstract":"Business software systems without exception need to be evolved to cater for new/changed market requirements, or to adapt to a new operating environment. One of the most significant problems in current software evolution practice is that software maintainers usually find it quite difficult to locate the program sections in the source code which need to be modified and to identify the extent to which the changes in these program sections could affect the rest of the software system. In this paper, we propose a knowledge engineering-based approach to solving this problem. In particular, we match a software program with a pre-defined domain knowledge base in the representation of a simplified semantic network that we have proposed in order to link the source program with its domain-level interpretation. The domain knowledge base contains only important domain knowledge where potential evolutions could occur; this reduces the size of the knowledge base. Moreover, a domain-oriented program partitioning method is also proposed in order to partition a program into self-contained modules of manageable size. In these ways, the computational complexity involved in generating the linkage is significantly reduced, which makes this approach usable. An example shows that software evolution can be carried out easily as the domain knowledge that it links with evolves.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"1 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128731357","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}
Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913215
M. Lehman, J. F. Ramil
After years of study of software evolution processes, most recently in the FEASTprojects, it appears that there is now a sufJicient body of knowledge to provide a basis for development of a theory of software evolution rooted in axioms derived from observation. That body includes, for example, behavioural patterns and invariants in the evolutionary attributes of industrially evolved systems and the processes applied to implement them. This paper discusses the need for such a theory, underlying concepts and the contribution that a theory could make to achieving greater software evolvability and improved planning and management for effective and responsive evolution. A brief discussion of the evolution phenomenon and some of its characteristics is followed by a listing of some of the management guidelines that have arisen from recent FEAST studies. These were derived from a series of observations and inferences that suggest an initial set of axioms from which a formal theory of software evolution may be developed. The set is of interest because it is believed that, after further clarification, the set suffices for a proof of the principle of software uncertainty. As more theorems are proven their interpretation should provide guidelines for the development of evolvable software architectures and suggest rules and guidelines for software evolution planning and management. Eventually, the rules already developed by ad hoc means, together with additional rules and other good practices should be formally derivable from the emerging theory.
{"title":"Towards a theory of software evolution - and its practical impact","authors":"M. Lehman, J. F. Ramil","doi":"10.1109/ISPSE.2000.913215","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913215","url":null,"abstract":"After years of study of software evolution processes, most recently in the FEASTprojects, it appears that there is now a sufJicient body of knowledge to provide a basis for development of a theory of software evolution rooted in axioms derived from observation. That body includes, for example, behavioural patterns and invariants in the evolutionary attributes of industrially evolved systems and the processes applied to implement them. This paper discusses the need for such a theory, underlying concepts and the contribution that a theory could make to achieving greater software evolvability and improved planning and management for effective and responsive evolution. A brief discussion of the evolution phenomenon and some of its characteristics is followed by a listing of some of the management guidelines that have arisen from recent FEAST studies. These were derived from a series of observations and inferences that suggest an initial set of axioms from which a formal theory of software evolution may be developed. The set is of interest because it is believed that, after further clarification, the set suffices for a proof of the principle of software uncertainty. As more theorems are proven their interpretation should provide guidelines for the development of evolvable software architectures and suggest rules and guidelines for software evolution planning and management. Eventually, the rules already developed by ad hoc means, together with additional rules and other good practices should be formally derivable from the emerging theory.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"25 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115859448","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}
Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913241
M. Marin, T. Ida
Describes the current status of the development of CFLP (constraint functional logic programming), a system which aims at the integration of the best features of functional logic programming (FLP), cooperative constraint solving (CCS) and distributed constraint solving. FLP provides support for defining one's own abstractions (user-defined functions and predicates) over a constraint domain in an easy and comfortable way, whereas CCS is employed to solve systems of mixed constraints by iterating specialized constraint-solving methods in accordance with a well-defined strategy. CFLP is a distributed implementation of a cooperative FLP scheme obtained from the integration of higher-order lazy narrowing for FLP with CCS. The implementation takes advantage of the existence of several constraint-solving resources located in a distributed environment, which communicate asynchronously via message passing.
{"title":"Cooperative constraint functional logic programming","authors":"M. Marin, T. Ida","doi":"10.1109/ISPSE.2000.913241","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913241","url":null,"abstract":"Describes the current status of the development of CFLP (constraint functional logic programming), a system which aims at the integration of the best features of functional logic programming (FLP), cooperative constraint solving (CCS) and distributed constraint solving. FLP provides support for defining one's own abstractions (user-defined functions and predicates) over a constraint domain in an easy and comfortable way, whereas CCS is employed to solve systems of mixed constraints by iterating specialized constraint-solving methods in accordance with a well-defined strategy. CFLP is a distributed implementation of a cooperative FLP scheme obtained from the integration of higher-order lazy narrowing for FLP with CCS. The implementation takes advantage of the existence of several constraint-solving resources located in a distributed environment, which communicate asynchronously via message passing.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"237-240 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130748833","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}
Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913216
Oscar Nierstrasz, F. Achermann
Software is not just difficult to develop, it is even more difficult to maintain in the face of changing requirements. The complexity of software evolution can, however be significantly reduced if we manage to separate the stable artifacts (the "components") from their configuration (the "scripts"). We have proposed a simple, unifying framework of forms, agents, and channels for modelling components and scripts, and we have developed an experimental composition language, called Piccola, based on this framework, that supports the specification of applications as flexible compositions of stable components. We show how Piccola can be used to reduce the complexity of software evolution through the specification and use of an appropriate compositional style, and we illustrate the approach through a non-trivial example of mixin layer composition.
{"title":"Supporting compositional styles for software evolution","authors":"Oscar Nierstrasz, F. Achermann","doi":"10.1109/ISPSE.2000.913216","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913216","url":null,"abstract":"Software is not just difficult to develop, it is even more difficult to maintain in the face of changing requirements. The complexity of software evolution can, however be significantly reduced if we manage to separate the stable artifacts (the \"components\") from their configuration (the \"scripts\"). We have proposed a simple, unifying framework of forms, agents, and channels for modelling components and scripts, and we have developed an experimental composition language, called Piccola, based on this framework, that supports the specification of applications as flexible compositions of stable components. We show how Piccola can be used to reduce the complexity of software evolution through the specification and use of an appropriate compositional style, and we illustrate the approach through a non-trivial example of mixin layer composition.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"8 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133774555","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}
Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913218
W. Qiu
The component technology will promise to cope with software evolution by extending and adapting only the affected parts. It is important to ensure consistency of extended and extending components. The consistency is generally determined with respect to some desired properties. The paper concentrates on the issue of composition safety: system-wide rules must not be violated by an extension. A component dependence model is presented in the paper. Besides the interface specification, we also require the model to explicitly express the needs provided by other components. Semantically, the dependence relationship asserts that a component satisfies property P if its depended component preserves property Q. The paper shows a crucial requirement to ensure composition safety is that an extending component should enhance functionality of the extended component but weaken the dependence. The logical framework is based on refinement calculus.
{"title":"Describing consistent component extension with expression of dependence","authors":"W. Qiu","doi":"10.1109/ISPSE.2000.913218","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913218","url":null,"abstract":"The component technology will promise to cope with software evolution by extending and adapting only the affected parts. It is important to ensure consistency of extended and extending components. The consistency is generally determined with respect to some desired properties. The paper concentrates on the issue of composition safety: system-wide rules must not be violated by an extension. A component dependence model is presented in the paper. Besides the interface specification, we also require the model to explicitly express the needs provided by other components. Semantically, the dependence relationship asserts that a component satisfies property P if its depended component preserves property Q. The paper shows a crucial requirement to ensure composition safety is that an extending component should enhance functionality of the extended component but weaken the dependence. The logical framework is based on refinement calculus.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"170 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124136481","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}
Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913233
S. Tichelaar, Stéphane Ducasse, S. Demeyer, Oscar Nierstrasz
Refactoring-transforming code while preserving behaviour-is considered a key approach for improving object-oriented software systems. Unfortunately, all of the current refactoring tools depend on language-dependent refactoring engines, which prevents a smooth integration with mainstream development environments. We investigate the similarities between refactorings for Smalltalk and Java, derive a language-independent meta-model and show that it is feasible to build a language-independent refactoring engine on top of this meta-model. Our feasibility study is validated by means of a tool prototype which uses the same engine to refactor both Smalltalk and Java code. Using our approach we minimize the language-dependent part of refactoring tools, providing a standard way for programmers and tools to perform refactorings no matter what language they work in.
{"title":"A meta-model for language-independent refactoring","authors":"S. Tichelaar, Stéphane Ducasse, S. Demeyer, Oscar Nierstrasz","doi":"10.1109/ISPSE.2000.913233","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913233","url":null,"abstract":"Refactoring-transforming code while preserving behaviour-is considered a key approach for improving object-oriented software systems. Unfortunately, all of the current refactoring tools depend on language-dependent refactoring engines, which prevents a smooth integration with mainstream development environments. We investigate the similarities between refactorings for Smalltalk and Java, derive a language-independent meta-model and show that it is feasible to build a language-independent refactoring engine on top of this meta-model. Our feasibility study is validated by means of a tool prototype which uses the same engine to refactor both Smalltalk and Java code. Using our approach we minimize the language-dependent part of refactoring tools, providing a standard way for programmers and tools to perform refactorings no matter what language they work in.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"222 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"124394997","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}
Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913246
M. Takeichi, Zhenjiang Hu
Proposes a new mechanism called "calculation-carrying programs" that can relax the tension between efficiency and clarity in programming. The idea is to accompany clear programs with some calculation specifying the intention of how to manipulate the programs to be efficient. This calculation specification can be executed automatically by our compiler to derive efficient programs. As a result, each calculation-carrying program becomes a complete document, including a concise specification of the given problem, as well as an effective way to derive both efficient and correct code.
{"title":"Calculation carrying programs - how to code program transformations","authors":"M. Takeichi, Zhenjiang Hu","doi":"10.1109/ISPSE.2000.913246","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913246","url":null,"abstract":"Proposes a new mechanism called \"calculation-carrying programs\" that can relax the tension between efficiency and clarity in programming. The idea is to accompany clear programs with some calculation specifying the intention of how to manipulate the programs to be efficient. This calculation specification can be executed automatically by our compiler to derive efficient programs. As a result, each calculation-carrying program becomes a complete document, including a concise specification of the given problem, as well as an effective way to derive both efficient and correct code.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"36 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125883734","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}
Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913227
T. Kobayashi, M. Kamo, T. Sanui, M. Saeki
This paper discusses a technique to model software patterns such as Gang-OF-Four (GOF) design patterns for supporting pattern based software development. Software patterns are general structures that frequently appear in the artifacts and encourage effective reuse of past successful experience. To support pattern based software development, we model the patterns from an object-oriented view so that machine processing is possible. In our approach, we consider that a pattern consists of a pattern structure (a class diagram) and manipulation operations on the pattern structure in order to use it. These manipulations are classified into three types; pattern instantiation (applying a pattern to an actual problem, i.e. filling their hot spots), pattern combination (combining several patterns into larger one) and pattern refinement (refine a pattern into more concrete one). These manipulation operations are specific to patterns and each pattern is a class which they are encapsulated into. We describe 22 Gang-Of-Four design patterns with Java and develop a supporting tool for using patterns. The tool has been developed by using our approach itself and it shows the usefulness of our approach.
{"title":"Object-oriented modeling of software patterns","authors":"T. Kobayashi, M. Kamo, T. Sanui, M. Saeki","doi":"10.1109/ISPSE.2000.913227","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913227","url":null,"abstract":"This paper discusses a technique to model software patterns such as Gang-OF-Four (GOF) design patterns for supporting pattern based software development. Software patterns are general structures that frequently appear in the artifacts and encourage effective reuse of past successful experience. To support pattern based software development, we model the patterns from an object-oriented view so that machine processing is possible. In our approach, we consider that a pattern consists of a pattern structure (a class diagram) and manipulation operations on the pattern structure in order to use it. These manipulations are classified into three types; pattern instantiation (applying a pattern to an actual problem, i.e. filling their hot spots), pattern combination (combining several patterns into larger one) and pattern refinement (refine a pattern into more concrete one). These manipulation operations are specific to patterns and each pattern is a class which they are encapsulated into. We describe 22 Gang-Of-Four design patterns with Java and develop a supporting tool for using patterns. The tool has been developed by using our approach itself and it shows the usefulness of our approach.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"83 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2000-11-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130023372","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
扫码关注我们
求助内容：
应助结果提醒方式：