Pub Date : 2000-11-01DOI: 10.1109/ISPSE.2000.913228
M. Aoyama
Design patterns are considered well-formed language to represent software design. We propose several notions of design evolution and discuss the patterns of design evolution in terms of design patterns. First, we propose a classification of design patterns into pattern families. To model the design patterns and the evolutionary relationship between them, we propose a set of graphical notations of design patterns and their evolution, namely pattern type diagrams and pattern evolution diagrams. Then, we analyze evolutionary patterns of design within a family and across multiple families of design patterns. Based on the patterns of design evolution, we can navigate designers to select and compose design patterns for solving complex problems with design patterns. An example illustrates evolutionary design of the framework by composing design patterns.
{"title":"Evolutionary patterns of design and design patterns","authors":"M. Aoyama","doi":"10.1109/ISPSE.2000.913228","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913228","url":null,"abstract":"Design patterns are considered well-formed language to represent software design. We propose several notions of design evolution and discuss the patterns of design evolution in terms of design patterns. First, we propose a classification of design patterns into pattern families. To model the design patterns and the evolutionary relationship between them, we propose a set of graphical notations of design patterns and their evolution, namely pattern type diagrams and pattern evolution diagrams. Then, we analyze evolutionary patterns of design within a family and across multiple families of design patterns. Based on the patterns of design evolution, we can navigate designers to select and compose design patterns for solving complex problems with design patterns. An example illustrates evolutionary design of the framework by composing design patterns.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"99 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":"131629369","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.913242
S. Nishizaki
Software evolution is one of the most important features in advanced computer systems, and the significance of its theoretical study is acknowledged. Software evolution is divided into two categories: static and dynamic evolution. Static evolution involves changes in a software system that occur before compilation; a typical example is a software update. On the other hand, dynamic evolution involves changes in the execution time of a software system. The dynamic library mechanism in operating systems and dynamic class loading in Java are types of dynamic evolution. An environment represents a mapping of variables onto values. We have studied the lambda calculus with first-class environments (called the environment calculus). With this, we can treat environments as first-class citizens: environment values can be passed as parameters and returned as resultant values. The first-class environments are formalized according to the idea of explicit substitutions. This paper proposes programmable environments, as a further extension of first-class environments, which provide a computational mechanism allowing first-class environments to be treated as functions mapping variables onto their bound values. Conversely, such functions can also be treated as first-class environments. Programmable environments allow us to operate meta-level name spaces directly, and they enable us to model the dynamic evolution mechanism.
{"title":"Programmable environment calculus as theory of dynamic software evolution","authors":"S. Nishizaki","doi":"10.1109/ISPSE.2000.913242","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913242","url":null,"abstract":"Software evolution is one of the most important features in advanced computer systems, and the significance of its theoretical study is acknowledged. Software evolution is divided into two categories: static and dynamic evolution. Static evolution involves changes in a software system that occur before compilation; a typical example is a software update. On the other hand, dynamic evolution involves changes in the execution time of a software system. The dynamic library mechanism in operating systems and dynamic class loading in Java are types of dynamic evolution. An environment represents a mapping of variables onto values. We have studied the lambda calculus with first-class environments (called the environment calculus). With this, we can treat environments as first-class citizens: environment values can be passed as parameters and returned as resultant values. The first-class environments are formalized according to the idea of explicit substitutions. This paper proposes programmable environments, as a further extension of first-class environments, which provide a computational mechanism allowing first-class environments to be treated as functions mapping variables onto their bound values. Conversely, such functions can also be treated as first-class environments. Programmable environments allow us to operate meta-level name spaces directly, and they enable us to model the dynamic evolution mechanism.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"201 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":"132855635","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.913230
H. Masuhara, Y. Sugita, A. Yonezawa
In reflective languages, application programs can customize a language system that executes the application programs. Our premise is that this customizability of reflective languages can be a basic mechanism of software evolution. We present a simple architecture of a reflective language that can dynamically select meta-interpreters, and a dynamic compilation scheme by using run-time specialization (RTS) techniques, which could also be useful to dynamically optimize systems with mechanisms of dynamic software evolution. Our prototype system showed that dynamically compiled reflective programs run more than four times faster than the interpreted ones, and that compilation processes are fast enough to be invoked at runtime. Compared to statically compiled programs, however, dynamically compiled ones yet have 20-30% overheads. We also discuss this problem.
{"title":"Dynamic compilation of a reflective language using run-time specialization","authors":"H. Masuhara, Y. Sugita, A. Yonezawa","doi":"10.1109/ISPSE.2000.913230","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913230","url":null,"abstract":"In reflective languages, application programs can customize a language system that executes the application programs. Our premise is that this customizability of reflective languages can be a basic mechanism of software evolution. We present a simple architecture of a reflective language that can dynamically select meta-interpreters, and a dynamic compilation scheme by using run-time specialization (RTS) techniques, which could also be useful to dynamically optimize systems with mechanisms of dynamic software evolution. Our prototype system showed that dynamically compiled reflective programs run more than four times faster than the interpreted ones, and that compilation processes are fast enough to be invoked at runtime. Compared to statically compiled programs, however, dynamically compiled ones yet have 20-30% overheads. We also discuss this problem.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"3 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":"114180533","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.913236
M. Tomoishi, N. Yonezaki
Presents a new consistency checking method for temporal logic specifications. The new method verifies the consistency of a whole specification by using a tableau graph constructed from tableau graphs obtained in the verifications of partial specifications. The new method is applicable not only to on-the-fly verification but also to compositional verification. On-the-fly verification is verification that proceeds as a specification is evolved; compositional verification is verification constructed by merging modular verifications. By verifying a specification at each step of its refinement, we can make the specification evolution process efficient. A tableau graph constructed by a traditional tableau method does not suit reuse. The traditional tableau method has two phases: a tableau graph construction phase and an eventuality checking phase. It is difficult to reflect the results of the eventuality checking on the tableau graph because there is no suitable substructure which can store the results. For that reason, it is necessary to check eventuality formulae repeatedly on the reuse of the tableau graphs. A new tableau graph introduced in this paper has a new structure and is obtained by piling up tableau graphs of subformulae. In this new structure, the checked results of eventuality checking are encoded. Therefore, all the results of the verification in each step can be reused for constructing the verification for a whole specification.
{"title":"Evolutional tableau method for temporal logic specifications","authors":"M. Tomoishi, N. Yonezaki","doi":"10.1109/ISPSE.2000.913236","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913236","url":null,"abstract":"Presents a new consistency checking method for temporal logic specifications. The new method verifies the consistency of a whole specification by using a tableau graph constructed from tableau graphs obtained in the verifications of partial specifications. The new method is applicable not only to on-the-fly verification but also to compositional verification. On-the-fly verification is verification that proceeds as a specification is evolved; compositional verification is verification constructed by merging modular verifications. By verifying a specification at each step of its refinement, we can make the specification evolution process efficient. A tableau graph constructed by a traditional tableau method does not suit reuse. The traditional tableau method has two phases: a tableau graph construction phase and an eventuality checking phase. It is difficult to reflect the results of the eventuality checking on the tableau graph because there is no suitable substructure which can store the results. For that reason, it is necessary to check eventuality formulae repeatedly on the reuse of the tableau graphs. A new tableau graph introduced in this paper has a new structure and is obtained by piling up tableau graphs of subformulae. In this new structure, the checked results of eventuality checking are encoded. Therefore, all the results of the verification in each step can be reused for constructing the verification for a whole specification.","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":"124817201","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.913223
K. Itou, T. Katayama
In object-oriented development methodologies, behavior of the system to be developed is usually specified as a collection of state diagrams for the objects involved in the system. We need to describe them so that each individual object reacts correctly to the events it receives. Also, we have to consider the entire system behaves properly as the result of the collective behavior of each object and this is usually done by the help of interaction or collaboration diagrams. We propose an evolutionary development method which allows to describe the system looking over its entire behavior, while it could be executed and tested at any stage of its development. It is based on the concept of stepwise reification and abstract execution. In this method, the system behavior is constructed by starting from its very abstract initial form and then gradually evolving it until its ultimate form is obtained. The evolution is done by executing and testing its abstract intermediate description and by reifying it to the next step. Execution of the abstract intermediate objects are done symbolically. We firstly formalize behaviors of object systems by the collection of regular expressions which are executed in parallel and by the concept of their collaboration. Next, on the foundation, we formalize the idea of evolutionary development of objects behavior in terms of rewriting behavior identifiers. Finally, we give an example to illustrate our method.
{"title":"Evolutionary development of object behaviors","authors":"K. Itou, T. Katayama","doi":"10.1109/ISPSE.2000.913223","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913223","url":null,"abstract":"In object-oriented development methodologies, behavior of the system to be developed is usually specified as a collection of state diagrams for the objects involved in the system. We need to describe them so that each individual object reacts correctly to the events it receives. Also, we have to consider the entire system behaves properly as the result of the collective behavior of each object and this is usually done by the help of interaction or collaboration diagrams. We propose an evolutionary development method which allows to describe the system looking over its entire behavior, while it could be executed and tested at any stage of its development. It is based on the concept of stepwise reification and abstract execution. In this method, the system behavior is constructed by starting from its very abstract initial form and then gradually evolving it until its ultimate form is obtained. The evolution is done by executing and testing its abstract intermediate description and by reifying it to the next step. Execution of the abstract intermediate objects are done symbolically. We firstly formalize behaviors of object systems by the collection of regular expressions which are executed in parallel and by the concept of their collaboration. Next, on the foundation, we formalize the idea of evolutionary development of objects behavior in terms of rewriting behavior identifiers. Finally, we give an example to illustrate our method.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"30 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":"122187768","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.913234
G. Masuda, N. Sakamoto, K. Ushijima
We describe a case study on redesigning of existing software using design patterns. Although design patterns have spread widely in object-oriented software design, the disordered application of them often makes the design more complicated or worsens performance. In the case study, we introduce a hot-spot based approach to apply design patterns effectively. Then we quantitatively evaluate the effectiveness of applying design patterns to the redesigning. The C&K metrics suite is used for the evaluation. We collect C&K metrics values for two versions of the decision tree learning system. One is a prototype version designed without using design patterns while the other is redesigned using design patterns. We conduct the Mann-Whitny U-test, one of the nonparametric statistics for testing hypotheses about whether two sample values differ. As a result, we find significant differences between the C&K metrics values of the two versions. Finally we discuss the applicability of the C&K metrics to criterion for evaluation of the flexibility and extensibility of software.
{"title":"Redesigning of an existing software using design patterns","authors":"G. Masuda, N. Sakamoto, K. Ushijima","doi":"10.1109/ISPSE.2000.913234","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913234","url":null,"abstract":"We describe a case study on redesigning of existing software using design patterns. Although design patterns have spread widely in object-oriented software design, the disordered application of them often makes the design more complicated or worsens performance. In the case study, we introduce a hot-spot based approach to apply design patterns effectively. Then we quantitatively evaluate the effectiveness of applying design patterns to the redesigning. The C&K metrics suite is used for the evaluation. We collect C&K metrics values for two versions of the decision tree learning system. One is a prototype version designed without using design patterns while the other is redesigned using design patterns. We conduct the Mann-Whitny U-test, one of the nonparametric statistics for testing hypotheses about whether two sample values differ. As a result, we find significant differences between the C&K metrics values of the two versions. Finally we discuss the applicability of the C&K metrics to criterion for evaluation of the flexibility and extensibility of software.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"15 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":"125594227","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.913247
S. Ida, K. Futatsugi
Analyses software evolution in component-based software developments. We adopt two aspects (functional and non-functional aspects) to characterize software evolution. These two aspects construct a 2D evolution space which can be nicely handled by component-based algebraic specification (CBAS). CBAS is based on the algebraic specification technique (a kind of formal specification) combined with the idea of behavioural specification. We discuss several typical examples to show how each evolution step can be explained by using formal specification techniques.
{"title":"Formal approach for handling software evolution in component-based software developments","authors":"S. Ida, K. Futatsugi","doi":"10.1109/ISPSE.2000.913247","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913247","url":null,"abstract":"Analyses software evolution in component-based software developments. We adopt two aspects (functional and non-functional aspects) to characterize software evolution. These two aspects construct a 2D evolution space which can be nicely handled by component-based algebraic specification (CBAS). CBAS is based on the algebraic specification technique (a kind of formal specification) combined with the idea of behavioural specification. We discuss several typical examples to show how each evolution step can be explained by using formal specification techniques.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"347 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":"125805686","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.913231
H. Kaiya, K. Kaijiri
We propose a specification of both runtime environments and software components which can be loaded not only from your local system but also from the other systems over the computer network. Because components from the other system are not always reliable or safe enough to act freely in your own system, you should limit their activities to a certain context. Such assumption is based on the sandbox security model. As such components are largely influenced by the runtime environments, users sometimes lose sight of the abilities and limitations of such components. Therefore, they fail to reuse the components in the right way. We provide a way to specify such properties, so that component users can precisely understand the abilities and limitations.
{"title":"Specifying runtime environments and functionalities of downloadable components under the sandbox model","authors":"H. Kaiya, K. Kaijiri","doi":"10.1109/ISPSE.2000.913231","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913231","url":null,"abstract":"We propose a specification of both runtime environments and software components which can be loaded not only from your local system but also from the other systems over the computer network. Because components from the other system are not always reliable or safe enough to act freely in your own system, you should limit their activities to a certain context. Such assumption is based on the sandbox security model. As such components are largely influenced by the runtime environments, users sometimes lose sight of the abilities and limitations of such components. Therefore, they fail to reuse the components in the right way. We provide a way to specify such properties, so that component users can precisely understand the abilities and limitations.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"35 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":"129929693","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 : 1900-01-01DOI: 10.1109/ISPSE.2000.913244
Naoyasu Ubayashi, T. Tamai
Using mobile agent systems, cooperative distributed applications that run over the Internet can be constructed flexibly. However, there are some problems: it is difficult to understand collaborations among the agents as a whole, and it is difficult to define the behaviors of agents because they are dynamically influenced by their external context. So, in general, constructions of cooperative distributed applications based on mobile agent systems are considered as very hard and difficult works. In this paper, the concept of RoleEP (Role-based Evolutionary Programming) is proposed in order to alleviate these problems. RoleEP provides a systematic evolutionary programming style. In RoleEP, a field where a group of agents collaborate with each other is regarded as an environment, and a function that an agent assumes in an environment is defined as a role. Descriptions only concerning the collaborations among agents can be abstracted by environments. An object becomes an agent by binding itself with a role that is defined in an environment, and it then acquires the functions needed for collaborating with other agents that exist in the same environment. Distributed applications based on mobile agent systems, which may change their functions dynamically in order to adapt themselves to their external context, can be constructed by synthesizing environments dynamically.
{"title":"RoleEP: role based evolutionary programming for cooperative mobile agent applications","authors":"Naoyasu Ubayashi, T. Tamai","doi":"10.1109/ISPSE.2000.913244","DOIUrl":"https://doi.org/10.1109/ISPSE.2000.913244","url":null,"abstract":"Using mobile agent systems, cooperative distributed applications that run over the Internet can be constructed flexibly. However, there are some problems: it is difficult to understand collaborations among the agents as a whole, and it is difficult to define the behaviors of agents because they are dynamically influenced by their external context. So, in general, constructions of cooperative distributed applications based on mobile agent systems are considered as very hard and difficult works. In this paper, the concept of RoleEP (Role-based Evolutionary Programming) is proposed in order to alleviate these problems. RoleEP provides a systematic evolutionary programming style. In RoleEP, a field where a group of agents collaborate with each other is regarded as an environment, and a function that an agent assumes in an environment is defined as a role. Descriptions only concerning the collaborations among agents can be abstracted by environments. An object becomes an agent by binding itself with a role that is defined in an environment, and it then acquires the functions needed for collaborating with other agents that exist in the same environment. Distributed applications based on mobile agent systems, which may change their functions dynamically in order to adapt themselves to their external context, can be constructed by synthesizing environments dynamically.","PeriodicalId":170375,"journal":{"name":"Proceedings International Symposium on Principles of Software Evolution","volume":"210 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"1900-01-01","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"115724106","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
扫码关注我们
求助内容：
应助结果提醒方式：