Software is the essential enabler for the new economy and science. It creates new markets and new directions for a more reliable, flexible, and robust society. It empowers the exploration of our world in ever more depth. However, software often falls short behind our expectations. Current software methodologies, tools, and techniques remain expensive and not yet reliable for a highly changeable and evolutionary market. Many approaches have been proven only as case-by-case oriented methods. This book presents a number of new trends and theories in the direction in which we believe software science and engineering may develop to transform the role of software and science in tomorrow’s information society. This publication is an attempt to capture the essence of a new state of art in software science and its supporting technology. Is also aims at identifying the challenges such a technology has to master.
Software is the essential enabler for the new economy and science. It creates new markets and new directions for a more reliable, flexible, and robust society. It empowers the exploration of our world in ever more depth. However, software often falls short behind our expectations. Current software methodologies, tools, and techniques remain expensive and not yet reliable for a highly changeable and evolutionary market. Many approaches have been proven only as case-by-case oriented methods.
This book presents a number of new trends and theories in the direction in which we believe software science and engineering may develop to transform the role of software and science in tomorrow's information society.
This book is an attempt to capture the essence of a new state of art in software science and its supporting technology. The book also aims at identifying the challenges such a technology has to master. It contains papers accepted at the Fifth International Conference on New Trends in software Methodology Tools, and Techniques, V, (SoMeT_06) held in Quebec, Canada, from 25th to 27th October 2006, (url: www.somet.soft.iwate-pu.ac.jp/somet_06). This workshop had brought together researchers and practitioners to share their original research results and practical development experiences in software science, and its related new challenging technology.
One of the important issues addressed in this book is software security tools and techniques. Another example we challenge in this conference is, Lyee methodology as a new Japanese emerged software methodology that has been patented in several countries in Europe, Asia, and America. But it is still in its early stage of emerging as a new software style. This book and the series it continues will also contribute to elaborate on such new trends and related academic research studies and development.
A major goal of this book was to gather scholars from the international research community to discuss and share research experiences on new software methodologies, and formal techniques. The book also investigated other comparable theories and practices in software science, including emerging technologies, from their computational foundations in terms of models, methodologies, and tools. These are essential for developing a variety of information systems research projects and to assess the practical impact on real-world software problems.
For an outline of the past series of related events that contributed to this publication are SoMeT_02 that was held October 3–5, 2002, in Sorbonne, Paris, France. SoMeT_03 was held in Stockholm, Sweden, SoMeT_04 held in Leipzig, Germany, SoMeT_05 held in Tokyo, Japan and this publication covers SoMeT_06; held in Quebec, Canada. These events, also initiate the forthcoming SoMeT_07, to be organized in Rome, Italy in November 2007, (url: www.somet.soft.iwate-pu.ac.jp/somet_07/).
This book participates to provide an opportunity for exchanging ideas and experiences in the field of software technology opening up new avenues for software development, methodologies, tools, and techniques, especially, software security and program coding diagnosis and related software maintenance techniques aspects.
The Lyee framework for example, captures the essence of the innovations, controversies, challenges and possible solutions of the software industry. This world wide patented software approach was born and enriched from experience, and it is time, and again through SoMeT_06 to try to let it stimulate the academic research on software engineering attempting to close the gap so far existed between theory and practice. We believe that this book creates an opportunity for us in the software science community to think about where we are today and where we are going.
The book is a collection of 28 carefully reviewed best-selected papers by the reviewing committee.
This book covers the following areas:
• Software engineering aspects on software security, programs diagnosis and maintenance
• Static and dynamic analysis on Lyee-oriented software performance model
• Software security aspects on Java mobile code, and networking
• Practical artefact on software security, software validation and diagnosis
• Software optimization and formal methods
• Requirement engineering and requirement elicitation
• Software methodologies and Lyee oriented software techniques
• Automatic software generation, reuse, and legacy systems
• Software quality and process assessment
• Intelligent software systems and evolution
• End-user requirement engineering and programming environment
• Ontology and philosophical aspects on software engineering
• Business software models and other kinds of software application models, based on Lyee theory
All papers published in this book are carefully reviewed selected by the SOMET international reviewing committee. Each paper has been reviewed by three and up to four reviewers and has been revised based on the review reports. The papers were reviewed on the basis of technical soundness, relevance, originality, significance, and clarity.
This book outcome is also a collective effort from all the Lyee International project collaborators and industrial supporters. We also, gratefully thank Iwate Prefectural University, University of Laval, Catena Co., ISD, Ltd, SANGIKYO co., and others for their overwhelming support, on this work. We specially, are thankful to the review committee and others who participated in the review of all submitted papers and thanks also for the hot discussion we have had on the reviews evaluation meetings that selected those contributed in book.
This outcome is another milestone in mastering new challenges on software and its new promising technology, within SoMeT's consecutive events. Also, it gives the reader new insights, inspiration and concrete material to elaborate and study this new technology.
Also, at last and not least, we would like to thank and acknowledge the support of the University of Leipzig, Telematik and e-Business group for allowing us to use the Paperdyne System as a conference-supporting tool during all the phases on review transactions.
For at least 4 decades, managers, customers, and anyone else who wanted to acquire software, has bemoaned our inability to specify exactly what is required when we want software built. Those who maintain software or use software complain about the lack of a precise description of what it does. Numerous specification methods, none of which have been found to be satisfactory have been proposed. This paper discusses documentation methods,why we need one and what a good one might be like.
Understanding software is getting more complex as programs are getting ever bigger. Many believe that the key to this problem is better visualization. The objective of this document is to provide an as thorough as possible overview of this field. This is the starting point for further research and development in this critical area. Over 140 papers and nearly as many tools were reviewed for this purpose. This document presents the most relevant and significant ones. It also tries to identify the essential requirements of a software visualization component.
Restructuring a program is a concept that aims at increasing the maintainability of a piece of code by changing its structure. The term refactoring is often used synonymously, especially when the observable behavior of a program should not change when transforming the structure of the software to a more sophisticated level, e.g. by using design patterns. Behaviour-conserving program transformations are difficult as the understanding of both the code to transform as well as the transformation is prerequisite for conserving the conduct of a transformed program. In addition, a transformation should only be executed if certain preconditions apply. To capture the semantic and syntactic details about a specific code fragment, it is proposed documenting them by adding machine-processable and at the same time human-readable annotations. These annotations contain explicit information and could be added to source code by tools evaluating the code, as well as by practitioners. With annotations, it may be possible checking preconditions for program transformations to execute, and gain information necessary for these transformations.
Any engineering method is based on the validity of some assumptions about the problem domain and about the artifacts used in any solution of an engineering problem. Engineers have learned, perhaps not perfectly, to lay bare these assumptions and to base their methods on effective use of these assumptions. Software engineers are less good at this, to the detriment of building effective methods. The paper discusses some assumptions that either are false or are not made properly explicit in methods and the detrimental effect on the relevant methods. Some ideas about dealing with these deficiencies are proposed and discussed.
Agile software development methods support mainly object-oriented, feature-oriented and component-oriented software development and do not address agent-oriented and aspect-oriented software development. The concepts of agents and objects are in many ways dissimilar; and an object-oriented approach is not immediately suitable for the development of a multiagent system. In our current research, we extend agile software development methods originating primarily in object-oriented technology to support agent-orientation in the context of the development of multiagent systems. This research paper introduces a new agile agent-oriented framework to create or tailor situation-specific non-fragile agile agent-oriented software development processes (using a method engineering approach) to support multi-agent software development.
This paper discusses argument structure asymmetries observed in linguistic expressions, and presents the main features of a parser that recovers them incrementally. It is argued that the recovery of argument structure asymmetries, expressed in terms of the asymmetric c-command relation, is crucial in Information Retrieval and Question Answering. A consequence is drawn for efficient software design.
The emergence and wide adoption of Web Services standards and technologies represents a shift from component-based development that dominated enterprise computing over the last decade towards service-oriented architectures that are more suited to the highly distributed inter-enterprise applications. This trend towards service-oriented computing necessitates the re-evaluation of software development methodologies that are used in the construction of enterprise applications. With growing acceptance of service-oriented computing and increasing number of large-scale Web Services projects there is evidence that practitioners involved in implementing these solutions are paying only limited attention to how such applications should be designed. Frequently, the design of Web Services applications is driven by performance and scalability considerations, rather than sound software engineering principles. A comprehensive methodological framework is required to guide designers and developers of service-oriented applications through the various phases of software development life cycle with specific emphasis on producing stable, reusable and extendable services. In this paper we first describe the characteristics of the Service Oriented Architecture (SOA) and then consider the requirements for methodological support for the development of service-oriented applications. We identify the key differences between SOA and earlier software development approaches and comment on the suitability of existing analysis and design methods in the context of SOA. The main contribution of this paper is a clear analysis of the differences between component-based and service-oriented methodologies and the identification of key design objectives and guidelines for the development of service-oriented applications.
With the expectations that the LYEE (governmentaL methodologY for softwarE providencE ) methodology may enable to develop software systems without any detailed coding knowledge and to shorten the development time as well, it was considered that the methodology may suit for fostering system architects by going through several repetitions of actual systems development in a much shorter time than having trainees gone through conventional on-the-job-training approaches. Receiving a LyeeAll2 training first time, the LYEE methodology was successfully implanted in the authors' company. Capabilities of using LyeeAll3, the next generation tool, were then readily obtained. Through the development of a couple of actual systems, the initial expectations were confirmed and the methodology seems to be useful for developing system architects from engineers with non-software background.
Luciana de Paiva Silva, Elisa H.M. Huzita, Tania F. Calvi Tait
146 - 156
The comparison of related approaches in aspects oriented requirements engineering (AORE) has been frequent in the last years. The comparisons made, until now, did not follow any standardization or were based on some previous specification with no patterns, what makes difficult the definition of characteristics or attributes to be taken in consideration at the time to elaborate the comparison properly. This paper has as objective to reduce the gap existent in the most approaches in AORE, providing a comparison through the derivation of the quality attributes defined by ISO/IEC 9126 norm.
The increasing trend of computer crimes has intensified the relevance of cyber-forensics. In such a context, forensic analysis plays a major role by analyzing the evidence gathered from the crime scene and corroborating facts about the committed crime. In this paper, we propose a formal approach for the forensic log analysis. The proposed approached is based on the logical modelling of the events and the traces of the victim system as formulas over a modified version of the ADM logic. In order to illustrate the proposed approach, the Windows auditing system is studied. We will discuss the importance of the different features of such a system from the forensic standpoint (e.g. the ability to log accesses to specific files and registry keys and the abundance of information that can be extracted from these logs). Furthermore, we will capture logically: Invariant properties of a system, forensic hypotheses, generic or specific attack signatures. Moreover, we will discuss the admissibility of forensics hypotheses and the underlying verification issues.
M. Debbabi, M. Saleh, Chamseddine Talhi, Sami Zhioua
177 - 194
This paper represents a careful study of the security aspects of Java 2 Micro-Edition (J2ME) with Connected Limited Device Configuration (CLDC) and Mobile Information Device Profile (MIDP). This Java platform is intended for resource-constrained devices, with the purpose of expanding the range of applications available for these devices, by enabling them to run Java programs. Using a Common Criteria approach, our objective is to propose a set of security requirements that should be followed by any implementation of the platform.
In this paper, we present a formal technique for enforcing security policies on programs. Our technique takes an untrusted program and a security policy as input and produces a new safe program with respect to the considered policy. The proposed technique is based on the use of automata and a special composition operator called injection over automata. Injection consists in embedding the automaton representing the safety property into the automaton representing the untrusted program, so that we get a new automaton. This latter can merely be converted into a safe program which always satisfies the safety property. Consequently, our enforcement method is based on rewriting, since it takes an untrusted program and transforms it, so it produces another equivalent program satisfying the safety property. Finally, we prove that our technique is both sound and complete, i.e.: all the possible executions of the new generated program are possible executions of the original one and any possible execution of the original program respecting the security policy is a possible execution of the new generated one.
Significant time is spent by companies in trying to reproduce and fix bugs in their software. The process of testing and debugging can immensely benefit from a tool that supports Deterministic Replay Debugging (DRD). A tool that supports DRD will allow a user to record a program's execution in a log, and to deterministically replay every single instruction executed as part of the application using the log.
In this paper, we present the BugNet software tool which can support DRD. It can handle all forms of non-determinism, including the non-determinism due to thread interactions in a multi-threaded application. Since the BugNet tool is operating system independent, a program execution that fails in a particular user's environment can be easily captured by the user in a log, and later reproduced by a developer working in a completely different environment.
We also empirically quantify certain variables relevant to the DRD process. This includes anempirical analysis, that quantifies how much of a program execution has to belogged and replayed in order to understand the root cause of a bug. Further, we examine the potential benefit of using dynamic slicing along with our deterministic replay debugger.
We investigated errors and vulnerabilities that emerge from software defects in C/C++ and Java programs. This allowed us to create a meaningful testbench in order to evaluate best-of-breed automatic source code verification tools. Our results show that current static tools cannot significantly reduce the risk associated with confidential data processing in a military context. Dynamic tools should be used in conjunction in order to provide the necessary assurance level.
We have invented an axiomatic based theory as a methodology for software development. Our methodology has been used world wide for program generation based on intentional user requirement. Using such methodology we have developed a tool for program validation for diagnosis purposes.
The tool is based on Lyee theory and sets of rules that interpret the logical semantics of the old program and verify it for design errors or possible security aspects. We explain the theory and also show some practical results reflect our practices on actual business project to show the effectiveness of our theory as it consumes less efforts and time to diagnose a program design and logical errors.
Given a cryptographic protocol, it is possible to extract an inference system modelling exactly the set of messages an active intruder can learn by manipulating this protocol. Unfortunately, there is no general proof-search procedure to test whether or not a term belongs to the theory of an inference system. This paper presents the preliminary results obtained during an attempt to circumvent this problem. First, it explains a transformation process over inference systems; then presents a decision procedure (using the transformation process) for the security of a class of cryptographic protocols, called structured protocols; and finally argues that some basic security properties are decidable for such cryptographic protocols. The security properties include secrecy and chaoticity; the results can possibly be extended to cover authentication as well.
A Unified OTP Cryptosystem with Authentication and Secrecy, which is theoretically unbreakable and inherently high speed, is newly proposed in this paper. The system is featured in the use of One Time Pad (here-in-after called as OTP) made from intrinsic random number sequences derived from the natural phenomenon. The other unique feature of the proposed system is to establish cryptograph communication path between each user and an authentication server (here-in-after called as Auth Server), not between users directly. Authentication is first established between a user who initiates communication and Auth Server through internet, and then encrypted message transmission will follow. The other user who wants to receive delivered messages also establishes authentication with Auth Server in the same way and encrypted message reception will follow. The two users do not need to share any secret key for establishing a secure communication channel in the proposed system. Therefore, any key information leak from one party does not jeopardize authentication and communication capabilities of the others.
This proposed cryptosystem belongs to the stream-cipher method whose security level was considered low as compared to the block-cipher method. With the use of OTP made from intrinsic random number sequences derived from the natural phenomenon, the system becomes theoretically unbreakable, and the drawback mentioned above is completely removed. Because of the bit-by-bit encryption process, the system is very simple and shows ultimate low latency. The simplicity allows realization of the system without special LSI functions but with small scale software only.
With the merits described above, the unified authentication and secrecy process can be easily applied to e-commerce applications using mobile phones which are very sensitive to the increase of complexity and power consumption. Authors examined a possible enhancement of the existing e-commerce systems to allow mobile phones as the terminal device.
This paper proposes a firewall specification calculus suited for expressing security policies implemented in distributed firewalls. Our syntax and semantics, inspired from the ambient calculus, allow the specification of filtering rules for both single and distributed configurations. We show how our calculus can be used to address the problem of conflict detection and how our approach facilitates the analysis of the effect that network topologies have on distributed firewall policies.
IOS Press, Inc.
6751 Tepper Drive
Clifton, VA 20124
Tel.: +1 703 830 6300
Fax: +1 703 830 2300 firstname.lastname@example.org
(Corporate matters and books only) IOS Press c/o Accucoms US, Inc.
For North America Sales and Customer Service
West Point Commons
Lansdale PA 19446
Tel.: +1 866 855 8967
Fax: +1 215 660 5042 email@example.com