Search

Open-science initiatives have gained substantial momentum in computer science, and particularly in software-engineering research. A critical aspect of open-science is the public availability of artifacts (e.g., tools), which facilitates the replication, reproduction, extension, and verification of results. While we experienced that many artifacts are not publicly available, we are not aware of empirical evidence supporting this subjective claim. In this article, we report an empirical study on software artifact papers (SAPs) published at the International Conference on Software Engineering (ICSE), in which we investigated whether and how researchers have published their software artifacts, and whether this had scientific impact. Our dataset comprises 789 ICSE research track papers, including 604 SAPs (76.6 %), from the years 2007 to 2017. While showing a positive trend towards artifact availability, our results are still sobering. Even in 2017, only 58.5 % of the papers that stated to have developed a software artifact made that artifact publicly available. As we did find a small, but statistically significant, positive correlation between linking to artifacts in a paper and its scientific impact in terms of citations, we hope to motivate the research community to share more artifacts. With our insights, we aim to support the advancement of open science by discussing our results in the context of existing initiatives and guidelines. In particular, our findings advocate the need for clearly communicating artifacts and the use of non-commercial, persistent archives to provide replication packages. [ABSTRACT FROM AUTHOR]

This document is a guest editorial for a special issue of the journal "Programming & Computer Software" titled "Recent Trends on Advanced Computing: The Converging Technologies." The issue features research and practical implementation results from researchers and industry experts in computer science, engineering, and technology. The papers cover a range of topics including microservices, software quality, user engagement on social media, non-functional requirements, medical software architecture, fallacies in political speeches, intelligent learning environments, and more. The guest editors for this special issue are Prof. Dr. Andrei Tchernykh, Prof. Reyes Juárez Ramírez, Dr. Esteban Mocskos, and Prof. Sergio Nesmachnow. [Extracted from the article]

In most areas of computer science (CS), and in the software domain in particular, international conferences are as important as journals as a venue to disseminate research results. This has resulted in the creation of rankings to provide quality assessment of conferences (specially used for academic promotion purposes) like the well-known CORE ranking created by the Computing Research and Education Association of Australasia. In this paper we analyze 102 CORE-ranked conferences in the software area (covering all aspects of software engineering, programming languages, software architectures and the like) included in the DBLP dataset, an online reference for computers science bibliographic information. We define a suite of metrics focusing on the analysis of the co-authorship graph of the conferences, where authors are represented as nodes and co-authorship relationships as edges. Our aim is to first characterize the patterns and structure of the community of researchers in software conferences. We then try to see if these values depend on the quality rank of the conference justifying this way the existence of the different classifications in the CORE-ranking system. [ABSTRACT FROM AUTHOR]

A systematic literature review (SLR) is an empirical method used to provide an overview of existing knowledge and to aggregate evidence within a domain. For computer science, several threats to the completeness of such reviews have been identified, leading to recommendations and guidelines on how to improve their quality. However, few studies address to what extent researchers can replicate an SLR. To conduct a replication, researchers have to first understand how the set of primary studies has been identified in the original study, and can ideally retrieve the same set when following the reported protocol. In this article, we focus on this initial step of a replication and report a two-fold empirical study: Initially, we performed a tertiary study using a sample of SLRs in computer science and identified what information that is needed to replicate the searches is reported. Based on the results, we conducted a descriptive, multi-case study on digital libraries to investigate to what extent these allow replications. The results reveal two threats to replications of SLRs: First, while researchers have improved the quality of their reports, relevant details are still missing—we refer to a reporting threat. Second, we found that some digital libraries are inconsistent in their query results—we refer to a searching threat. While researchers conducting a review can only overcome the first threat and the second may not be an issue for all kinds of replications, researchers should be aware of both threats when conducting, reviewing, and building on SLRs. [ABSTRACT FROM AUTHOR]

This document is a guest editorial for a special section in the journal "Software & Systems Modeling." The special section features revised and extended versions of selected papers from the 20th International Conference on Software Engineering and Formal Methods (SEFM'22), which was held in Berlin, Germany in September 2022. The SEFM conference series aims to advance the state of the art in formal methods and their integration into practical software engineering methods and tools. The special section includes papers on topics such as user-centric analysis, automated generation of finite automata, formal specifications of smart contracts, distributed verification of programs, and abstraction-based verification of neural networks. The authors express their gratitude to the authors and reviewers for their contributions and thank Springer for their support in publishing the special section. [Extracted from the article]

Various computing subdisciplines, such as computer science and software engineering, each have their own curricular guidelines. They can be very difficult to understand and compare for people such as prospective students, industry personnel, and even faculty members. This is compounded by a lack of information surrounding undergraduate computing curricular topics via visual methods. This paper describes two experimental activities where the objective is to explore the possibility of obtaining quantitative data sets necessary for visualization, one based on competencies and the other based on knowledge areas. Both activities were based on surveys. The results from the first activity showed that a consensus interpretation could be obtained for the knowledge, skills, and dispositions implied by the competency descriptions, although not as strongly for dispositions. The second activity resulted in a table of knowledge areas with minimum and maximum weights for six computing subdisciplines. Finally, this paper also shows two examples of how users can explore the various curricular guidelines through visualization. [ABSTRACT FROM AUTHOR]

Abstract  This paper emphasizes the importance of defining processes rigorously, completely, clearly, and in detail in order to support the complex projects that are essential to the modern world. The paper argues that such process definitions provide needed structure and context for the development of effective software systems. The centrality of process is argued by enumerating seven key ways in which processes and their definitions are expected to provide important benefits to society. The paper provides an example of a process formalism that makes good progress towards the difficult goal of being simultaneously rigorous, detailed, broad, and clear. Early experience suggests that these four key characteristics of this formalism do indeed seem to help it to support meeting the seven key benefits sought from process definitions. Additional research is suggested in order to gain more insights into needs in the area of process definition formalisms. [ABSTRACT FROM AUTHOR]

Abstract??If empirical software engineering is to grow as a valid scientific endeavor, the ability to acquire, use, share, and compare data collected from a variety of sources must be encouraged. This is necessary to validate the formal models being developed within computer science. However, within the empirical software engineering community this has not been easily accomplished. This paper analyses experiences from a number of projects, and defines the issues, which include the following: (1) How should data, testbeds, and artifacts be shared? (2) What limits should be placed on who can use them and how? How does one limit potential misuse? (3) What is the appropriate way to credit the organization and individual that spent the effort collecting the data, developing the testbed, and building the artifact? (4) Once shared, who owns the evolved asset? As a solution to these issues, the paper proposes a framework for an empirical software engineering artifact agreement. Such an agreement is intended to address the needs for both creator and user of such artifacts and should foster a market in making available and using such artifacts. If this framework for sharing software engineering artifacts is commonly accepted, it should encourage artifact owners to make the artifacts accessible to others (gaining credit is more likely and misuse is less likely). It may be easier for other researchers to request artifacts since there will be a well-defined protocol for how to deal with relevant matters. [ABSTRACT FROM AUTHOR]

Underrepresentation of women in computer science (CS) increasingly demands the necessity to find and enhance current learning engagement approaches to bring more women into computing fields. Some researchers have been exploring the influence of gamification on female students as one of these possible learning engagement strategies. Gamification refers to the introduction of video game elements into non-game activities to enhance engagement and motivation. Previous studies have reported mixed results of the impact of gamification on women. In this study, we introduce SEP-CyLE (Software Engineering and Programming Cyberlearning Environment), an online gamified tool that was designed to provide supplemental computing content to students. This paper presents a convergent mixed-methods study guided by social identity theory and self-efficacy to understand women's experiences with this gamified tool. More specifically, this study explores virtual points' and leaderboards' effects on CS identity development, self-efficacy, and performance. The results show that virtual points and the leaderboard contributed to improved performance for students of all genders, suggesting that gamification is a gender-neutral learning engagement strategy that improves female students' performance as much as male students. Regardless of improved performance, most women did not actively enjoy or were motivated by the virtual points or leaderboard in SEP-CyLE. Additionally, gamification had no significant impact on CS identity development or self-efficacy constructs and had little to no impact on women's interest and engagement in the field of computing. [ABSTRACT FROM AUTHOR]

The article focuses on the computer industry. It offers a history of Computer Science and software engineering which concentrates on virtual reality and related areas. The author shares the realization and the idea of abstraction that computer programming is not an easy job. The author relates his experience with Computer Science and software engineering during his undergraduate project at the University of Limerick on the subject of software development where the book changed the direction of his career for both its technical content and for sentimental reasons.

The term software engineering has had a problematic history since its appearance in the 1960s. At first seen as a euphemism for programming, it has now come to encompass a wide range of activities. At its core lies the desire of software developers to mimic 'real' engineers, and claim the status of an engineering discipline. Attempts to establish such a discipline, however, confront pressing commercial demands for cheap and timely software products. This paper briefly examines some of the claims for the engineering nature of software development, before moving to argue that the term 'engineering' itself carries with it some unwanted baggage. This contributes to the intellectual quandary in which software development finds itself, and this is exacerbated by many writers who rely upon and propagate a mythical view of 'engineering.' To complicate matters further, our understanding of software development is grounded in a series of metaphors that highlight some key aspects of the field, but push other important issues into the shadows. A rereading of Brooks' “No Silver Bullet” paper indicates that the metaphorical bases of software development have been recognized for some time. They cannot simply be jettisoned, but perhaps they need widening to incorporate others such as Brooks' concepts of growth and nurture of software. Two examples illustrate the role played by metaphor in software development, and the paper concludes with the idea that perhaps we need to adopt a more critical stance to the 'engineering' roots of our endeavours. [ABSTRACT FROM AUTHOR]

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]

The Internet is undergoing a tremendous change towards the globalized computing environment. Due to the open, dynamic and uncontrollable natures of the Internet, software running in the Internet computing environment has some new features, which bring challenges to current software technologies in terms of software model, software operating platform, software engineering approaches and software quality. Researchers in China have proposed the term 'Internetware' to present the emerging software paradigm. Sponsored by the National Basic Research 973 Program, several research practices have been done on the Internetware in the past decade. This paper summarizes the progress and status of the Internetware researches. A technical solution framework for the Internetware paradigm is proposed from four aspects: the Internetware software model defines what the Internetware is to be; the Internetware middleware determines how to run the Internetware applications; the engineering methodology determines how to develop the Internetware applications; the Internetware quality assurance determines how well the Internetware applications can perform. The paper also discusses the ongoing research issues and future trends of Internetware. [ABSTRACT FROM AUTHOR]

We discuss means for describing domains. We do so on the background of the example of part I of the present (Part II) paper and in its discussion. The discussion amounts to a proposal for a base description ontology. The discussion borders between computer science and an emerging Philosophy of Informatics. As such it is very tentative. The present discussion might inspire better minds to put this border area on a stronger footing. [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]

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]

Conceptual modelling is situated in the broader view of information systems requirements engineering. Requirements Engineering (RE) explores the objectives of different stakeholders and the activities carried out by them to meet these objectives in order to derive purposeful system requirements and therefore lead to better quality systems, i.e., systems that meet the requirements of their users. Thus RE product models use concepts for modelling these instead of concepts like data, process, events, etc., used in conceptual models. Since the former are more stable than the latter, requirements engineering manages change better. The paper gives the rationale for extending traditional conceptual models and introduces some RE product models. Furthermore, in contrast to conceptual modelling, requirements engineering lays great stress on the engineering process employed. The paper introduces some RE process models and considers their effect on tool support. [ABSTRACT FROM AUTHOR]

Developing and maintaining large-scale software systems is very expensive. The concept of software architecture has recently emerged as a way to support the evolution of large-scale software systems. Several architecture description languages (ADLs) have been proposed to support the specification of software architectures. However, current ADLs do not provide strong support for the analysis of software architecture properties. On the other hand, various analysis tools have been developed for system analysis in the formal verification community. In this paper, we make two contributions. First, for the tools which are applicable to the property analysis of software architectures, we establish a connection between different analysis tools and the software systems modeled by architecture description languages. Second, we conduct experiments to study the performance of four different analysis tools in detecting deadlocks. Based on these experiments, we are able to compare the efficiency of these analysis tools in verifying certain software properties. [ABSTRACT FROM AUTHOR]

This paper describes a methodology for the specification and analysis of distributed real-time systems using the toolset called PARAGON. PARAGON is based on the Communicating Shared Resources paradigm, which allows a real-time system to be modeled as a set of communicating processes that compete for shared resources. PARAGON supports both visual and textual languages for describing real-time systems. It offers automatic analysis based on state space exploration as well as user-directed simulation. Our experience with using PARAGON in several case studies resulted in a methodology that includes design patterns and abstraction heuristics, as well as an overall process. This paper briefly overviews the communicating shared resource paradigm and its toolset PARAGON, including the textual and visual specification languages. The paper then describes our methodology with special emphasis on heuristics that can be used in PARAGON to reduce the state space. To illustrate the methodology, we use examples from a real-life system case study. [ABSTRACT FROM AUTHOR]

One of the most intractable problems in software is getting engineers to consistently use effective methods. The Software Engineering Institute (SEI) has worked on this problem for a number of years and has developed effective methods for addressing it. This paper describes these methods and shows what they have accomplished with several hundred students and working engineers. After first describing the problem of changing engineers' practices, the paper discusses the logic engineers typically follow in deciding what methods to use. Next is a description of the Personal Software Process (PSP) and the Team Software Process (TSP). Finally, the implications of SEI's experiences with the PSP and TSP are described, with particular emphasis on software engineering and computer science education. [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]

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]

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]

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]

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]

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]

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]

Test-driven development (TDD) is a style of development named for its most visible characteristic: the design and implementation of test cases prior to the implementation of the code required to make them pass. Many claims have been made for TDD: that it can improve implementation as well as design quality, that it can improve productivity, that it results in 100% coverage, and so forth. However, research to validate these claims has yielded mixed and sometimes contradictory results. We believe that at least part of the reason for these results stems from differing interpretations of the TDD development style, along with an inability to determine whether programmers actually follow whatever definition of TDD is in use. Zorro is a system designed to automatically determine whether a developer is complying with an operational definition of Test-Driven Development (TDD) practices. Automated recognition of TDD can benefit the software development community in a variety of ways, from inquiry into the "true nature" of TDD, to pedagogical aids to support the practice of test-driven development, to support for more rigorous empirical studies on the effectiveness of TDD in both laboratory and real world settings. This paper describes the Zorro system, its operational definition of TDD, the analyses made possible by Zorro, two empirical evaluations of the system, and an attempted case study. Our research shows that it is possible to define an operational definition of TDD that is amenable to automated recognition, and illustrates the architectural and design issues that must be addressed in order to do so. Zorro has implications not only for the practice of TDD, but also for software engineering "micro-process" definition and recognition through its parent framework, Software Development Stream Analysis. [ABSTRACT FROM AUTHOR]

Abstract  Standard practice in building models in software engineering normally involves three steps: collecting domain knowledge (previous results, expert knowledge); building a skeleton of the model based on step 1 including as yet unknown parameters; estimating the model parameters using historical data. Our experience shows that it is extremely difficult to obtain reliable data of the required granularity, or of the required volume with which we could later generalize our conclusions. Therefore, in searching for a method for building a model we cannot consider methods requiring large volumes of data. This paper discusses an experiment to develop a causal model (Bayesian net) for predicting the number of residual defects that are likely to be found during independent testing or operational usage. The approach supports (1) and (2), does not require (3), yet still makes accurate defect predictions (an R 2 of 0.93 between predicted and actual defects). Since our method does not require detailed domain knowledge it can be applied very early in the process life cycle. The model incorporates a set of quantitative and qualitative factors describing a project and its development process, which are inputs to the model. The model variables, as well as the relationships between them, were identified as part of a major collaborative project. A dataset, elicited from 31 completed software projects in the consumer electronics industry, was gathered using a questionnaire distributed to managers of recent projects. We used this dataset to validate the model by analyzing several popular evaluation measures (R 2, measures based on the relative error and Pred). The validation results also confirm the need for using the qualitative factors in the model. The dataset may be of interest to other researchers evaluating models with similar aims. Based on some typical scenarios we demonstrate how the model can be used for better decision support in operational environments. We also performed sensitivity analysis in which we identified the most influential variables on the number of residual defects. This showed that the project size, scale of distributed communication and the project complexity cause the most of variation in number of defects in our model. We make both the dataset and causal model available for research use. [ABSTRACT FROM AUTHOR]

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]

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]

Technical issues are important for software work, but so are personal disciplines, team-working skills, and application-domain knowledge. Also, much like an artistic performance, first-class software engineering requires constant practice, good technique, and effective coaching. The challenge of producing high-quality large-scale software products is substantial today and will be even more demanding in the future. Without concerted action, we cannot expect software organizations' capabilities to improve. To address these problems, the Software Engineering Institute (SEI) has developed the Personal Software Process (PSP) and the Team Software Process (TSP). This paper addresses the problems of software engineering and discusses the intellectual nature of software work. It then reviews the characteristics of this kind of work and describes the principal conditions for effective software performance. In the conclusion, the author makes some observations about the challenges ahead and the future actions required. [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]

With the rapid growth of network computing, the demand for large-scale and complex software systems has increased dramatically. However, the development of large-scale and complex software systems is much more difficult and error prone. This is due to the fact that techniques and tools for assuring the correctness and reliability of software systems lag far behind the increasing growth in size and complexity of software systems. The concept of software architecture has recently emerged as a new way to improve our ability to effectively construct and maintain large-scale complex software systems. The architecture based development of software systems focuses on the architectural elements and their overall interconnection structure. Several Architectural Definition Languages (ADLs) have been proposed for specifying domain specific or general purpose architectures. On the other hand, formal verification is rapidly becoming a promising and automated method to ensure the accuracy and correctness of software systems. In this paper, we survey several architecture description languages and formal verification methods. We present an environment to conduct experiments to study the performance of five different verification tools on software architecture specifications. Based on these experiments, we are able to compare the efficiency of these verification tools in verifying certain software property. [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]

This paper investigates implementations of process algebras which are suitable for modeling concurrent real-time systems. It suggests an approach for efficiently implementing real-time semantics using dynamic priorities. For this purpose a process algebra with dynamic priority is defined, whose semantics corresponds one-to-one to traditional real-time semantics. The advantage of the dynamic-priority approach is that it drastically reduces the state-space sizes of the systems in question while preserving all properties of their functional and real-time behavior. The utility of the technique is demonstrated by a case study that deals with the formal modeling and verification of several aspects of the widely-used SCSI-2 bus-protocol. The case study is carried out in the Concurrency Workbench of North Carolina, an automated verification tool in which the process algebra with dynamic priority is implemented. It turns out that the state space of the bus-protocol model is about an order of magnitude smaller than the one resulting from real-time semantics. The accuracy of the model is proved by applying model checking for verifying several mandatory properties of the bus protocol. [ABSTRACT FROM AUTHOR]

Postgraduate degree programs in “software engineering” have been in existence for some time and now undergraduate degree programs with this title are beginning to appear. A number of questions and issues of only moderate importance with respect to the postgraduate programs now become critical and of overriding importance. While one could (and did) by and large gloss over these issues earlier, this will be much more difficult, and probably impossible, in the future. These issues must be resolved in a wider context than that in which they have been dealt with before, involving engineering in the universities and professional engineering societies in the larger social context. Much of the disagreement regarding these issues can, ultimately, be traced back to differing fundamental views and definitions of the term “engineering” and whether “software engineering” should be treated as “just” another engineering discipline or in a significantly and fundamentally different way. After examining two different definitions and views of “engineering,” this paper states and discusses a number of the questions and issues which planners of new undergraduate software engineering degree programs must deal with. Some pros and cons of various alternative answers are presented and a few answers suggested. The issues discussed here begin with questions of general policy and concept (e.g., which culture – that of the traditional engineering disciplines or that of computer science – should be instilled in the students in these new degree programs), include organizational matters (e.g., the position of the new degree program in the university hierarchy) and end with selected, more detailed questions regarding the curriculum (e.g., how to deal with programming, design and management topics). It is conjectured that, although the scientific foundation for the undergraduate software engineering degree programs must and will come from computer science, their culture and orientation must come from engineering if they and their graduates are to be successful in satisfying society's needs in the long term. [ABSTRACT FROM AUTHOR]

In this paper we describe and review the course plan and syllabus we use in a course on formal methods in software engineering currently included in the degree in Informatics of the Faculty of Sciences at the University of Bologna. The course matches the theory of formal methods with their practice based on actual tool usage. In fact, the course is centered upon a project whose main goal is to let students learn some formal specification techniques, all supported by specific tools. The students use well-known notations for both requirements specification and formal design. The formal methods we use are based on the Z notation for requirements specification and on the Larch family of languages for design specifications. [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]

Building on the computer science concept of code smells, we initiate the study of law smells, i.e., patterns in legal texts that pose threats to the comprehensibility and maintainability of the law. With five intuitive law smells as running examples—namely, duplicated phrase, long element, large reference tree, ambiguous syntax, and natural language obsession—, we develop a comprehensive law smell taxonomy. This taxonomy classifies law smells by when they can be detected, which aspects of law they relate to, and how they can be discovered. We introduce text-based and graph-based methods to identify instances of law smells, confirming their utility in practice using the United States Code as a test case. Our work demonstrates how ideas from software engineering can be leveraged to assess and improve the quality of legal code, thus drawing attention to an understudied area in the intersection of law and computer science and highlighting the potential of computational legal drafting. [ABSTRACT FROM AUTHOR]