Search

The field of statistical computing is rapidly developing and evolving. Shifting away from the formerly siloed landscape of mathematics, statistics, and computer science, recent advancements in statistical computing are largely characterized by a fusing of these worlds; namely, programming, software development, and applied statistics are merging in new and exciting ways. There are numerous drivers behind this advancement, including open movement (encompassing development, science, and access), the advent of data science as a field, and collaborative problem-solving, as well as practice-altering advances in subfields such as artificial intelligence, machine learning, and Bayesian estimation. In this paper, we trace this shift in how modern statistical computing is performed, and that which has recently emerged from it. This discussion points to a future of boundless potential for the field. [ABSTRACT FROM AUTHOR]

Abstract: Measuring inconsistency is crucial to effective inconsistency management in software development. A complete measurement of inconsistency should focus on not only the degree but also the significance of inconsistency. However, most of the approaches available only take the degree of inconsistency into account. The significance of inconsistency has not yet been given much needed consideration. This paper presents an approach for measuring the significance of inconsistency arising from different viewpoints in the Viewpoints framework. We call an individual set of requirements belonging to different viewpoints a combined requirements collection in this paper. We argue that the significance of inconsistency arising in a combined requirements collection is closely associated with global priority levels of requirements involved in the inconsistency. Here we assume that the global priority level of an individual requirement captures the relative importance of every viewpoint including this requirement as well as the local priority level of the requirement within the viewpoint. Then we use the synthesis of global priority levels of all the requirements in a combined collection to measure the significance of the collection. Following this, we present a scoring matrix function to measure the significance of inconsistency in an inconsistent combined requirements collection, which describes the contribution made by each subset of the requirements collection to the significance of the set of requirements involved in the inconsistency. An ordering relationship between inconsistencies of two combined requirements collections, termed more significant than, is also presented by comparing their significance scoring matrix functions. Finally, these techniques were implemented in a prototype tool called IncMeasurer, which we developed as a proof of concept. [Copyright &y& Elsevier]

There is an increase use of security driven approaches to support software development activities, such as requirements, design and implementation. The objective of this paper is to identify the existing software security approaches used in the software development lifecycle (SDLC). In order to meet our goal, we conducted a systematic mapping study to identify the primary studies on the use of software security techniques in SDLC. In total, we selected and categorized 118 primary studies. After analyzing the selected studies, we identified 52 security approaches and we categorized them in to five main categories, namely, ‘secure requirements modeling’, ‘vulnerability identification, adaption and mitigation’, ‘software security focused process’, ‘extended UML-based secure modeling profiles’, ‘non UML-based secure modeling notations’. The results show that the most frequently used approaches are static analysis and dynamic analysis that provide security checks in the coding phase. In addition, our results show that many studies in this review considered security checks around the coding stage of software development. This work will assist software development organizations in better understanding the existing software security approaches used in the software development lifecycle. It can also provide researchers with a firm basis on which to develop new software security approaches. [ABSTRACT FROM AUTHOR]

Nowadays, the majority of software systems are inherently concurrent. Anyway, internal and external concurrent activities increase the complexity of systems' behavior. Adequate architecting can significantly decrease implementation errors. This work is motivated by the desire to understand how concurrency can constrain or influence software architecting. As a result, in the paper a methodological architecting framework applied for systems with "concurrency-intensive architecture" is described. This special term is defined to emphasize architectures, in which concurrent interactions are crucial. Also in the paper potential models for each phase of architecting framework are indicated. [ABSTRACT FROM AUTHOR]

The purpose of the research described in this paper is to propose a framework and supporting tools that will help software companies to establish formalised methods that will be technically and socially sound with their needs. Following the framework the companies can asses and improve their existing ways of working, capture them into formalised methods and continuously enrich them based on the past development experiences. Furthermore, the formalised methods that are designed based on the suggested framework are flexible and can be automatically adjusted by the supporting tools to suite circumstances of a particular project or team. This paper describes the framework philosophy and its tool support. [ABSTRACT FROM AUTHOR]

In 1980, System Development Corporation (SDC) delivered software for a modern air defense system (ADS) for a foreign country. Development of the ADS software was a successful SCD project where all products were delivered within budget and within an ambitious 25 month schedule. This paper describes SDC's approach and experience in developing ADS software. SDC's software development approach included the first time use of an oft-the-shelf operating system for a major air defense system, the application of a selective set of modern software development techniques, and use of a matrix management structure. SDC's successful application on ADS of a commercial (`pent- log system, a higher order language, a Program Design Language, a Pro- gram Production Library, structured walk-throughs, structured programming techniques, incremental build implementation and test procedures, interactive development, and word processing is described. A discussion of the advantages realized and difficulties encountered in the ADS matrix management structure is presented. The paper concludes with a summary of how SDC will develop software on future projects as a result of its experience on ADS. [ABSTRACT FROM AUTHOR]

In computer science, functional orbits – i.e., tracks left by the iterations of a function – in a finite domain naturally appear at a high or a low level. This paper introduces a Coq logical orbit framework, the purpose of which is to help rigorously developing software systems with some complex data structures from specification to implementation. The result is a Coq library of orbit concepts formalized as definitions, lemmas and theorems. Most of them are inspired by our previous work in geometric modelling, where combinatorial hypermaps were used to describe surface subdivisions appearing in computational geometry problems, e.g., building convex hulls or Delaunay diagrams. Now, this domain remains a reference for us, but our results are drastically extended and usable in other computer science areas. The proof of Floyd's cycle-detection algorithm, known as “the tortoise and the hare”, confirms that point. The library contains operations to observe, traverse and update orbits – addition, deletion, mutation, transposition – with proofs of their behavior. It focuses on the important case where the involved function is a partial injection. In this case, it defines a connectivity relationship and evaluates the variation of the number of connected components during updates. [ABSTRACT FROM AUTHOR]

The University of Computer Sciences is responsible for the training of computer professionals as well as for the direct participation in the development of national computerization projects and export commitments as part of the industry. The integration model of formation-production- research processes expresses that students must perform a role in the software development process, linked to a real project. The objective of this paper is to establish a proposal of a methodology that systematizes the process of assigning students to a role. It has as a starting point the recruitment processes in the industry and a model for the comparison and prediction of student's behavior in each role. The methods used were document analysis, systemic method, among others. The analysis of the impact of the results of the methodology is analyzed and discussed. [ABSTRACT FROM AUTHOR]

Computer science is a predominantly male field of study. Women face barriers while trying to insert themselves in the study of computer science. Those barriers extend to when women are exposed to the professional area of computer science. Despite decades of social fights for gender equity in Science, Technology, Engineering, and Mathematics (STEM) education and in computer science in general, few women participate in computer science, and some of the reasons include gender bias and lack of support for women when choosing a computer science career. Open source software development has been increasingly used by companies seeking the competitive advantages gained by team diversity. This diversification of the characteristics of team members includes, for example, the age of the participants, the level of experience, education and knowledge in the area, and their gender. In open source software projects women are underrepresented and a series of biases are involved in their participation. This paper conducts a systematic literature review with the objective of finding factors that could assist in increasing women's interest in contributing to open source communities and software development projects. The main contributions of this paper are: (i) identification of factors that cause women's lack of interest (engagement), (ii) possible solutions to increase the engagement of this public, (iii) to outline the profile of professional women who are participating in open source software projects and software development projects. The main findings of this research reveal that women are underrepresented in software development projects and in open source software projects. They represent less than 10% of the total developers and the main causes of this underrepresentation may be associated with their workplace conditions, which reflect male gender bias. [ABSTRACT FROM AUTHOR]

Abstract: Although component middleware is increasingly used to develop distributed, real-time and embedded (DRE) systems, it poses new fault-tolerance challenges, such as the need for efficient synchronization of internal component state, failure correlation across groups of components, and configuration of fault-tolerance properties at the component granularity level. This paper makes three contributions to R&D on component-based fault-tolerance. First, it describes the COmponent Replication based on Failover Units (CORFU) component middleware, which provides fail-stop behavior and fault correlation across groups of components treated as an atomic unit in DRE systems. Second, it describes how CORFU’s Components with HEterogeneous State Synchronization (CHESS) module provides mechanisms for real-time aware state transfer and synchronization in CORFU. Third, we empirically evaluate the client failover and group shutdown capabilities of CORFU and its CHESS module and compare/contrast it with existing object-oriented fault-tolerance methods. Our results show that component middleware (1) has acceptable fault-tolerance performance for DRE systems, (2) allows timely recovery while considering failure location, size, and functional topology of the group, and finally (3) eases the burden of application development by providing middleware support for fault-tolerance at the component level. [Copyright &y& Elsevier]

In this paper, we provide an analysis of three pairs of professional software designers, each working on a provided design problem. To understand these sessions, we track the ideas that were generated, relate them to one another, and categorize them according to the subject being discussed. This data is then used to divide the sessions into design cycles, each of which represents a period of focus on a given aspect of the system being designed. We observe that the designers often consider two subjects at a time, and rotate through subjects in an effort to develop them evenly. The sessions are also characterized by a great deal of repetition, as the designers regularly reconsider previously stated ideas in new contexts. [ABSTRACT FROM AUTHOR]

Several recent studies indicate that many industrial applications exhibit poor quality in the design of exception-handling. To improve the quality of error-handling, we need to understand the problems and obstacles that developers face when designing and implementing exception-handling. In this paper, we present our research on understanding the viewpoint of developers--novices and experts--toward exception-handling. First, we conducted a study with novice developers in industry. The study results reveal that novices tend to ignore exceptions because of the complex nature of exception-handling. Then, we conducted a second study with experts in industry to understand their perspective on exception-handling. The study results show that, for experts, exception-handling is a crucial part in the development process. Experts also confirm the novices' approach of ignoring exception-handling and provide insights as to why novices do so. After analyzing the study data, we identified factors that influence experts' strategy selection process for handling exceptions and then built a model that represents a strategy selection process experts use to handle exceptions. Our model is based on interacting modules and fault scope. We conclude with some recommendations to help novices improve their understanding of exception-handling. [ABSTRACT FROM AUTHOR]

The majority of an engineer's time in the software industry is spent working with other programmers. Agile methods of software development like eXtreme Programming strongly rely upon practices like daily meetings and pair programming. Hence, the need to learn the skill of working collaboratively is of primary importance for software developers. During computing education, this may be particularly important for the stronger students as they may be the ones who least desire to work with other programmers. Further, programmers need to develop the ability to comprehend the programs developed by others and, also, to write programs that can be easily comprehended by other programmers. Increasing dependence on large amounts of Free and Open Source Software (FOSS) makes this even more crucial. Until a decade ago, one weakness in the typical undergraduate experience was the failure to train students to work with other programmers -- in fact it was often considered a form of cheating. Over time, researchers have the need to find a way to allow students to work together within clearly defined boundaries that would be an acceptable practice. A traditional form of pair programming based on the driver-navigator model has been successful in many introductory computer science courses. Its success is noticeable in better performance in computer science assignments, increased team work in and outside class, enhanced learning, and decreased frustration (Cliburn, 2003; Domino, Collins, & Hevner, 2007; McDowell, Werner, Bullock, & Fernald, 2002; Nagappan et al., 2003;Sfetsos, Stamelos, Angelis, & Deligiannis, 2009; Thomas, Ratcliffe, & Robertson, 2003; VanDeGrift, 2004; Williams & Kessler, 2003; Williams, Yang, Wiebe, Ferzli, & Miller, 2002). However, pair programming has its weaknesses too (Bevan, Werner, & McDowell, 2002, Cliburn, 2003; VanDeGrift, 2004). Most of the experiments have the shortcoming of not having been able to create a convincing need for collaboration. Such a situation results in students sitting together, sharing a machine, but not actually collaborating with each other The objective of this paper is to propose a new framework for implementing pair programming in the classroom. Our model of collaborative pair programming is based on Dillenbourg's set of four conditions to set up an active collaborative context. We have transformed the traditional form of pair first work independently and then work on a combined task that brings together their individual tasks. The framework has been experimented within a real classroom environment for the course 'Introduction to Computer Programming' offered to first year engineering students. All the inexperienced programmers were allowed to form pairs, while all the experienced students worked as solo programmers. This was done primarily to compare the performance of experienced versus inexperienced programmers at the end of the course. This comparison helped identify if such an implementation of collaborative pair programming proved advantageous for students. The experiment was well monitored and regulated by four instructors and teaching assistants at any given time. Observations throughout the five months of the course and results from various examinations and feedback mechanisms showed that such a framework for collaborative pair programming enhanced problem solving skills, improved quality of work, and increased trust and teamwork. Final examination results for inexperienced programmers showed a marked increase in their performance when compared to results of experienced programmers. In conclusion, the new framework proved successful by helping inexperienced programmers perform at par with their experienced peers. [ABSTRACT FROM PUBLISHER]

Synthesis of behavior models from software development artifacts such as scenario-based descriptions or requirements specifications helps reduce the effort of model construction. However, the models favored by existing synthesis approaches are not sufficiently expressive to describe both universal constraints provided by requirements and existential statements provided by scenarios. In this paper, we propose a novel synthesis technique that constructs behavior models in the form of Modal Transition Systems (MTS) from a combination of safety properties and scenarios. MTSs distinguish required, possible, and proscribed behavior, and their elaboration not only guarantees the preservation of the properties and scenarios used for synthesis but also supports further elicitation of new requirements. [ABSTRACT FROM AUTHOR]

The basis of consistency check of architectural elements (components and connectors) in the generic component-based architecture is the definition of embedding and refinement relations for their internal relationships and interconnections. The ideas which are presented here constitute a guide for the automation of this architecture description using UML beginning with classes and sequence diagrams formal definition as well as consistency checking of components and connectors. This paper presents a plugin extension to Visual Paradigm which instruments this proposal. [ABSTRACT FROM AUTHOR]

Unified Modeling Language, (UML) is a standard modeling language for general purposes, however it may be extended in order to represent specific domain such component-based architectures. This paper presents an extension using a profile for generic components and connectors-based architecture. [ABSTRACT FROM AUTHOR]

Information Systems are situated in and are representations of some business or organizational domain. Hence, understanding the application domain is critical to the success of information systems development. To support domain understanding, the application domain is represented in conceptual models. The correctness of conceptual models can affect the development outcome and prevent costly rework during later development stages. This paper proposes a method to restrict the syntax of a modeling language to ensure that only possible configurations of a domain can be modeled, thus increasing the likelihood of creating correct domain models. The proposed method, based on domain ontologies, captures relationships among domain elements via constraints on the language metamodel, thus restricting the set of statements about the domain that can be generated with the language. In effect, this method creates domain specific modeling languages from more generic ones. The method is demonstrated using the Unified Modeling Language (UML). Specifically, it is applied to the subset of UML dealing with object behavior and its applicability is demonstrated on a specific modeling example. [ABSTRACT FROM AUTHOR]

Teaching future knowledge engineers, the necessary skills for designing and implementing intelligent software solutions required by business, industry and research today, is a very tall order. These skills are not easily taught in traditional undergraduate computer science lectures; nor are the practical experiences easily reinforced in laboratory sessions. In an attempt to address this issue, a software development project, designed to take students through a complete process of knowledge engineering, was introduced in an undergraduate Intelligent Systems subject. In this project, students were required to act as domain experts, knowledge engineers, programmers, end users and project manager in the production of a game-playing expert system. The paper describes the project, its objectives and development, as well as some of the benefits. [ABSTRACT FROM AUTHOR]

Over the last decade, a lot of research has been directed toward integrating performance analysis into the software development process. Traditional software development methods focus on software correctness, introducing performance issues later in the development process. This approach does not take into account the fact that performance problems may require considerable changes in design, for example, at the software architecture level, or even worse at the requirement analysis level. Several approaches were proposed in order to address early software performance analysis. Although some of them have been successfully applied, we are still far from seeing performance analysis integrated into ordinary software development. In this paper, we present a comprehensive review of recent research in the field of model-based performance prediction at software development time in order to assess the maturity of the field and point out promising research directions. [ABSTRACT FROM AUTHOR]

In this paper we describe two experiments in the verification of software standard conformance. In our experiments, we use a model-based test generator to create a test suite for parts of the POSIX™ standard and another test suite for the specification of Java™ exception handling. We demonstrate that models. derived from specifications produce better test suites than the suites specified by standards. In particular, our test suites achieved higher levels of code coverage with complete test requirements coverage. Moreover, the test suite for the Java study found code defects that were not exposed by other benchmark test suites. The effort involved in producing these models and test suites was comparable to the effort involved in developing a test suite by more conventional methods. We avoid the state space explosion problem by modeling only the external behavior of a specific feature of the standard, without modeling the details of any particular implementation. [ABSTRACT FROM AUTHOR]

Software testing is an integral, costly, and time-consuming activity in the software development life cycle. As is true for software development in general, reuse of common artifacts can provide a significant gain in productivity. In addition, because testing involves running the system being tested under a variety of configurations and circumstances, automation of execution-related activities offers another potential source of savings in the testing process. This paper explores the opportunities for reuse and automation in one test organization, describes the shortcomings of potential solutions that are available "off the shelf," and introduces a new solution for addressing the questions of reuse and automation. the Software Testing Automation Framework (STAF), a multiplatform, multilanguage approach to reuse. It is based on the concept of reusable services that can be used to automate major activities in the testing process. The design of STAF is described Also discussed is how it was employed to automate a resource-intensive test suite used by an actual testing organization within IBM. [ABSTRACT FROM AUTHOR]

Orthogonal Defect Classification (ODC) is a methodology used to classify software defects. When combined with a set of data analysis techniques designed to suit the software development process, ODC provides a powerful way to evaluate the development process and software product. In this paper, three case studies demonstrate the use of ODC to improve software testing. The first case study illustrates how a team developing a high-quality, mature product arrived at specific testing strategies aimed at reducing field defects. The second is a middleware project that identified the areas of system test that needed to be strengthened. The third describes how a very small team with an inadequate testing strategy recognized its risk in trying to meet the scheduled release and made the product more stable by postponing the release date and adding badly needed testing scenarios. All three case studies highlight how technical teams can use ODC data for objective feedback on their development processes and the evolution of their products. This feedback facilitates the identification of actions to increase the efficiency and effectiveness of development and test, resulting in improved resource management and enhanced software quality. [ABSTRACT FROM AUTHOR]

Various business considerations have led a growing number of organizations to rely on external vendors to develop software for their needs. Much of the day-to-day data from vendors are not available to the vendee, and typically the vendee organization ends up with its own system or acceptance test to validate the software. The 2000 Summer Olympics in Sydney was one such project in which IBM evaluated vendor-delivered code to ensure that all elements of a highly complex system could be integrated successfully. The readiness of the vendor-delivered code was evaluated based primarily on the actual test execution results. New metrics were derived to measure the degree of risk associated with a variety of test case failures such as functionality not enabled, bad fixes, and defects not fixed during successive iterations. The relationship of these metrics to the actual cause was validated through explicit communications with the vendor and the subsequent actions to improve the quality and completeness of the delivered code. This paper describes how these metrics can be derived from the execution data and used in a software project execution environment. Even though we have applied these metrics in a vendor-related project, the underlying concepts are useful to many software projects. [ABSTRACT FROM AUTHOR]

Formal methods have yet to achieve wide industrial acceptance for several reasons. They are not well integrated into established industrial software processes, their application requires significant abstraction and mathematical skills, and existing tools do not satisfactorily support the entire formal software development process. We have proposed a language called SOFL (Structured-Object-based-Formal Language) and a SOFL methodology for system development that attempts to address these problems using an integration of formal methods, structured methods and object-oriented methodology. Construction of a system uses structured methods in requirements analysis and specifications, and an object-based methodology during design and implementation stages, with formal methods applied throughout the development in a manner that best suits their capabilities. This paper describes the SOFL methodology, which introduces some substantial changes from current formal methods practice. A comprehensive, practical case study of an actual industrial Residential Suites Management System illustrates how SOFL is used. [ABSTRACT FROM AUTHOR]

In this paper, we demonstrate how model checking can be used to verify safety properties for event-driven systems. SCR tabular requirements describe required system behavior in a format that is intuitive, easy to read, and scalable to large systems (e.g., the software requirements for the A7 aircraft). Model checking of temporal logics has been established as a sound technique for verifying properties of hardware systems. We have developed an automated technique for formalizing the semiformal SCR requirements and for transforming the resultant formal specification onto a finite structure that a model checker can analyze. This technique was effective in uncovering violations of system invariants in both an automobile cruise control system and a water-level monitoring system. [ABSTRACT FROM AUTHOR]

The popularity of the Data Flow Diagram (DFD) specification tool in industry seems to stems from its use of intuitively defined concepts and notation. The use of such concepts and notation gives flexibility to the tool and most often results in intuitively appealing specifications. The flexibility comes at a price—the lack of a formal basis for DFD concepts and notation prohibits its use as a formal specification tool. On the other hand, a problem commonly stated as a deterrent to the use of formal specification techniques in industry is the lack of intuitive appeal in the specifications, which has led some researchers to suggest that formal specifications be supplemented with less formal, more intuitive documentations of specified functionalities. In this paper we describe a method for associating a DFD with a formal specification. The intention is to enhance the use of the DFD as a formal specification tool, thus gaining a tool that can be used to document application functionality in an understandable manner and, at the same time, be capable of producing a formal specification that can be used to rigorously investigate semantic properties of the application. [ABSTRACT FROM AUTHOR]

This paper discusses a rule-based design methodology for solving control problems. For the representation of various constraints, activities, and other dependency properties of the control problem, we are introducing and using abstract Petri nets: (APN) (an extended form of Petri net modeling) as a specification and formalism tool which can be analyzed using analysis techniques of Petri-net-based models. The APN provides a compact, consistent, and verifiable description of dynamic behavior of the system (under consideration) in a structured mode. The proposed design methodology (paradigm) supports specification, validation, and analysis through high-level interaction with the modeled system. The discussion about various steps towards the development of such a design paradigm is explained, with the help of an example. [ABSTRACT FROM AUTHOR]

In this paper, we report the results of an experimental study of software matrics for a fairly large software system used in a real-time application. We examine a number of issues, including the mutual relationship between various software metrics and, more importantly, the relationship between metrics and the development effort. We report some interesting connections between metrics and the software development effort. [ABSTRACT FROM AUTHOR]

This paper analyzes the concepts of software construction embodied in the Draco approach. The analysis relates specific aspects of Draco to particular software engineering (SE) principles and suggests future research needed to extend the approach. The purpose of this analysis is to help researchers understand Draco better and thus to enhance future research. [ABSTRACT FROM AUTHOR]

Because large-scale software development is a struggle against internal program complexity, the modules into which programs are divided play a central role in software engineering. A module encapsulating a data type allows the programmer to ignore both the details of its operations, and of Its value representations. It Is a primary strength of program proving that as modules divide a program, making it easier to understand, so do they divide its proof. Each module can he verified in isolation,, then its internal details ignored in a proof of its use, This paper describes proofs of module abstractions based on functional semantics, and contrasts this with the Alphard formalism based on Hoare logic. [ABSTRACT FROM AUTHOR]

Software development environments help programmers perform tasks related to the software development process. Different programming projects require different environments. However, handcrafting a separate environment for each project is not economically feasible. Gandalf solves this problem by permitting environment designers to generate families of software development environments semiautomatically without excessive cost. Environments generated using Gandalf address both programming environments, which help ease the programming process, and system development environments, which reduce the degree to which a soft- ware project is dependent on the good will of its members. Gandalf environments integrate programming and system development, permitting interactions not available in traditional environments. The paper covers several topics including the basic characteristics of Gandalf environments, our method for generating these environments, the structure and function of several existing Gandalf environments, and ongoing and planned research of the project. [ABSTRACT FROM AUTHOR]

Starting from a brief summary of the background and goals of developments in software engineering, this paper discusses some of the major thrusts in the future of program development and maintenance. Various national level software initiatives are discussed in this context. This is not a comparative survey of their plans and activities. Central issues addressed relate to the understandability of programming, the reuse of software, and the general problem of working with and improving a program that is already almost the one desired. This is the phase of the process after the system is "90 percent done," hence the emphasis on the "Last 10 Percent." [ABSTRACT FROM AUTHOR]

Software design is the process which translates the requirements into a detailed design representation of a software system. Good software design is a key to produce reliable and understandable software. To support software design, many techniques and tools have been developed. In this paper, important techniques for software design, including architectural and detailed design stages, are surveyed. Recent advances in distributed software system design methodologies are also reviewed. To ensure software quality, various design verification and validation techniques are also discussed. In addition, current software metrics and error-resistant software design methodologies are considered. Future research in software design is also discussed. [ABSTRACT FROM AUTHOR]

An abstract requirements specification states system requirements precisely without describing a real or a paradigm implementation. Although such specifications have important advantages, they are difficult to produce for complex systems and hence are seldom seen in the "real" programming world. This paper introduces an approach to producing abstract requirements specifications that applies to a significant class of real-world systems, including any system that must reconstruct data that have undergone a sequence of transformations. It also describes how the approach was used to produce a requirements document for SCP, a small, but nontrivial Navy communications system. The specification techniques used in the SCP requirements document are introduced and illustrated with examples. [ABSTRACT FROM AUTHOR]

The article discusses how software architecture has evolved since 2006. In the first paper written by the authors, they claimed that software architecture is a healthy engineering discipline since it follows a classic technology maturation path, which begins with research and ends with the termination of software building without the help of technology. They considered 2006 as a golden age for software architecture and predicted that the discipline is starting to mature. The authors are still convinced that software architecture is shifting from concept exploration to the application of the concepts.

In this correspondence, we point out some of the major shortcomings that we have discovered in the article titled "Factors that Impact Implementing a System Development Methodology" by Roberts et al. [9]. The article was published in the August 1998 issue of IEEE Transactions of Software Engineering. The article contains multiple problems that, if not pointed out, have the potential to lead to a state of confusion among researchers and practitioners alike. In particular, the article has the following problems: 1) The authors claim that the lack of theoretical basis for their factors is due to the fact that SDM implementation has never been studied in the literature. In fact, there is a multitude of studies very similar to that of Roberts et al. 2) The study does not meet commonly accepted standards for factor analysis procedures such as a minimum sample size ratio of 5:1, a ratio mandated even by the authors' own citations. This and other factor analysis problems lead to results that are questionable. In order to make the published article more useful to researchers and practitioners this paper corrects some of the inaccuracies in the Roberts et al.'s article by: 1) Providing a brief literature review of some articles that are similar to the Roberts et aI. study and 2) noting some of the technical inaccuracies in the data analysis procedures used by the authors so that the results can be interpreted in the proper context. [ABSTRACT FROM AUTHOR]

The conversation scheme is a promising way of developing fault-tolerant software and several mechanisms for its implementation have been proposed. In an earlier paper Tyrrell and Holding used Petri nets to design conversations. Their procedure, although correct, appears to be more complex than necessary. In this correspondence, a simplified transition identification method is proposed. Using a robot arm control program we show that the corresponding Petri net graph is simpler than the one proposed by Tyrrell and Holding, but the communication state change table is the same. It is also shown that these two methods are equivalent. [ABSTRACT FROM AUTHOR]

The article discusses the first International Conference on the Quantitative Evaluation of SysTems, entitled QEST 2004, which was held at the University of Twente in the Netherlands. Topics such as modeling formalisms and methodologies, theory, tools, and case studies, as well as performance, dependability, and safety were discussed at the conference. The review received over 80 paper submissions and narrowed them down to 28 for publication. The guest editors present several brief descriptions that are presented in this issue, including "Backward Bisimulation in Markov Chain Model Checking" and "Analysis of Restart Mechanisms in Software Systems." [ABSTRACT FROM AUTHOR]

This article introduces a series of articles on software testing and development. Hailpern and Santhanam provide formal definitions for debugging, testing and verification and show how each activity relates to the software development process. Bassin, Biyani and Santhanam describe metrics that can be applied as part of the acceptance test for vendor-developed software. The authors explain how metrics can be used to estimate the degree of risk involved in accepting a software component, based on test case execution. The paper by Butcher, Munro and Kratschmer describes case studies in which Orthogonal Defect Classification, a quantitative method used to improve processes as products evolve, was applied to a mature product, a large middleware product, and small team project. Weyuker and Avritzer introduce the performance nonscalability likelihood metric, designed to predict the likelihood that the system will fail to meet its performance goals when the workload is scaled. Loveland and colleagues report on the process, tools and techniques used to test z/OS, the operating system for the IBM zSeries processors. Edelstein and colleagues describe ConTest, a tool that both generates and executes tests for detecting synchronization problems in multithreaded Java programs.