Tracking software changes and their impact are important tasks when developing and deploying software. Software developers armed with the knowledge of which changes have the highest impact on the existing software can selectively deploy changes to minimize any negative impacts on the deployment. Software developers can use requirements change impact measures to assist with how to implement the changes to software code. One challenge when identifying change impact is quantifying the effect of the impact. In this research, we approach the problem of identifying and quantifying the impact of changes by applying IR techniques along with data mining. We apply TF-IDF and LSI to help determine which changes have a high potential of modifying existing requirements. We also analyze similarities among requirements changes and similarities among requirements baselines. In both cases, our threshold for identifying similarity is between 75% - 95%. We use these transitive relationships in conjunction with the change to baseline relationships to derive more insight about the inter-relationships of the baseline requirements and changes to those requirements. We bucket these relationships according to their impact scores into buckets of low, medium, and high impact using per dataset analysis of tertiles.

Multiple software development activities, including change impact analysis, requirements validation, maintenance and evolution of software benefit from adequate requirements traceability link recovery practices. Requirements traceability link recovery increases the overall quality of software products; however, companies often are unsuccessful implementing them due to lack of communication and strict deadlines. Several approaches for semi-automatic link recovery across requirements and source code in which textual analysis and information retrieval (IR) techniques are the baseline have been developed, but there is a need for methods that further enable the automatic generation of links. To advance automatization in the link recovery process, we investigate it as a combinational problem using an optimization approach. In this paper, we studied the requirements traceability recovery problem as a big search space formed by multiple pairs (requirements and source code classes), where requirements are matched to code elements. The artificial bee colony (ABC) algorithm is adapted for searching for the solution that maximizes an objective function which is calculated by a weighted cosine similarity where weighs for each term in the textual content of requirements and source code are defined according to the term frequency (TF-idf). Evaluation over three data sets demonstrates the effectiveness of the proposed approach. It returned high precision and recall values for the recovered links.

Presents the introductory welcome message from the conference proceedings. May include the conference officers' congratulations to all involved with the conference event and publication of the proceedings record.

Presents an editorial which explores the market fr cloud-based mobile computing systems. The concept of cloud-based mobile applications has emerged recently to address the limitations of pure mobile applications by leveraging the vast resources available at computing clouds. Traditionally, mobile applications benefit by outsourcing a part of the program execution to a cloud-based system to compute the (intermediate) results and send back these results for integration by the relevant mobile application. By doing so, the program code, data as well as device-specific information, such as user locations, can be made available to a cloud. Infrastructures to support computation outsourcing of the above type and its variants have been widely studied; and the associated security and privacy issues are hot topics in research.

Presents a listing of the Symposium organizing committee.

Data-driven Natural Language Processing (NLP) methods have noticeably advanced in the past few years. These advances can be tied to the drastic growth of the quality of collaborative knowledge bases (KB) available on the World Wide Web. Such KBs contain vast amounts of up-to-date structured human knowledge and common sense data that can be exploited by NLP methods to discover otherwise-unseen semantic dimensions in text, aiding in tasks related to natural language understanding, classification, and retrieval. Motivated by these observations, we describe our research agenda for exploiting online human knowledge in Requirements Engineering (RE). The underlying assumption is that requirements are a product of the human domain knowledge that is expressed mainly in natural language. In particular, our research is focused on methods that exploit the online encyclopedia Wikipedia as a textual corpus. Wikipedia provides access to a massive number of real-world concepts organized in hierarchical semantic structures. Such knowledge can be analyzed to provide automated support for several exhaustive RE activities including requirements elicitation, understanding, modeling, traceability, and reuse, across multiple application domains. This paper describes our preliminary findings in this domain, current state of research, and prospects of our future work.

Numerous challenges currently face digital forensic analysis. Although a variety of techniques and tools exist to assist with the analysis of digital evidence, they inadequately address key problems. We consider the applicability and usefulness of weaving ontologies to address some of these problems. We introduce an ontological approach leading to future development of an automated digital forensic analysis tool.

Code optimization of the offset assignment generated in embedded systems allows for power and space efficient systems. We propose a new heuristic that uses edge classification to commutatively transformation and optimize the assignment. We introduce concept of breakable and unbreakable edges, which assists in selecting edges for path cover and edges for commutative transformation.

The Mdel Driven Architecture (MDA) initiative formulated by the Object Management Group (OMG) is intended to support the development of software-intensive systems through the transformation of models to executable components and applications. Techniques and technologies that support rigorous definition of model transformations are required to realize the MDA vision. In this paper, we describe a technique for specifying pattern-based transformations of UML models consisting of class and interaction diagrams. The transformation specifications can be used to support systematic and verifiable transformations of UML models.

Determining the impact of requirement changes on software development is critical to project management. We present an impact analysis method to evaluate requirement changes for software development projects that is based on requirements traceability. By using attributes of the work products and traces, we create classes of requirement changes prioritized according to the potential impact. We present a case study that shows a favorable comparison between the actual impact and the predicted impact. Finally, we discuss the expansion of the method.

Maintenance of legacy systems is a laborious, error-prone task. It is often difficult to define encapsulated components in procedural programs. We define a comprehensive process for re-engineering procedural, legacy code to an object-oriented architecture. The process is based on a program representation graph, called a statement dependence graph. The process includes a technique to recognize potential object hierarchies, state variables and operations. Procedures are partitioned into operations by analyzing variable use-def chains. The statement dependence graph is restructured by merging cohesive parts of the graph to produce a restructured graph. From the restructured graph, we identify hierarchies of objects. The process to encapsulate the objects includes streamlining the interfaces. Copyright © 2000 John Wiley & Sons, Ltd.

There is an increasing interest in migrating legacy systems to new hardware platforms and to new software development paradigms. High maintenance costs and lack of documentation are among the challenges facing software engineers who wish to migrate such systems. The increasing emphasis on distributed systems and on the object-oriented paradigm suggests that object-oriented, component-based, distributed systems will represent a significant portion of the next generation of software systems. We present a semiautomatic, evolutionary migration methodology for legacy systems which produces an object-based distributed system. We use ISA which is a design recovery and subsystem classification technique that produces a data-cohesive hierarchical subsystem decomposition of the subject system. We adapt the subsystems to the object-oriented paradigm. We wrap and define interfaces of the subsystems in order to define components. Components are allocated to multiple sites. Finally, middleware technologies for distributed systems are used to implement the communication between components. The approach is suitable for the evolutionary migration of legacy systems since each component can be reengineered separately.

The activity of reengineering and maintaining large legacy systems involves the use of design recovery techniques to produce abstractions that facilitate the understanding of the system. We present an approach to design recovery based on data mining. This approach derives from the observation that data mining can discover unsuspected non-trivial relationships among elements in large databases. This observation suggests that data mining can be used to elicit new knowledge about the design of a subject system and that it can be applied to large legacy systems. We describe the ISA methodology which uses data mining to identify data cohesive subsystems. We were able to decompose COBOL systems into subsystems by using this approach. Our experience shows that data mining can identify data cohesive subsystems without any previous knowledge of the subject system. Furthermore, data mining can produce meaningful results regardless of system size making this approach especially appropriate to the analysis of large undocumented systems.

In this paper, we study the exploitation of statement-level parallelism in dependence cycles of Do-loops executed in a random (general) synchronization mode, with emphasis on the effect of statement ordering on parallelism level. For a dependence cycle of a single parallel loop, the parallelism exposed, in general, varies with the alignment of statements. Statement reordering (without modifying the semantics) relies on the compile-time prediction of execution-time of the loop. An improved timing formula and the derived algorithm of statement reordering in single Do loop with dependence cycles to improve the performance of parallel loops are proposed and discussed.

Formal specification languages provide assistance to solving the problem of high maintenance costs caused by ineffective communication of a system’s requirements. Using a sound mathematical basis, a formal specification language provides a precise and definitive system description that can serve as a binding contract. Additionally, the integration of the object-oriented paradigm with a formal specification language provides increased potential for software reuse, conceptually cleaner specifications and a framework for defining interfaces. To this end, there has been significant work done to extend existing specification languages to allow object-oriented specifications. This paper provides a comparison of such object-oriented specification languages, specifically, those extending Z. The paper is organized into five major sections. After a brief introduction to the concepts of formal specification languages and Z, a simple library system is defined and used as an example throughout the paper. Each of the object-oriented specification languages is introduced and classified as either using Z in an object-oriented style or providing a true object-oriented extension of Z. For each language, the specification of the example library system is presented following a brief overview of the language’s features. An in-depth comparison is made of each of the languages which provide a true object-oriented extension of Z.

FunZ, an intermediate specification language, is part of a complete methodology designed to facilitate the derivation of purely functional programs from Z specifications. FunZ is actually an extension of Haskell, yet the language also retains a Z-like flavor in that it contains notational conventions similar to those of standard Z or several object oriented variants. By combining features from both Z and Haskell, FunZ provides a bridge between Z specifications and Haskell implementations. Although the intermediate language and associated methodology target Haskell, the approach itself is general and can also be applied to other purely functional languages. The paper highlights one facet of the methodology, namely the procedure to derive concrete predicates written in FunZ from their abstract Z counterparts. In addition, by means of an example, the paper gives an overview of the translation process from Z specifications to FunZ designs.

Presents the language model InterProcess Communication with C++ (IPCC++), which is C++ extended with interprocess communication objects that support distributed memory models. The model represents an extension of the C++ programming language that introduces primitives of concurrency to C++ as objects. The model supports: the principle of orthogonality, explicit concurrency, C++'s inheritance feature, inter-object concurrency, static and dynamic process creation, a socket-based application program interface, and synchronous and asynchronous communication utilizing a typed message passing system which supports selective waiting. Features of concurrency are introduced as complete objects using the primitives of object-oriented programming languages as the primary vehicle for introduction. The underlying implementation of the components utilizes PVM (Parallel Virtual Machine), a software system that provides an abstraction of UNIX interprocess communication system calls.

During the last few years, the field of software engineering has witnessed an increased interest in formal methods and software reuse. At the same time, functional programming languages, often espoused as rapid prototyping tools, have begun to enjoy more mainstream usage. Assuming that these trends continue, software developers will need improved methods to transform existing specifications into functional implementations. In this paper, we discuss the intermediate specification language FunZ, an integral part of a methodology to produce purely functional programs from Z specifications. To illustrate the concepts of FunZ, we specify the design of a simple software system using both the Z notation and that of FunZ. FunZ itself is best described as an extension of Haskell, yet the language also retains a Z-like flavour in that it contains notational conventions similar to those of standard Z and several object-oriented variants. In addition, software design with FunZ parallels the activity in Z except that each step has functional overtones to better accommodate a final implementation in a purely functional language.

Abstract Z is a widely used, model‐oriented specification language. Haskell is a programming language that was recently developed to serve as a standard for non‐strict, purely functional languages. Although functional languages have proved to be excellent prototyping tools, Haskell was designed as a general purpose language which could be used when building large software systems. This paper develops two designs for a computerized class roll. The development begins with a description of the requirements and initial specification. The next section delineates the designs and explains how each design targets a specific Haskell data structure: design one employs sequences to model lists, whereas design two uses a Z function to describe a Haskell array. The corresponding implementations follow, along with a critical analysis of each translation from Z notation to Haskell code. The paper demonstrates that Z design schemas map well to at least two Haskell data types, namely the list and the array. Furthermore, it includes insights into how software developers might translate similar Z designs to Haskell.

DELTA, a DEsign Language To Actor, is a formal language used to enhance the design process. DELTA incorporates the concepts of object-oriented design into a design language. Once the preliminary steps of design have been completed, DELTA can be used to bridge the gap between architectural design and a detailed design specification. DELTA can be used to produce a documented design. Rapid prototyping, and reengineering are among the potential benefits to be reaped.>

Z is a popular specification language which has also been used as a design tool, although much less frequently. Haskell is a programming language that was recently developed to serve as a standard for non-strict, purely functional languages. Although functional languages have proved to be excellent prototyping tools, Haskell was designed as a general purpose language which could be employed to build large applications. In this paper, we show that the formal language Z is an effective design tool when a software system is implemented in a functional language. We trace the development of a simple system from its beginning specification written in Z to its final implementation as a Haskell program. The case study is based on a specification, the class manager's assistant, found in the literature.>

The authors discuss a software environment that automates the extraction of an object from the knowledge base and represents it in DOSL form. A prototype system to execute DOSL specifications is described. The method chose provides a translator from DOSL to ACT++.>

The process of system modeling and specification remains primarily a manual, labor-intensive task. The informality often present in initial requirements documents hinders the use of automated tools for system modeling. However, with the aid of a translator to convert the initial requirements document into a more structured representation, improved modeling techniques are possible. This article describes such a modeling technique. A system model based on the objects in the initial requirements document is generated. The technique is automated, thus ensuring that the developed model directly reflects the information present in the requirements document. The system model may be used both as a preliminary specification model and as the input into a more formal specification process. It provides a solid foundation for object-based specification and design. © 1992 John Wiley & Sons, Inc.

The increasing emphasis on software engineering in the computer science curricula directly correlates with the expansion of the area of software engineering.The increased occurrence of software engineering courses has produced significant discrepancies in the content of the courses at the undergraduate level.These discrepancies have percipitated the need for recommendations for the inclusion of software engineering in the curriculum.The recommendations presented in this paper include both the integration of software engineering principles throughout the undergraduate curriculum and the content of a separate software engineering course.The recommendations for course content are based on a survey of the contents of recently published software engineering textbooks.

Since the development of software is often done by teams, it is beneficial to include a team project in a software development course.Diverse approaches to including team projects in such courses are employed.The advantages and disadvantages of assigning a single project to the entire class over assigning each team a unique project are discussed.