Function points are a standard method frequently used to calculate size and to estimate effort in applications. Although it has been used with good results in the development of industrial software, it is still necessary to improve some aspects such as: the time at which the estimation of effort is performed and the margin of error in the effort estimation. In this article an alternative method for early effort estimation based on use cases is presented. Two new alternative notions of size are used for effort estimation: transactions and entity objects. A case study developed in order to compare the estimations obtained with the two methods for actual projects is described. The result shows that by using number of transactions as a notion of size and the technique mean productivity value to perform the estimation, the current way of estimating effort can be improved.
{"title":"An Alternative Method Employing Uses Cases for Early Effort Estimation","authors":"Gabriela Robiolo, R. Orosco","doi":"10.1109/SEW.2007.91","DOIUrl":"https://doi.org/10.1109/SEW.2007.91","url":null,"abstract":"Function points are a standard method frequently used to calculate size and to estimate effort in applications. Although it has been used with good results in the development of industrial software, it is still necessary to improve some aspects such as: the time at which the estimation of effort is performed and the margin of error in the effort estimation. In this article an alternative method for early effort estimation based on use cases is presented. Two new alternative notions of size are used for effort estimation: transactions and entity objects. A case study developed in order to compare the estimations obtained with the two methods for actual projects is described. The result shows that by using number of transactions as a notion of size and the technique mean productivity value to perform the estimation, the current way of estimating effort can be improved.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"34 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130250449","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
Software patterns have been used as a software design tool to reuse proven solutions to recurring problems. But the complex interconnections and the number of pattern collections is becoming a barrier for identifying relevant patterns and pattern combinations for a given design context. More formal representations of patterns are needed that support machine processing in addition to the traditional text- based presentation of software patterns. In this paper, usability patterns are used to demonstrate a framework and techniques to support the development of pattern forms that facilitate cross-collection links over the World-Wide Web. This is an essential first step that will enable moving from loosely coupled patterns to closely coupled pattern languages. Semantic Web technologies are used both to support distributed and heterogeneous data integration and to provide a computational basis for building intelligent tools that utilize patterns to support software development activities.
{"title":"A Framework for Flexible and Executable Usability Patterns Standards","authors":"S. Henninger","doi":"10.1109/SEW.2007.82","DOIUrl":"https://doi.org/10.1109/SEW.2007.82","url":null,"abstract":"Software patterns have been used as a software design tool to reuse proven solutions to recurring problems. But the complex interconnections and the number of pattern collections is becoming a barrier for identifying relevant patterns and pattern combinations for a given design context. More formal representations of patterns are needed that support machine processing in addition to the traditional text- based presentation of software patterns. In this paper, usability patterns are used to demonstrate a framework and techniques to support the development of pattern forms that facilitate cross-collection links over the World-Wide Web. This is an essential first step that will enable moving from loosely coupled patterns to closely coupled pattern languages. Semantic Web technologies are used both to support distributed and heterogeneous data integration and to provide a computational basis for building intelligent tools that utilize patterns to support software development activities.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"36 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"130631491","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
In this paper the author uses Alloy, as a modeling language, to model the elements that form a state machine and the rules that govern how they can be connected. This modeling language is also a formal method that develops a model incrementally and can analyze it in an early state of the design having the advantage of detecting modeling errors very quickly. By using the formal method, some instances of the model are generated without making a line of code. The paper presents two models based on the formal approach: a graphical model and a textual model. The graphical model is used as an overview of the system and the textual model to establish further constraints on the graphical model.
{"title":"A Formal Model for the Building of State Machines: A Lightweight Approach","authors":"F. V. Barajas","doi":"10.1109/SEW.2007.43","DOIUrl":"https://doi.org/10.1109/SEW.2007.43","url":null,"abstract":"In this paper the author uses Alloy, as a modeling language, to model the elements that form a state machine and the rules that govern how they can be connected. This modeling language is also a formal method that develops a model incrementally and can analyze it in an early state of the design having the advantage of detecting modeling errors very quickly. By using the formal method, some instances of the model are generated without making a line of code. The paper presents two models based on the formal approach: a graphical model and a textual model. The graphical model is used as an overview of the system and the textual model to establish further constraints on the graphical model.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"39 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"122047189","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}
Transaction is a lasting debatable issue, no matter in database systems or in the new paradigm of web services. Particularly, in the context of service oriented computing, business transactions usually require long periods of time to complete. In case of failure, the traditional approaches, e.g., rollback, are not applicable to handle errors during long running transactions. Instead, compensation is suggested to be an error recovery mechanism. Hence, a business transaction is programmed as a composition of a set of compensable transactions. Sequence and parallel are two standard primitives to put compensable transactions together into a bigger compensable one. Besides, there are other useful compositional constructs, such as speculative choice, exception handling, alternative forwarding, and programmable compensation. These constructs cannot only improve the responsiveness to environment but also enhance the capability for dealing with errors. In this paper, we introduce a transactional calculus in which compensable transactions can be composed in a variety of ways. It is equipped with a trace model which is carefully presented to provide a clear meaning for each transactional construct. In addition, algebraic properties are investigated by giving corresponding equational laws.
{"title":"Looking into Compensable Transactions","authors":"Jing Li, Huibiao Zhu, G. Pu, Jifeng He","doi":"10.1109/SEW.2007.100","DOIUrl":"https://doi.org/10.1109/SEW.2007.100","url":null,"abstract":"Transaction is a lasting debatable issue, no matter in database systems or in the new paradigm of web services. Particularly, in the context of service oriented computing, business transactions usually require long periods of time to complete. In case of failure, the traditional approaches, e.g., rollback, are not applicable to handle errors during long running transactions. Instead, compensation is suggested to be an error recovery mechanism. Hence, a business transaction is programmed as a composition of a set of compensable transactions. Sequence and parallel are two standard primitives to put compensable transactions together into a bigger compensable one. Besides, there are other useful compositional constructs, such as speculative choice, exception handling, alternative forwarding, and programmable compensation. These constructs cannot only improve the responsiveness to environment but also enhance the capability for dealing with errors. In this paper, we introduce a transactional calculus in which compensable transactions can be composed in a variety of ways. It is equipped with a trace model which is carefully presented to provide a clear meaning for each transactional construct. In addition, algebraic properties are investigated by giving corresponding equational laws.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"25 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125961307","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The communication and tasking infrastructure of a real-time application makes up a significant portion of any embedded control system. Traditionally, the tasking and communication constructs are provided by an RTOS. We present an approach to automatically generate a robust framework for a single-node application from its architectural description. This framework sits atop a Ravenscar-compliant runtime as opposed to a standard RTOS. Finally, we present an extension of our approach to support code generation for distributed applications.
{"title":"A Generative Approach to Building a Framework for Hard Real-Time Applications","authors":"Irfan Hamid, E. Najm, J. Hugues","doi":"10.1109/SEW.2007.83","DOIUrl":"https://doi.org/10.1109/SEW.2007.83","url":null,"abstract":"The communication and tasking infrastructure of a real-time application makes up a significant portion of any embedded control system. Traditionally, the tasking and communication constructs are provided by an RTOS. We present an approach to automatically generate a robust framework for a single-node application from its architectural description. This framework sits atop a Ravenscar-compliant runtime as opposed to a standard RTOS. Finally, we present an extension of our approach to support code generation for distributed applications.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"38 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"116535383","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}
Multi-agent systems are said to possess considerable strengths like robustness, flexibility, and reliability. But their application in safety- and/or security-critical domains is often not accepted. This is because in such domains the correctness and predictability of a system must be validated by application of a huge amount of test sets or, in the worst case, verified by formal methods. However, verifying multi-agent systems can be very complex or even impossible. Note that the main problem seems not to be the distributed nature of agent-based systems but the agents' autonomy, especially when agents have to act in a non-cooperative and non-deterministic environment because such situations require the ability to reason about the current situation context and draw own decisions in order to realize individual or common group goals. In our work we propose a model that is based on the Observe-Orient-Decide-Act Loop and the Belief-Desire-Intention Model and is completely realized with Reference Nets - a special kind of Object Petri Nets. It allows for the formal specification of Cognitive Decision Making processes together with inherent concurrencies as well as causal dependencies and facilitates automatic code generation. Furthermore, it enforces modeling with constrained resources in order to allow for practical model-checking.
{"title":"A Reference Net Based Formalization of Concurrent Cognitive Decision Making","authors":"J. Duscher, Amine El Malki","doi":"10.1109/SEW.2007.86","DOIUrl":"https://doi.org/10.1109/SEW.2007.86","url":null,"abstract":"Multi-agent systems are said to possess considerable strengths like robustness, flexibility, and reliability. But their application in safety- and/or security-critical domains is often not accepted. This is because in such domains the correctness and predictability of a system must be validated by application of a huge amount of test sets or, in the worst case, verified by formal methods. However, verifying multi-agent systems can be very complex or even impossible. Note that the main problem seems not to be the distributed nature of agent-based systems but the agents' autonomy, especially when agents have to act in a non-cooperative and non-deterministic environment because such situations require the ability to reason about the current situation context and draw own decisions in order to realize individual or common group goals. In our work we propose a model that is based on the Observe-Orient-Decide-Act Loop and the Belief-Desire-Intention Model and is completely realized with Reference Nets - a special kind of Object Petri Nets. It allows for the formal specification of Cognitive Decision Making processes together with inherent concurrencies as well as causal dependencies and facilitates automatic code generation. Furthermore, it enforces modeling with constrained resources in order to allow for practical model-checking.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"86 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"133241128","PeriodicalName":null,"FirstCategoryId":null,"ListUrlMain":null,"RegionNum":0,"RegionCategory":"","ArticlePicture":[],"TitleCN":null,"AbstractTextCN":null,"PMCID":"","EPubDate":null,"PubModel":null,"JCR":null,"JCRName":null,"Score":null,"Total":0}
The JMEI (Java Mathematical Engine Interface) framework is a layered Java application framework for providing mathematical computing services for the Internet/Web. The layered architecture of JMEI framework follows model- view-controller pattern. The JMEI framework architecture, JMEI API and JMEI drivers, the JMEI JSP Tag Library, the JMEIAJAX library, and the practical uses of the JMEI Framework are discussed. The JMEI framework can also be used in grid computing and other distributed environments.
{"title":"A Layered Java Application Framework for Supplying Mathematical Computing Power to the Distributed Environment","authors":"W. Liao, Benjamin J. Koonse","doi":"10.1109/SEW.2007.84","DOIUrl":"https://doi.org/10.1109/SEW.2007.84","url":null,"abstract":"The JMEI (Java Mathematical Engine Interface) framework is a layered Java application framework for providing mathematical computing services for the Internet/Web. The layered architecture of JMEI framework follows model- view-controller pattern. The JMEI framework architecture, JMEI API and JMEI drivers, the JMEI JSP Tag Library, the JMEIAJAX library, and the practical uses of the JMEI Framework are discussed. The JMEI framework can also be used in grid computing and other distributed environments.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"130 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"121228736","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}
Gregory Kulczycki, Heather Keown, M. Sitaraman, B. Weide
The ultimate objective of a verifying compiler is to prove that proposed code implements a full behavioral specification. Experience reveals this to be especially difficult for programs that involve pointers or references and linked data structures. In some situations, pointers are unavoidable; in some others, verification can be simplified through suitable abstractions. Regardless, a verifying compiler should be able to handle both cases, preferably using the same set of rules. To illustrate how this can be done, we examine two approaches to full verification. One replaces language- supplied indirection with software components whose specifications abstract pointers and pointer- manipulation operations. Another approach uses abstract specifications to encapsulate data structures that pointers and references are often used to implement, limiting verification complications to inside the implementations of these components. Using a modular, specification-based tool we have developed for verification condition generation, we show that full verification of programs with and without the direct use of pointers can be handled similarly. There is neither a need to focus on selected pointer properties, such as the absence of null references or cycles, nor a need for special rules to handle pointers.
{"title":"Abstracting Pointers for a Verifying Compiler","authors":"Gregory Kulczycki, Heather Keown, M. Sitaraman, B. Weide","doi":"10.1109/SEW.2007.89","DOIUrl":"https://doi.org/10.1109/SEW.2007.89","url":null,"abstract":"The ultimate objective of a verifying compiler is to prove that proposed code implements a full behavioral specification. Experience reveals this to be especially difficult for programs that involve pointers or references and linked data structures. In some situations, pointers are unavoidable; in some others, verification can be simplified through suitable abstractions. Regardless, a verifying compiler should be able to handle both cases, preferably using the same set of rules. To illustrate how this can be done, we examine two approaches to full verification. One replaces language- supplied indirection with software components whose specifications abstract pointers and pointer- manipulation operations. Another approach uses abstract specifications to encapsulate data structures that pointers and references are often used to implement, limiting verification complications to inside the implementations of these components. Using a modular, specification-based tool we have developed for verification condition generation, we show that full verification of programs with and without the direct use of pointers can be handled similarly. There is neither a need to focus on selected pointer properties, such as the absence of null references or cycles, nor a need for special rules to handle pointers.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"5 23","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"113963356","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}
A lightweight approach to the verification of software at large scales, called "symbolic approximation", has been developed in order to achieve post-hoc verification of C code in fast-moving open source projects such as the Linux kernel. While other approaches such as model-checking were known to be technically sound beforehand and were subsequently scaled up to treat larger problems, symbolic approximation was created to first of all work expediently at very large scales and absolute formal correctness is being adduced only afterwards. In this paper we report just a few new details and advances in the technology but supply new global reasoning supporting its correctness.
{"title":"Verification in the Light and Large: Large-Scale Verification for Fast-Moving Open Source C Projects","authors":"Peter T. Breuer, S. Pickin","doi":"10.1109/SEW.2007.113","DOIUrl":"https://doi.org/10.1109/SEW.2007.113","url":null,"abstract":"A lightweight approach to the verification of software at large scales, called \"symbolic approximation\", has been developed in order to achieve post-hoc verification of C code in fast-moving open source projects such as the Linux kernel. While other approaches such as model-checking were known to be technically sound beforehand and were subsequently scaled up to treat larger problems, symbolic approximation was created to first of all work expediently at very large scales and absolute formal correctness is being adduced only afterwards. In this paper we report just a few new details and advances in the technology but supply new global reasoning supporting its correctness.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"3 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"128870136","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}
Performance is a key aspect of non-functional software requirements. While performance cross-cuts much of the software functionality, it is frequently difficult to express in traditional software development representations. In this paper we propose a framework for evaluating software performance using aspect-oriented programming (AOP) and examine its strengths and limitations. The framework provides a mechanism for supporting software performance evaluation prior to final software release. AOP is a promising software engineering technique for expressing cross-cutting characteristics of software systems. We consider software performance as a cross-cutting concern since it is not confined only a few modules, but often spread over multiple functional and non-functional elements. A key strength of our framework is the use of a code instrumentation mechanism of AOP - AspectJ code for performance analysis is separated from Java code for functional requirements. Java code is executable regardless of Aspect J code and can be woven together with AspectJ code when performance is evaluated. Our performance evaluation modules, written in AspectJ are semi-automatically or automatically generated from the UML [1] models with annotated performance profiles. The AspectJ code generator facilitates performance evaluation by allowing performance requirements that have been specified in UML models to be analyzed. The UML diagrams can then be improved by reflecting the feedback from the results of the performance analysis.
{"title":"An AOP-based Performance Evaluation Framework for UML Models","authors":"Dong Kwan Kim, S. Bohner","doi":"10.1109/SEW.2007.92","DOIUrl":"https://doi.org/10.1109/SEW.2007.92","url":null,"abstract":"Performance is a key aspect of non-functional software requirements. While performance cross-cuts much of the software functionality, it is frequently difficult to express in traditional software development representations. In this paper we propose a framework for evaluating software performance using aspect-oriented programming (AOP) and examine its strengths and limitations. The framework provides a mechanism for supporting software performance evaluation prior to final software release. AOP is a promising software engineering technique for expressing cross-cutting characteristics of software systems. We consider software performance as a cross-cutting concern since it is not confined only a few modules, but often spread over multiple functional and non-functional elements. A key strength of our framework is the use of a code instrumentation mechanism of AOP - AspectJ code for performance analysis is separated from Java code for functional requirements. Java code is executable regardless of Aspect J code and can be woven together with AspectJ code when performance is evaluated. Our performance evaluation modules, written in AspectJ are semi-automatically or automatically generated from the UML [1] models with annotated performance profiles. The AspectJ code generator facilitates performance evaluation by allowing performance requirements that have been specified in UML models to be analyzed. The UML diagrams can then be improved by reflecting the feedback from the results of the performance analysis.","PeriodicalId":277367,"journal":{"name":"31st IEEE Software Engineering Workshop (SEW 2007)","volume":"37 1","pages":"0"},"PeriodicalIF":0.0,"publicationDate":"2007-03-06","publicationTypes":"Journal Article","fieldsOfStudy":null,"isOpenAccess":false,"openAccessPdf":"","citationCount":null,"resultStr":null,"platform":"Semanticscholar","paperid":"125004660","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
扫码关注我们
求助内容：
应助结果提醒方式：