Search

Event-based communication is used in different domains including telecommunications, transportation, and business information systems to build scalable distributed systems. Such systems typically have stringent requirements for performance and scalability as they provide business and mission critical services. While the use of event-based communication enables loosely-coupled interactions between components and leads to improved system scalability, it makes it much harder for developers to estimate the system's behavior and performance under load due to the decoupling of components and control flow. In this paper, we present our approach enabling the modeling and performance prediction of event-based systems at the architecture level. Applying a model-to-model transformation, our approach integrates platform-specific performance influences of the underlying middleware while enabling the use of different existing analytical and simulation-based prediction techniques. In summary, the contributions of this paper are: (1) the development of a meta-model for event-based communication at the architecture level, (2) a platform aware model-to-model transformation, and (3) a detailed evaluation of the applicability of our approach based on two representative real-world case studies. The results demonstrate the effectiveness, practicability and accuracy of the proposed modeling and prediction approach. [ABSTRACT FROM AUTHOR]

This paper discusses Extreme Programming (XP), a relatively new and increasingly popular `user-centred' software design approach. Extreme Programming proposes that collaborative software development should be centred on the practices of programming. That proposal contrasts strongly with more heavily instrumented, formalised and centrally managed software engineering methodologies. The paper maps the interactions of an Extreme Programming team involved in building a commercial organisational knowledge management system. Using ethnographic techniques, it analyses how this particular style of software development developed in a given locality, and how it uniquely hybridised documents, conversations, software tools and office layout in that locality. It examines some of the many artifices, devices, techniques and talk that come together as a complicated contemporary software system is produced. It argues that XP's emphasis on programming as the core activity and governing metaphor can only be understood in relation to competing overtly formal software engineering approaches and the organisational framing of software development. XP, it suggests, gains traction by re-embodying the habits of programming as a collective practice. [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]

This paper describes the development of an undergraduate degree programme in software engineering over the ten year period from 1988 to 1998. Particular emphasis is given to the fundamental principles that have been established to guide the creation and evolution of this programme during this period, and to ensure that it has been distinctively a course in software engineering rather than in any other branch of computing. To this end, the fundamental engineering characteristics of the programme are compared with those of undergraduate courses in other branches of engineering. Desirable future developments in this programme are then discussed, and finally the different principles identified in the paper are evaluated. [ABSTRACT FROM AUTHOR]

Model composition plays a central role in many software engineering activities, e.g., evolving design models to add new features. To support these activities, developers usually rely on model composition heuristics. The problem is that the models to-be-composed usually conflict with each other in several ways and such composition heuristics might be unable to properly deal with all emerging conflicts. Hence, the composed model may bear some syntactic and semantic inconsistencies that should be resolved. As a result, the production of the intended model is an error-prone and effort-consuming task. It is often the case that developers end up examining all parts of the output composed model instead of prioritizing the most critical ones, i.e., those that are likely to be inconsistent with the intended model. Unfortunately, little is known about indicators that help developers (1) to identify which model is more likely to exhibit inconsistencies, and (2) to understand which composed models require more effort to be invested. It is often claimed that software systems remaining stable over time tends to have a lower number of defects and require less effort to be fixed than unstable systems. However, little is known about the effects of software stability in the context of model evolution when supported by composition heuristics. This paper, therefore, presents an exploratory study analyzing stability as an indicator of inconsistency rate and resolution effort on model composition activities. Our findings are derived from 180 compositions performed to evolve design models of three software product lines. Our initial results, supported by statistical tests, also indicate which types of changes led to lower inconsistency rate and lower resolution effort. [ABSTRACT FROM AUTHOR]

To predict the performance of an application, it is crucial to consider the performance of the underlying infrastructure. Thus, to yield accurate prediction results, performance-relevant properties and behaviour of the infrastructure have to be integrated into performance models. However, capturing these properties is a cumbersome and error-prone task, as it requires carefully engineered measurements and experiments. Existing approaches for creating infrastructure performance models require manual coding of these experiments, or ignore the detailed properties in the models. The contribution of this paper is the Goal-oriented INfrastructure Performance EXperiments ( Ginpex) approach, which introduces goal-oriented and model-based specification and generation of executable performance experiments for automatically detecting and quantifying performance-relevant infrastructure properties. Ginpex provides a metamodel for experiment specification and comes with predefined experiment templates that provide automated experiment execution on the target platform and also automate the evaluation of the experiment results. We evaluate Ginpex using three case studies, where experiments are executed to quantify various infrastructure properties. [ABSTRACT FROM AUTHOR]

The accuracy of performance-prediction models is crucial for widespread adoption of performance prediction in industry. One of the essential accuracy-influencing aspects of software systems is the dependence of system behaviour on a configuration, context or history related state of the system, typically reflected with a (persistent) system attribute. Even in the domain of component-based software engineering, the presence of state-reflecting attributes (the so-called internal states) is a natural ingredient of the systems, implying the existence of stateful services, stateful components and stateful systems as such. Currently, there is no consensus on the definition or method to include state-related information in component-based prediction models. Besides the task to identify and localise different types of stateful information across component-based software architecture, the issue is to balance the expressiveness and complexity of prediction models via an effective abstraction of state modelling. In this paper, we identify and classify stateful information in component-based software systems, study the performance impact of the individual state categories, and discuss the costs of their modelling in terms of the increased model size. The observations are formulated into a set of heuristics-guiding software engineers in state modelling. Finally, practical effect of state modelling on software performance is evaluated on a real-world case study, the SPECjms2007 Benchmark. The observed deviation of measurements and predictions was significantly decreased by more precise models of stateful dependencies. [ABSTRACT FROM AUTHOR]

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]

In this paper, we wish to advocate that departments of computer science put emphasis on teaching programming and software engineering based on formal methods; and more emphasis on research into formal methods for the trustworthy development of software. We also wish to advocate that the concepts of domain science and domain engineering become an indispensable part of the science of informatics and of software engineering. [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]

To achieve better software quality, to shorten software development time and to lower development costs, software engineers are adopting generative reuse as a software design process. The usage of generic components allows increasing reuse and design productivity in software engineering. Generic component design requires systematic domain analysis to identify similar components as candidates for generalization. However, component feature analysis and identification of components for generalization usually is done ad hoc. In this paper, we propose to apply a data visualization method, called Multidimensional Scaling (MDS), to analyze software components in the multidimensional feature space. Multidimensional data that represent syntactical and semantic features of source code components are mapped to 2D space. The results of MDS are used to partition an initial set of components into groups of similar source code components that can be further used as candidates for generalization. STRESS value is used to estimate the generalizability of a given set of components. Case studies for Java Buffer and Geom class libraries are presented. [ABSTRACT FROM AUTHOR]

Abstract: Ensuring model quality is a key success factor in many computer science areas, and becomes crucial in recent software engineering paradigms like the one proposed by model-driven software development. Tool support for measurements and redesigns becomes essential to help developers improve the quality of their models. However, developing such helper tools for the wide variety of (frequently domain specific) visual notations used by software engineers is a hard and repetitive task that does not take advantage from previous developments, thus being frequently forgotten. In this paper we present our approach for the visual specification of measurements and redesigns for Domain Specific Visual Languages (DSVLs). With this purpose, we introduce a novel DSVL called SLAMMER that contains generalisations of some of the more used types of internal product measurements and redesigns. The goal is to facilitate the task of defining measurements and redesigns for any DSVL, as well as the generation of tools from such specification reducing or eliminating the necessity of coding. We rely on the use of visual patterns for the specification of the relevant elements for each measurement and redesign type. In addition, SLAMMER allows the specification of redesigns either procedurally or by means of graph transformation rules. These redesigns can be triggered when the measurements reach a certain threshold. These concepts have been implemented in the meta-modelling tool AToM3. In this way, when a DSVL is designed, it is possible to specify measurements and redesigns that will become available in the final modelling environment generated for the language. As an example, we show a case study in the web modelling domain. [Copyright &y& Elsevier]

State machines, represented by statecharts or state machine diagrams, are an important formalism for behavioural modelling. According to the research literature, the most popular statechart formalisms appear to be Classical, UML, and that implemented by R hapsody. These three formalisms seem to be very similar; however, there are several key syntactic and semantic differences. These differences are enough that a model written in one formalism could be ill-formed in another formalism. Worse, a model from one formalism might actually be well-formed in another, but be interpreted differently due to the semantic differences. This paper summarizes the results of an informal comparative study of these three formalisms with the help of several illustrative examples. We present a classification of the differences according to the nature of potential problems caused by each difference. In addition, for each difference we discuss how translation between formalisms can be achieved, if at all. [ABSTRACT FROM AUTHOR]

Product quality is directly related to how well that product meets the customer’s needs and intents. Therefore, the ability to capture customer requirements correctly and succinctly is paramount. Unfortunately, within most software development frameworks requirements elicitation, recording and evaluation are some of the more ill-defined and least structured activities. To help address such inadequacies, we propose a requirements generation model (RGM) that (a) decomposes the conventional “requirements analysis” phase into sub-phases which focus and refine requirement generation activities, (b) bounds and structures those activities to promote a more effective generation process, and (c) implements a monitoring methodology to assist in detecting deviations from well-defined procedures intended to support the generation of requirements that meet the customer’s intent. The RGM incorporates “lessons learned” from a preliminary study that concentrated on identifying where and how miscommunication and requirements omission occur. An industry study (also reported in this paper) attests to the effectiveness of the RGM. The results of that study indicate that the RGM helps (a) reduce the late discovery of requirements, (b) reduce the slippage in milestone completion dates, and (c) increase customer and management satisfaction levels. [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]

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]

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]

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]

Domain knowledge is the soul of software systems. After decades of software development, domain knowledge has reached a certain degree of saturation. The recovery of domain knowledge from source code is beneficial to many software engineering activities, in particular, software evolution. In the real world, the ambiguous appearance of domain knowledge embedded in source code constitutes the biggest barrier to recovering reliable domain knowledge. In this paper, we introduce an innovative approach to recovering domain knowledge with enhanced reliability from source code. In particular, we divide domain knowledge into interconnected knowledge slices and match these knowledge slices against the source code. Each knowledge slice has its own authenticity evaluation function which takes the belief of the evidence it needs as input and the authenticity of the knowledge slice as output. Moreover, the knowledge slices are arranged to exchange beliefs with each other through interconnections, i.e. concepts, so that a better evaluation of the authenticity of these knowledge slices can be obtained. The decision on acknowledging recovered knowledge slices can therefore be made more easily. Our approach, rooted as it is in cognitive science and social psychology, is also widely applicable to other knowledge recovery tasks. [ABSTRACT FROM AUTHOR]

As software technologies advance, the software community uses the newest and most powerful technology and associated notations. However, mapping software with a set of notations that would survive the test of time is becoming increasingly difficult. A survey of current methodologies indicates that half-lives of various software notations are short. The dependence of software notations on programming languages and environment specific methodologies often makes these notations obsolete. In this paper, development of a standard set of software notations that is independent of programming paradigms, yet extensible enough to accommodate programming needs, is proposed. [ABSTRACT FROM AUTHOR]

The contribution of this paper is three empirical evaluations of a reference model for the practice of software reuse. Our research thesis is that software development based upon a software reuse reference model improves quality of products, productivity of processes and product time-to-market for many software development enterprises. The definition and investigation of such a model has been carried out using three steps. First, the reference model is developed based on existing software reuse concepts. Second, this reference model is empirically evaluated using three studies: one using a survey method, one using a case studies method, and one using a legacy studies method. Third, the impact of the reference model on software development productivity, quality, and time-to-market is empirically derived. [ABSTRACT FROM AUTHOR]

This paper summarizes several classes of software cost estimation models and techniques: parametric models, expertise-based techniques, learning-oriented techniques, dynamicsbased models, regression-based models, and composite-Bayesian techniques for integrating expertise-based and regression-based models. Experience to date indicates that neural-net and dynamics-based techniques are less mature than the other classes of techniques, but that all classes of techniques are challenged by the rapid pace of change in software technology. The primary conclusion is that no single technique is best for all situations, and that a careful comparison of the results of several approaches is most likely to produce realistic estimates. [ABSTRACT FROM AUTHOR]

ASTRAL is a formal specification language for real-time systems. It is intended to support formal software development and, therefore, has been formally defined. The structuring mechanisms in ASTRAL allow one to build modularized specifications of complex systems with layering. A real-time system is modeled by a collection of state machine specifications and a single global specification. This paper discusses the ASTRAL Software Development Environment (SDE), which is an integrated set of design and analysis tools based on the ASTRAL formal framework. The tools that make up the support environment are a syntax-directed editor, a specification processor, a verification condition generator, a browser kit, a model checker, and a mechanical theorem prover. [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]

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]

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]

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]

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]

A project course in software engineering is often part of the curriculum in computer engineering or computer science. This paper studies the relationship between academic and industrial projects in software engineering. The purpose is to compare the practices followed in a project-course approach with the practices of professional software engineers. The approach is to compare the measurements obtained from academic and industrial projects. The critical factors regarding the process, the people and the project are discussed. The structure of the software processes and the measurement tools are presented. The data analyses show that the academic projects are found to be strongly dominated by programming activities. Based on the data from the industrial projects, we formulate seven recommendations to improve the software engineering practices in academic projects. They are related to management, predevelopment, development, testing, reviews documentation and team activities. The concluding remarks discuss some of the actions that could be taken to improve academic projects. [ABSTRACT FROM AUTHOR]

This paper describes how we have modified a software engineering stream within a computer science course to include broader concepts of systems engineering. We justify this inclusion by showing how many reported problems with large systems are not just software problems but relate to system issues such as hardware and operational processes. We describe what we mean by ‘systems engineering’ and go on to discuss the particular course structure which we have developed. We explain, in some detail, the contents of two specific systems engineering courses (Software Intensive Systems Engineering and Critical Systems Engineering) and discuss the problems and challenges we have faced in making these changes. In the appendix, we provide details of the case studies which are used as linking themes in our courses. [ABSTRACT FROM AUTHOR]

Software engineering education has a 30-year history. It is a story of academics struggling to fulfill industry needs with almost no support from computer science curriculum designers. It is a story of industry finally winning over some of academia to teach software engineering rather than vanilla computer science. It is a story of a discipline still incomplete, but having made great strides in the last decade. This paper discusses the succeeding eras of software engineering education, from lone teachers to master's curricula to undergraduate degree programs. Even though the maturity of the discipline is as yet unattained, it will achieve adult status through practice, not by waiting for academia to glacially catch up. [ABSTRACT FROM AUTHOR]

Programmes in “Software Engineering” have become a source of contention in many universities. Some Computer Science departments, many of which have used that phrase to describe individual courses for decades, claim software engineering as part of their discipline. However, Engineering faculties claim “Software Engineering” as a new speciality in the family of engineering disciplines. This paper discusses the differences between traditional computer science programmes and most engineering programmes and argues that we need programmes that follow the traditional engineering approach to professional education and educate engineers whose speciality within engineering is software construction. One such programme is described. [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]

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.