Search

This document is a guest editorial for the special section on SEFM 2020 and 2021 in the journal Software & Systems Modeling. The International Conference on Software Engineering and Formal Methods (SEFM) aims to bring together practitioners and researchers to advance the state of the art in formal methods and their application in the software industry. This special section includes selected papers from SEFM 2020 and 2021, which were held virtually during the COVID pandemic. Each article in this section has undergone rigorous peer review and has been revised and extended compared to its conference version. The selected papers cover topics such as embedded software portability and verification, nontermination inference, quantitative modeling and analysis of BDI agents, lazy model checking for recursive state machines, P-stable abstractions of hybrid systems, fairness and guarantees for extended bounded response LTL+P synthesis, counterexample classification, analyzing the impact of human errors on interactive service robotic scenarios, and active model learning of stochastic reactive systems. [Extracted from the article]

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]

What are the landmark papers in scientific disciplines? Which papers are indispensable for scientific progress? These are typical questions which are of interest not only for researchers (who frequently know the answers – or guess to know them) but also for the interested general public. Citation counts can be used to identify very useful papers since they reflect the wisdom of the crowd – in this case, the scientists using published results for their research. In this study, we identified with recently developed methods for the program CRExplorer landmark publications in nearly all Web of Science subject categories (WoS-SCs). These are publications which belong more frequently than other publications during the citing years to the top-1‰ in their subject area. As examples, we show the results of five subject categories: 'Information Science & Library Science', 'Computer Science, Information Systems', 'Computer Science, Software Engineering', 'Psychology, Social' and, 'Chemistry, Physical'. The results of the other WoS-SCs can be found online at http://crexplorer.net. An analyst of the results should keep in mind that the identification of landmark papers depends on the used methods and data. Small differences in methods and/or data may lead to other results. [ABSTRACT FROM AUTHOR]

The data-driven approach is popular to automate learning of fuzzy rules and tuning membership function parameters in fuzzy inference systems (FIS) development. However, researchers highlight different challenges and issues of this FIS development because of its complexity. This paper evaluates the current state of the art of FIS development complexity issues in Computer Science, Software Engineering and Information Systems, specifically: 1)What complexity issues exist in the context of developing FIS? 2) Is it possible to systematize existing solutions of identified complexity issues? We have conducted a hybrid systematic literature review combined with a systematic mapping study that includes keyword map to address these questions. This review has identified the main FIS development complexity issues that practitioners should consider when developing FIS. The paper also proposes a framework of complexity issues and their possible solutions in FIS development. [ABSTRACT FROM AUTHOR]

Aim/Purpose This paper investigates the gaps between industry and academia perceptions of information technology fields, such as computer science, software engineering, and computer engineering, and it identifies areas of asymmetry between curricula and industry expectations. The study mainly focuses on the skills required of IT professionals (graduated students) and on how higher education institutes equip students for industry. Background Higher education institutes have several IT-related departments. However, it is not clear whether these departments have sufficient content to equip students with industry-related skills. Rapid advances mean that some curriculum topics are redundant before the end of a standard two- or four-year degree programs. Balancing the technical/non-technical skills and adjusting the curricula to better prepare the students for industry is a constant demand for higher education institutions. Several studies have demonstrated that a generic curriculum is inadequate to address current IT industry needs. Methodology The study involved a comprehensive survey of IT professionals and compa- nies using a Web-based questionnaire sent directly to individual companies, academics, and employers. 64 universities and 38 companies in 24 countries were represented by the 209 participants, of whom 99 were IT professionals, 72 academics, and 38 employers. Contribution This paper is intended to guide academics in preparing dynamic curricula that can be easily adapted to current industry trends and technological developments, with content directly relevant to student's careers. In addition, the results may identify the skills that students need to secure employment and the courses that will provide skills in line with current industry trends. Findings The results indicate a lack of emphasis on personal and non-technical skills in undergraduate education compared to general computer science, software development, and coding courses. Employers' and software experts' responses emphasize that soft skills should not be ignored, and that, of these, analytical thinking and teamwork are the two most requested. Rather than a theoretical emphasis, courses should include hands-on projects. Rapid developments and innovations in information technologies demand that spiral and waterfall models are replaced with emerging software development models, such as Agile and Scrum development. Recommendations for Practitioners A multidisciplinary approach should be taken to the teaching of soft skills, such as communication, ethics, leadership, and customer relations. Establishing multiple learning tracks in IT education would equip students with specialized knowledge and skills in IT. An effective communication channel should be established between students and industry. It is also important to reduce the distance between academics and students and to provide an interactive environment for technical discussions. Enterprise level computing and Framework use provide job market advantages. Recommendations for Researchers Researchers and department heads, particularly those involved in curriculum design and accreditation, could use the results of this exemplary study to identify key topics for attention. Impact on Society Changes of various degrees are required in the current curricula in many higher education institutions to better meet student needs. Societies and technology are dynamic in nature, and information technology-related curricula in higher education institutions should be equally dynamic. Future Research Since technology (especially information technology) transforms and advances itself so rapidly, this study should be replicated t to investigate how these changes affect the gap between revised curricula and current industry expectations. [ABSTRACT FROM AUTHOR]

Background: More than 30 years ago, Harmon distinguished developmental research articles (RAs), which propose a solution to a problem, from experimental RAs, but the developmental format has received little attention. Literature review: Genre analysis of RAs has been largely restricted to articles following the standard experimental/Introduction, Methods, Results, Discussion (IMRD) format, thereby excluding many developmental engineering articles. Recently, a textbook proposed Introduction, Process, Testing, Conclusion (IPTC) as a prototypical format for electrical engineering RAs, but this format has not yet been demonstrated from a corpus. Research questions: 1. What is the macrostructure of electrical engineering RAs? 2. What are the characteristic features of each division of electrical engineering RAs? Methodology: Section headings, wordcount, and notable features were analyzed for 75 RAs from 15 electrical engineering journals and compared with both IPTC and Harmon's developmental structure. Results: Only one article, a case study, followed IMRD. Sixty-seven developmental RAs followed the IPTC format. These are distinguished by the second division (P), where the new solution is described, written in extended style, comprising several sections with headings specific to the research. A paragraph at the end of the Introduction describing the organization of the paper, the location of the theoretical framework and testing methods, and a ubiquitous Conclusion also differ from IMRD. Seven developmental RAs exhibited a hybrid format with the well-known IMRD section headings superimposed on an IPTC structure. Conclusions: Most electrical engineering articles are developmental and follow IPTC format. This can inform future genre analysis research and has pedagogical implications for teaching engineering writing. [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]

Execution traces comprehension is an important topic in computer science since it allows software engineers to get a better understanding of the system behavior. However, traces are usually very large and hence they are difficult to interpret. Parallel, execution traces comprehension is a very important topic into the algorithms learning courses since it allows students to get a better understanding of the algorithm behavior. Therefore, there is a need to investigate ways to help students (and teachers) find and understand important information conveyed in a trace despite the trace being massive. In this paper, we propose a new approximation for execution traces comprehension based on fuzzy linguistic descriptions. A new methodology and a data-driven architecture based on linguistic modelling of complex phenomenon are presented and explained. In particular, they are applied to automatically generate linguistic reports from execution traces generated during the execution of algorithm implemented by the students of an introductory course of artificial intelligence. To the best of our knowledge, it is the first time that linguistic modelling of complex phenomenon is applied to execution traces comprehension. Throughout the article, it is shown how this kind of technology can be employed as a useful computer-assisted assessment tool that provides students and teachers with technical, immediate and personalised feedback about the algorithms that are being studied and implemented. At the same time, they provide us with two useful applications: they are an indispensable pedagogical resource for improving comprehension of execution traces, and they play an important role in the process of measuring and evaluating the "believability" of the agents implemented. To show and explore the possibilities of this new technology, a web platform has been designed and implemented by one of the authors, and it has been incorporated into the process of assessment of an introductory artificial intelligence course. Finally, an empirical evaluation to confirm our hypothesis was performed and a survey directed to the students was carried out to measure the quality of the learning-teaching process by using this methodology enriched with fuzzy linguistic descriptions. [ABSTRACT FROM AUTHOR]

This study aims to examine research collaboration between universities and industry in the field of computer science using bibliometric methods. To further understand the impact of individual countries on university-industry (UI) collaboration, data were retrieved from the computer science journal papers included in the Science Citation Index and published during the period 2002--2011. The density, degree centrality, betweenness centrality, and closeness centrality of UI collaborative networks were calculated in order to ascertain the core countries involved in international UI collaboration. This study investigates university-industry collaborative papers (UI papers) at the global and country levels. At the global level, the results show an increasing trend in UI papers and a stable UI collaboration ratio during the last decade. The average number of authors for UI papers is 4.13, which is higher than that for all other papers. Most UI papers result from two-institution collaboration, but we observed an increase in the number of UI papers produced by multiple universities and industrial entities. At the country level, the results also show that international UI paper collaboration has intensified. Meanwhile, the USA is the dominant collaborative partner with many countries and has produced the highest number of UI papers globally. [ABSTRACT FROM AUTHOR]

Many test case generation algorithms have been proposed to test Android apps through their graphical user interfaces. However, no systematic study on the impact of the core design elements in these algorithms on effectiveness and efficiency has been reported. This paper presents the first controlled experiment to examine three key design factors, each of which is popularly used in GUI traversal-based test case generation techniques. These three major factors are definition of GUI state equivalence, state search strategy, and waiting time strategy in between input events. The empirical results on 33 Android apps with real faults revealed interesting results. First, different choices of GUI state equivalence led to significant difference on failure detection rate and extent of code coverage. Second, searching the GUI state hierarchy randomly is as effective as searching it systematically. Last but not the least, the choices on when to fire the next input event to the app under test is immaterial so long as the length of the test session is practically long enough such as 1 h. We also found two new GUI state equivalence definitions that are statistically as effective as the existing best strategy for GUI state equivalence. [ABSTRACT FROM AUTHOR]

The invention of the computer has led to the establishment of a new research paradigm, computation, which has recently become more and more popular in scientific exploration. However, computation is not well represented in high school and university curricula in science and engineering, although it applies to a wide range of disciplines beyond computer science and software engineering. In light of the increasing need to provide students with computational education, this paper presents a novel way to develop computational thinking among students. The proposed approach is based on the implementation of Papert's theory of constructionism in electronic spreadsheets. In this approach, students build their knowledge while constructing the difference equation that describes a physical (or engineering) phenomenon, based on specific cases investigated in the spreadsheet. The method does not require the students to write code or perform complex calculations in the spreadsheet and makes it possible to teach advanced subjects at a relatively early stage. The method is demonstrated through contents taken from the secondary and tertiary curricula in mechanics and electromagnetism. [ABSTRACT FROM AUTHOR]

The aim of this study was mapping, visualizing and determining subject trends in the field of information retrieval using author co-citation network based on articles indexed in Scopus from 2005-2018. This scientometric study was performed using co-citation analysis. Research population includes all articles indexed in Scopus in the field of information retrieval from 2005 to 2018. Therefore, 35018 papers were retrieved in this field. VOSviewer was used to analyze the author co-citation. The study indicated that a total of 604757 authors were co-cited, 212328 journals were cited. Also highly cited articles and sources were determined. Amongst countries, United States, China, United Kingdom, Germany and Canada ranked one to five, respectively. Computer science was a pioneer with regard to interdisciplinary area in IR. It is noteworthy that visualization of author co-citation in field of IR determined ten clusters, namely knowledge and information science, computer science, electronics, information retrieval, information seeking behavior, psychology, multimedia information retrieval, software engineering, ophthalmology and surgery. [ABSTRACT FROM AUTHOR]

Determining the most appropriate learning technique(s) is vital for the accurate and effective software fault prediction (SFP). Earlier techniques used for SFP have reported varying performance for different software projects and none of them has always reported the best performance across different projects. The problem of varying performance can be solved by using an approach, which partitions the fault dataset into different module subsets, trains learning techniques for each subset, and integrates the outcomes of all the learning techniques. This paper presents an approach that dynamically selects learning techniques to predict the number of software faults. For a given testing module, the presented approach first locates its neighbor module subset that contained modules similar to testing module using a distance function and then chooses the best learning technique in the region of that module subset to make the prediction for testing module. The learning technique is selected based on its past performance in the region of module subset. We have performed an evaluation of the proposed approach using fault datasets garnered from the PROMISE data repository and Eclipse bug data repository. Experimental results showed that the proposed approach led to an improved performance when predicting the number of faults in software systems. [ABSTRACT FROM AUTHOR]

Highlights • An architectural assumption management process with guidelines is developed. • Two case studies were conducted to validate the process. • The process can help to make architectural assumptions explicit. • The process can help to identify and reduce invalid architectural assumptions. Abstract Context Architectural assumption management is critical to the success of software development projects. In this paper, we propose an Architectural Assumption Management (AAM) process, comprised of four AAM activities: Architectural Assumption Making, Description, Evaluation, and Maintenance. Objective Evaluating the AAM process in architectural assumption management, regarding the ease of understanding and the effort of conducting the AAM process, as well as the effectiveness of using the AAM process to make architectural assumptions explicit and to identify and reduce invalid architectural assumptions. Method An explanatory study with 88 first-year master students in software engineering, and an exploratory study with five practitioners from five companies. Results (1) the ease of understanding the AAM process is moderate for first-year master students but easy for practitioners; (2) the effort of conducting the AAM process is moderate for first-year master students; (3) Making and Evaluation took the students more time than Description and Maintenance; (4) the practitioners considered Evaluation as the most time consuming activity; (5) the AAM process can help to make architectural assumptions explicit and to identify and reduce invalid architectural assumptions in projects. The majority of the students and practitioners agreed that Architectural Assumption Evaluation is the most helpful activity for all these three aspects. For other activities, there are different opinions about their helpfulness; and (6) there are various factors identified that can impact the aforementioned results. Being aware of and properly adjusting these factors can facilitate the application of the AAM process in projects. Conclusions The AAM process aims at systematically managing architectural assumptions in software development. The results of the case studies provide preliminary empirical evidence for the evaluation of the AAM process. [ABSTRACT FROM AUTHOR]

In recent years, misconfigurations have become one of the major causes of software system failures, resulting in numerous service outages. What is worse, misconfigurations are also costly to diagnose and troubleshoot. This remains a great challenge for sysadmins (system administrators) to detect, diagnose, or troubleshoot these misconfigurations. Unlike software bugs, misconfigurations are more vulnerable to sysadmins’ mistakes. Developers and researchers are attempting to improve system reactions to misconfigurations to ease the burden of sysadmins’ diagnoses. Such efforts would greatly benefit from the techniques that can comprehensively detect bad system reactions through injected misconfigurations. Unfortunately, few such studies have achieved the above goal in the past, primarily because they only relied on generic alterations and failed to find a way to systematically generate misconfigurations. In this paper, we study eight mature open-source and commercial software packages and summarize a fine-grained classification of option types. Based on this classification, we use Augmented Backus–Naur Form to summarize and extract syntactic and semantic constraints of each type. In order to generate comprehensive misconfigurations in the test systems, we propose misconfiguration generation methods for our constraints. We implement a tool named Configuration Vulnerability Detector (ConfVD) to conduct misconfiguration injection and further analyze the systems’ reaction abilities to various misconfigurations. We carried out comprehensive analyses upon Apache Httpd, MySQL, PostgreSQL, and Yum. The results of our analysis show that our option classification covers 96% of 1582 options from the above-mentioned systems. Our constraints are more fine grained than previous works and their accuracy was found to be 91% (ascertained by manual verification). Our technique could improve generic alteration approaches without constraints, and we found that ConfVD could find nearly three times the bad reactions that were found by ConfErr. In total, we found 65 bad reactions from the systems being tested and our fine-grained constraints contributed 27.7% more bad reactions than techniques only using coarse-grained constraints. [ABSTRACT FROM AUTHOR]

A bridge role metric model is put forward in this paper. Compared with previous metric models, our solution of a large-scale object-oriented software system as a complex network is inherently more realistic. To acquire nodes and links in an undirected network, a new model that presents the crucial connectivity of a module or the hub instead of only centrality as in previous metric models is presented. Two previous metric models are described for comparison. In addition, it is obvious that the fitting curve between the results and degrees can well be fitted by a power law. The model represents many realistic characteristics of actual software structures, and a hydropower simulation system is taken as an example. This paper makes additional contributions to an accurate understanding of module design of software systems and is expected to be beneficial to software engineering practices. [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 purpose of regression testing is to ensure that changes made to software, such as adding new features or modifying existing features, have not adversely affected features of the software that should not change. Regression testing is usually performed by running some, or all, of the test cases created to test modifications in previous versions of the software. Many techniques have been reported on how to select regression tests so that the number of test cases does not grow too large as the software evolves As the software systems evolve with time, regression testing is an important and very expensive activity to ensure that this evolution will not disrupt the existing functionalities of the system. An important issue, in this context, is optimal selection of subset of test cases from the initial test suite to minimize the testing time, cost and effort. Researchers have proposed various types of regression test selection techniques that are code-based, and modelbased. Code-based regression test selection techniques can be effectively applied for unit-testing. It uses relationship between code parts and test cases that traverse them to locate test cases for retest when code is modified. This paper is the analysis of both code-based and model-based regression testing technique according to some comparison and evaluation criterion. [ABSTRACT FROM AUTHOR]

The lack of precision to predict service performance through load indices may lead to wrong decisions regarding the use of web services, compromising service performance and raising platform cost unnecessarily. This paper presents experimental studies to qualify the behaviour of load indices in the web service context. The experiments consider three services that generate controlled and significant server demands, four levels of workload for each service and six distinct execution scenarios. The evaluation considers three relevant perspectives: the capability for representing recent workloads, the capability for predicting near-future performance and finally stability. Eight different load indices were analysed, including the JMX Average Time index (proposed in this paper) specifically designed to address the limitations of the other indices. A systematic approach is applied to evaluate the different load indices, considering a multiple linear regression model based on the stepwise-AIC method. The results show that the load indices studied represent the workload to some extent; however, in contrast to expectations, most of them do not exhibit a coherent correlation with service performance and this can result in stability problems. The JMX Average Time index is an exception, showing a stable behaviour which is tightly-coupled to the service runtime for all executions. Load indices are used to predict the service runtime and therefore their inappropriate use can lead to decisions that will impact negatively on both service performance and execution cost. [ABSTRACT FROM AUTHOR]

Distributed hash tables (DHTs) are usually used in the open networking environment, where they are vulnerable to Sybil attacks. Pebble-Rotating Game (PRG) mixes the nodes of the honest and the adversarial randomly, and can resist the Sybil attack efficiently. However, the adversary may have some tricks to corrupt the rule of PRG. This paper proposes a set of mechanisms to make the rule of PRG be obliged to obey. A new joining node must ask the Certificate Authority (CA) for its signature and certificate, which records the complete process on how a node joins the network and obtains the legitimacy of the node. Then, to prevent the adversary from accumulating identifiers, any node can make use of the latest certificate to judge whether one identifier is expired with the help of the replacement property of RPG. This paper analyzes in details the number of expired certificates which are needed to store in every node, and gives asymptotic solution of this problem. The analysis and simulations show that the mean number of the certificates stored in each node are , where n is the size of the network. [ABSTRACT FROM AUTHOR]

We live in an era of abundant data. This has necessitated the development of new and innovative statistical algorithms to get the most from experimental data. For example, faster algorithms make practical the analysis of larger genomic data sets, allowing us to extend the utility of cutting-edge statistical methods. We present a randomised algorithm that accelerates the clustering of time series data using the Bayesian Hierarchical Clustering (BHC) statistical method. BHC is a general method for clustering any discretely sampled time series data. In this paper we focus on a particular application to microarray gene expression data. We define and analyse the randomised algorithm, before presenting results on both synthetic and real biological data sets. We show that the randomised algorithm leads to substantial gains in speed with minimal loss in clustering quality. The randomised time series BHC algorithm is available as part of the R package BHC, which is available for download from Bioconductor (version 2.10 and above) via http://bioconductor.org/packages/2.10/bioc/html/BHC.html. We have also made available a set of R scripts which can be used to reproduce the analyses carried out in this paper. These are available from the following URL. https://sites.google.com/site/randomisedbhc/. [ABSTRACT FROM AUTHOR]

This paper examines three ideas: First, the traditional relationship between a science, the mathematics it uses and the engineering based on it. Second, the nature of (software) computer science, which may not be a science at all, and its unusual use of mathematics. And finally, the nature of software engineering, its relationship with computer science, and its use of mathematics called ‘formal methods’. These three ideas turn on the first of them, since the scientific world view seems natural for the study of computing. The paper's thesis is that while software touches science in many ways, it does not itself have a significant scientific component. For understanding programming, for teaching it and for applying it in the world, science is the wrong model. Mathematics has found its own foundations apart from science, and computer science must do the same. [ABSTRACT FROM AUTHOR]

The design of complex software systems fundamentally relies on the understanding of abstract components and their interactions. Although compositional techniques are being successfully employed in practice, the use of such techniques is often rather informal and intuitive, and typically a justification for correct behaviour of the composed system exists but is not expressed explicitly. In this paper, we show what can be gained from treating such justifications as first-class citizens. The fairly general setting for this paper is a formal development of a UNITY-style temporal logic for labeled transition systems in the calculus of inductive constructions which has been conducted using the Coq proof assistant in a formally rigorous way. Our development not only subsumes the original UNITY approach to program verification and the more recent approach of New UNITY, but goes beyond it in several essential aspects, such as the generality of the program/system model (arbitrary labeled transition systems instead of UNITY programs), the notion of fairness (weak group fairness instead of unconditional fairness), and the issue of compositionality (not only for safety but also for liveness assertions). The last aspect, which we feel is crucial in the foundations for software engineering, is subject of this paper. We present a general proof rule for compositional verification of liveness assertions in tightly coupled systems. It relies on a notion of compositional proofs, which in turn is closely related to classical work on interference-free proofs for parallel programs. The formulation of this new proof rule and the verification of its soundness does not only exploit the strong inductive reasoning capabilities of the calculus of inductive constructions, but it also uses the propositions-as-types interpretation and the associated proofs-as-objects interpretation in an essential way. [ABSTRACT FROM AUTHOR]

Attempts to perform systematic literature reviews have identified a problem with the quality of software engineering abstracts for papers describing empirical studies. Structured abstracts have been found useful for improving the quality of abstracts in many other disciplines. However, there have been no studies of the value of structured abstracts in software engineering. Therefore this paper aims to assess the comparative length and readability of unstructured abstracts and structured versions of the same abstract. Abstracts were obtained from all empirical conference papers from the Evaluation and Assessment in Software Engineering Conference (EASE04 and EASE06) that did not have a structured abstract (23 in total). Two novice researchers created structured versions of the abstracts, which were checked by the papers' authors (or a surrogate). Web tools were used to extract the length in words and readability in terms of the Flesch reading ease index and automated readability index (ARI) for the structured and unstructured abstracts. The structured abstracts were on average 142.5 words longer than the unstructured abstracts (p<0.001). The readability of the structured abstracts was better by 8.5 points on the Flesch index (p<0.001) and 1.8 points on the ARI (p<0.003). The results are consistent with previous studies, although the increase in length and the increase in readability are both greater than the previous studies. Future work will consider whether structured abstracts increase the content and quality of abstracts. [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]

Software systems are increasing in size and complexity and, subsequently, are becoming ever more difficult to validate. Finite state verification (FSV) has been gaining credibility and attention as an alternative to testing and to formal verification approaches based on theorem proving. There has recently been a great deal of excitement about the potential for FSV approaches to prove properties about hardware descriptions but, for the most part, these approaches do not scale adequately to handle the complexity usually found in software. In this paper, we describe an FSV approach that creates a compact and conservative, but imprecise, model of the system being analyzed, and then assists the analyst in adding additional details as guided by previous analysis results. This paper describes this approach and a prototype implementation called FLAVERS, presents a detailed example, and then provides some experimental results demonstrating scalability. [ABSTRACT FROM AUTHOR]

The past two decades have seen increasing sophistication in software work. Now and in the future, the work of both practitioners and researchers would be helped by a more objective and finer granularity recognition of types of software evolution and software maintenance activities as actually done. To these ends, this paper proposes a clarifying redefinition of the types of software evolution and software maintenance. The paper bases the proposed classification not on people's intentions but upon objective evidence of maintainers' activities ascertainable from observation of activities and artifacts, and/or a before and after comparison of the software documentation. The classification includes taking into account in a semi-hierarchical manner evidence of the change or lack thereof in: (1) the software, (2) the documentation, (3) the properties of the software, and (4) the customer-experienced functionality. A comparison is made with other classifications and typologies. The paper provides a classified list of maintenance activities and a condensed decision tree as a summary guide to the proposed evidence-based classification of the types of software evolution and software maintenance. [ABSTRACT FROM AUTHOR]

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]

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]

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]

This paper describes a procedure for analyzing unbalanced datasets that include many nominal- and ordinal-scale factors. Such datasets are often found in company datasets used for benchmarking and productivity assessment. The two major problems caused by lack of balance are that the impact of factors can be concealed and that spurious impacts can be observed. These effects are examined with the help of two small artificial datasets. The paper proposes a method of forward pass residual analysis to analyze such datasets. The analysis procedure is demonstrated on the artificial datasets and then applied to the COCOMO dataset. The paper ends with a discussion of the advantages and limitations of the analysis procedure. [ABSTRACT FROM AUTHOR]

An important advantage of a database system is that it provides each application with a custom view of the data. The issue addressed in this paper is how to provide such custom views to applications that access multiple databases. The paper describes a formal method that generates such superviews, In an interactive process of schema editing operations. A mapping of the superview into the individual databases is derived from the editing process, and is stored together with the superview as a virtual database. When this database is interrogated, the mapping is used to decompose each query into a set of queries against the individual databases, and recompose the answers to form an answer to the original query. As this process is transparent to the user, virtual databases may be regarded as a more general type of databases. A prototype database system, that allows users to construct virtual databases and interrogate them, has been developed. [ABSTRACT FROM AUTHOR]

In a paper by Hawthorn and DeWitt, the projected performance of several proposed database machines was examined for three relational database queries. The present paper investigates the performance of a massively parallel machine called NON-VON for the same queries under comparable assumptions. In the case of simple queries, a NON-VON machine of comparable size to those considered by Hawthorn and DeWitt is found to be somewhat faster than the fast- est machines examined in their study; for a more complex database operation, NON-VON is shown to be five to ten times faster than the fastest of these machines. [ABSTRACT FROM AUTHOR]

It is desirable for the load in a distributed system to be balanced evenly. A dynamic process migration protocol is needed in order to achieve load balancing in a user transparent manner. A distributed algorithm for load balancing which is network topology independent is proposed in this paper. Different network topologies and low-level communications protocols affect the choice of only some system design parameters. The "drafting" algorithm attempts to compromise two contradictory goals: maximize the processor utilization and minimize the communication overhead. The main objective of this paper is to describe the dynamic process migration protocol based on the proposed drafting algorithm. A sample distributed system is used to further illustrate the drafting algorithm and to show how to define system design parameters. The system performance is measured by simulation experiments based on the sample system. [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 this paper we: 1) discuss the need for quantitatively reproducible experiments in the study of top-down design; 2) propose the design and writing of tutorial papers as a suitably general and in- expensive vehicle; 3) suggest the software science parameters as appropriate metrics; 4) report two experiments validating the use of these metrics on outlines and prose; and 5) demonstrate that the experiments tended toward the same optimal modularity. The last point appears to offer a quantitative approach to the estimation of the total length or volume (and the mental effort required to produce it) from an early stage of the top-down design process. If results of these experiments are validated elsewhere, then they will provide basic guidelines for the design process. [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]

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]

An architecture haiku aims to capture software system architecture's most important details on a single piece of paper. An architecture haiku helps development teams focus on the most essential information relevant to the architecture, provides clear guidance for construction, and encourages collaboration. [ABSTRACT FROM PUBLISHER]

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]

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]

Semantic Web and Web services have been two prominent themes in the computer science and IT mainstream for more than a decade. While both of these themes have been evolving, some geographers and GIScientists have been trying to introduce and adopt such new technologies into GIScience research and development. This paper reviews the state-of-the-art and the main constraints of semantic Web and Web services technologies and their applications in GIScience. Unless some fundamental problems within both semantic Web and Web services can be resolved, such technologies will be difficult to match the needs in the GIScience community. Besides logics, more sciences and theories have to be introduced into this research front in order to break through the long-term bottleneck in semantic Web and service computation in general. [ABSTRACT FROM AUTHOR]

Aspect-oriented software development has become an important development and maintenance approach to software engineering across requirements, design and implementation phases. However, discovering early aspects from requirements for a better integration of crosscutting concerns into a target system is still not well addressed in the existing works. In this paper, we propose a Goal-driven Early Aspect approach (called GEA) to discovering early aspects by means of a clustering algorithm in which relationships among goals and use cases are utilized to explore similarity degrees of clustering goals, and total interaction degrees are devised to check the validity of the formation of each cluster. Introducing early aspects not only enhances the goal-driven requirements modeling to manage crosscutting concerns, but also provides modularity insights into the analysis and design of software development. Moreover, relationships among goals represented numerically are more informative to discover early aspects and more easily to be processed computationally than qualitative terms. The proposed approach is illustrated by using two problem domains: a meeting scheduler system and a course enrollment system. An experiment is also conducted to evaluate the benefits of the proposed approach with Mann-Whitney U-test to show that the difference between with GEA and without GEA is statistically significant. [ABSTRACT FROM PUBLISHER]

Formal specification is an active research field in software engineering of this century, where different configurations and techniques are employed and although their industrial use is still limited, the scientific community currently has a different understanding about its usefulness and necessity. Until present time, researchers' work focuses on the specification written during the design of the preliminary functional model, for this reason it mainly focuses on evaluating the related tools. In this paper, a literature review is performed, covering the essence, function, use and disadvantages of formal specification techniques and some assessment and evaluation criteria are analyzed regarding their weaknesses. The results become the basis for future work formulation, aimed to the strengthening of formal specification as a core research activity. [ABSTRACT FROM AUTHOR]