Search

The authors introduce The Journal of Open Source Software (JOSS), a publication that focuses on research software and its place in the scholarly publishing ecosystem. JOSSs goal is to make it easy for authors to publish a paper about their software, mostly focused on the software itself, and then be credited when this software is used based on users citing the JOSS paper. [ABSTRACT FROM AUTHOR]

This paper integrates an estimation of distribution (EoD)-based update operator into decomposition-based multiobjective evolutionary algorithms for binary optimization. The probabilistic model in the update operator is a probability vector, which is adaptively learned from historical information of each subproblem. We show that this update operator can significantly enhance decomposition-based algorithms on a number of benchmark problems. Moreover, we apply the enhanced algorithms to the constrained optimal software product selection (OSPS) problem in the field of search-based software engineering. For this real-world problem, we give its formal definition and then develop a new repair operator based on satisfiability solvers. It is demonstrated by the experimental results that the algorithms equipped with the EoD operator are effective in dealing with this practical problem, particularly for large-scale instances. The interdisciplinary studies in this paper provide a new real-world application scenario for constrained multiobjective binary optimizers and also offer valuable techniques for software engineers in handling the OSPS problem. [ABSTRACT FROM AUTHOR]

The nine papers in this special section focus on new developments in agile software and reports on applications for its use. A key aspect for the extensive use of agile software is that it supports developers with coping with the growing uncertainty and turbulence in technological and market environments. Feedback and change are at the core of Agile for a dynamic, evolving, and organic, rather than static, predefined, and mechanistic development process advocated by waterfall management. To create timely, high-quality, cost-efficient, and innovative solutions, Agile developers organized in small, colocated, autonomous teams, build and test software in rapid iterative cycles, actively involving users to gather feedback, updating the project scope, and plan "on-the-fly," using face-to-face communication as opposed to documentation. These papers contribute to the state-of-the-art of agile research by offering a rich, up-todate account of the dynamics occurring when expanding Agile into "not-just-software" contexts of the key challenges and perils related to the scaling and of the possible solutions to them. [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]

With continued technology scaling and increased power and thermal densities, processor operation and performance are increasingly dominated by physical phenomena. Microarchitectural approaches to mitigate these effects must be based on a profound understanding of how the physics is manifested in microarchitectural executions and system-level properties, such as performance, energy efficiency, or lifetime reliability. This requires a modeling and simulation environment that incorporates multiple physical phenomena and their concurrent interactions with microarchitecture. In this paper, we introduce an integrated power, thermal, and reliability modeling framework, KitFox. The goal of KitFox framework is to facilitate research explorations at the intersection of applications, microarchitectures, and various physical phenomena, including energy, power, thermal, cooling, and reliability. The KitFox framework implements a standard interface to bridge multiple physical models, where individual models are encapsulated into libraries and are interchangeable. This paper describes the design methodology of the library framework that orchestrates various implementations of physical models and standardized interface to cycle-level microarchitecture simulators. Several use cases are presented to demonstrate the range of modeling capabilities of KitFox. [ABSTRACT FROM PUBLISHER]

Despite the increasing demand for utilizing high-performance computing (HPC) for CSE applications, software development for HPC historically attracted little attention from the software engineering (SE) community. Paradoxically, the HPC CSE community has increasingly been adopting SE techniques and tools. Indeed, the development of CSE software for HPC differs significantly from the development of more traditional business information systems, from which many SE best practices and tools have been drawn. The workshop summarized in this column, the fourth in the series to be collocated with the Supercomputing conference series, examined two main topics: testing and tradeoffs. Through presentations of work in this area and structured group discussions, the participants highlighted some of the key issues, as well as indicated the direction the community needs to go. In particular, there is a need for more high-quality research in this area that we can use as an evidence base to help developers of CSE applications change practice and benefit from advances in software engineering. [ABSTRACT FROM PUBLISHER]

Function point analysis (FPA) is a standardized method to systematically measure the functional size of software. This method is proposed by an international organization and it is currently recommended by governments and organizations as a standard method to be adopted for this type of measurement. This paper presents a compilation of improvements, focused on increasing the accuracy of the FPA method, which have been proposed over the past 13 years. The methodology used was a systematic literature review (SLR), which was conducted with four research questions aligned with the objectives of this study. As a result of the SLR, of the 1600 results returned by the search engines, 454 primary studies were preselected according to the criteria established for the SLR. Among these studies, only 18 specifically referred to accuracy improvements for FPA, which was the goal of this study. The low number of studies that propose FPA improvements might demonstrate the maturity of the method in the current scenario of software metrics. Specifically in terms of found issues, it was found that the step for calculating the functional size exhibited the highest number of problems, indicating the need to revise FPA in order to encompass the possible improvements suggested by the researchers. [ABSTRACT FROM PUBLISHER]

Softwarization of networks allows simplifying deployment, configuration, and management of network functions. The driving force toward this evolution is represented by software defined networking that allows more flexible and dynamic network resource allocation and management. The efficient allocation and orchestration of network resources is of extreme importance for this softwarization process, and many centralized solutions have been proposed. However, they are complex and exhibit scalability issues. So, distributed solutions are to be preferred but, in order to be effective, should quickly converge towards equilibrium solutions. In this paper, we focus on making distributed resource allocation and orchestration a viable approach, and prove convergence of the relevant mechanisms. Specifically, we exploit game theory to model interactions between users requesting network functions and servers providing these functions. Accordingly, a two-stage Stackelberg game is presented, where servers act as leaders of the game and users as followers. Servers have conflicting interests and try to maximize their utility; users, on the other hand, use a replicator behavior and try to imitate other user’s decisions to improve their benefit. The framework proves the existence and uniqueness of an equilibrium, and a learning mechanism to converge to such equilibrium is proposed. Numerical results show the effectiveness of the approach. [ABSTRACT FROM PUBLISHER]

Fuzzy systems have been used widely thanks to their ability to successfully solve a wide range of problems in different application fields. However, their replication and application require a high level of knowledge and experience. Furthermore, few researchers publish the software and/or source code associated with their proposals, which is a major obstacle to scientific progress in other disciplines and in industry. In recent years, most fuzzy system software has been developed in order to facilitate the use of fuzzy systems. Some software is commercially distributed, but most software is available as free and open-source software, reducing such obstacles and providing many advantages: quicker detection of errors, innovative applications, faster adoption of fuzzy systems, etc. In this paper, we present an overview of freely available and open-source fuzzy systems software in order to provide a well-established framework that helps researchers to find existing proposals easily and to develop well-founded future work. To accomplish this, we propose a two-level taxonomy, and we describe the main contributions related to each field. Moreover, we provide a snapshot of the status of the publications in this field according to the ISI Web of Knowledge. Finally, some considerations regarding recent trends and potential research directions are presented. [ABSTRACT FROM PUBLISHER]

Edge computing is a continuum that includes the computing resources from cloud to things. Ecosystem of things (EoT) is a subsystem of the ecosystem of edge computing, which potentially contains trillions of devices of things and directly interacts with the physical world. This paper surveys the state of the art of EoT by focusing on the computing infrastructure aspect with a forward-looking perspective. We point out a trend of smart edge computing with four types of smartness and intelligence. We address three fundamental questions. 1) What capabilities and how much energy efficiency are the hardware providing? What is the future growth potential? 2) What abstractions are provided by the system software? Are they adequate to support smart edge computing? 3) What ecosystem architectures have been proposed for the coordination of things, the edge, and the cloud? Are they meeting the needs to encourage innovation but avoid unnecessary ecosystem fragmentation? We examine advances from both industry and academia, including research results, visions, and project concepts. We also point out future research directions. [ABSTRACT FROM AUTHOR]

In this paper, we describe research results arising from a technology transfer exercise on agent-oriented requirements engineering with an industry partner. We introduce two improvements to the state-of-the-art in agent-oriented requirements engineering, designed to mitigate two problems experienced by ourselves and our industry partner: (1) the lack of systematic methods for agent-oriented requirements elicitation and modelling; and (2) the lack of prescribed deliverables in agent-oriented requirements engineering. We discuss the application of our new approach to an aircraft turnaround simulator built in conjunction with our industry partner, and show how agent-oriented models can be derived and used to construct a complete requirements package. We evaluate this by having three independent people design and implement prototypes of the aircraft turnaround simulator, and comparing the three prototypes. Our evaluation indicates that our approach is effective at delivering correct, complete, and consistent requirements that satisfy the stakeholders, and can be used in a repeatable manner to produce designs and implementations. We discuss lessons learnt from applying this approach. [ABSTRACT FROM PUBLISHER]

Software process modeling (SPM) is an important area of software engineering because it provides a basis for managing, automating, and supporting software process improvement (SPI). Teaching SPM is a challenging task, mainly because it lays great emphasis on theory and offers few practical exercises. Furthermore, as yet few teaching approaches have aimed at teaching SPM by introducing innovative features, such as games. The use of games has mainly been focused on other areas of software engineering, for example software project management. In an attempt to fill this gap, this paper describes a formal experiment carried out to assess the learning effectiveness of a serious game (DesigMPS), designed to support the teaching of SPM, and to compare game-based learning with a project-based learning method. In the DesigMPS game, the student models a software process from an SPI perspective, based on the Brazilian SPI model (MPS.BR). The results indicate that playing the game can have a positive learning effect and results in a greater degree of learning effectiveness than does the project-based learning instructional method. [ABSTRACT FROM PUBLISHER]

Reports on the need to make make software open source. It should be both archived for reproducibility and actively maintained for reusability. In computational and computer science, research software is a central asset for development activities. For good scientific practice, the resulting research software should be open source. Established open source software licenses provide sufficient options for granting permissions such that it should be the rare exception to keep research software closed. Proper engineering is required for obtaining reusable and sustainable research software. This way, software engineering methods may improve research in other disciplines. However, research in software engineering and computer science itself will also benefit when programs are reused. To study the state of the art in this field, we analyzed research software publishing practices in computer and computational science and observed significant differences: computational science emphasizes reproducibility, while computer science emphasizes reuse. [ABSTRACT FROM AUTHOR]

Substantial industry and government investments in software are at risk due to changes in the underlying programming languages, despite the fact that such changes have no empirically verified benefits. One way to address this problem is to establish rigorous evidence standards like those in medicine and other sciences. [ABSTRACT FROM PUBLISHER]

Software plays a central role in scientific discovery. Improving how we develop and use software for research can have both broad and deep impacts on a spectrum of challenges and opportunities society faces today. The emergence of the research software engineer (RSE) role correlates with the growing complexity of scientific challenges and the diversity of software team skills. In this article, research software science (RSS), an idea related to RSE and particularly suited to research software teams, is described. RSS promotes the use of scientific methodologies to explore and establish broadly applicable knowledge. Using RSS, we can pursue sustainable, repeatable, and reproducible software improvements that positively impact research software toward improved scientific discovery. [ABSTRACT FROM AUTHOR]

Software engineering standards are essential sources of codified knowledge for all software engineers. Could the professors who are not teaching software engineering standards to software engineering students be accused of malpractice? [ABSTRACT FROM AUTHOR]

Imbalanced data is a significant issue in software fault prediction. It is very challenging for software engineers to handle imbalanced software fault data for the early prediction of software faults. In the last two decades, many researchers have used synthetic minority oversampling technique (SMOTE), SMOTE for regression and other such techniques to preprocess the imbalanced software fault data. However, these preprocessing techniques do not produce consistently good accuracy, especially in inter release, and cross project fault prediction. The learning of imbalanced fault data for prediction of the number of software faults has not been explored in depth so far. To deal with this scenario, we have explored an efficient machine learning technique, namely extreme learning machine (ELM) for prediction of the number of software faults. Furthermore, a new variant of ELM, namely weighted regularization ELM, is proposed to generalize the imbalanced data to balanced data. To validate the proposed imbalanced learning model, we have used 26 open source PROMISE software fault datasets and three prediction scenarios, intra release, inter release, and cross project. We have conducted the experiments for prediction of the number of faults. The experimental results showed that the proposed approach led to improved performance. [ABSTRACT FROM AUTHOR]

Cache timing attacks allow third-party observers to retrieve sensitive information from program executions. But, is it possible to automatically check the vulnerability of a program against cache timing attacks and then, automatically shield program executions against these attacks? For a given program, a cache configuration and an attack model, our CacheFix framework either verifies the cache side-channel freedom of the program or synthesizes a series of patches to ensure cache side-channel freedom during program execution. At the core of our framework is a novel symbolic verification technique based on automated abstraction refinement of cache semantics. The power of such a framework allows symbolic reasoning over counterexample traces and combines it with runtime monitoring for eliminating cache side channels during program execution. Our evaluation with routines from OpenSSL, libfixedtimefixedpoint, GDK, and FourQlib libraries reveals that our CacheFix approach (dis)proves cache side-channel freedom within an average of 75 s. In nearly all test cases, CacheFix synthesizes all patches within 20 min to ensure cache side-channel freedom of the respective routines during execution. [ABSTRACT FROM AUTHOR]

This study addresses two important questions related to engineering of safety-critical software and software-intensive systems. The first question is: which software and software-intensive systems should be considered safety critical? The second question is: what processes, design practices, and tools have practitioners been using for building these systems? We answer these questions through an analysis of unstructured interviews with experienced engineers who self-describe as working on safety-critical systems. Then, a thematic analysis of these responses was conducted. The results of this study are intended to provide guidance to those building safety-critical systems and have implications on state engineering licensure boards, in the determination of legal liability, and in risk assessment for policymakers, corporate governors, and insurance executives. [ABSTRACT FROM PUBLISHER]

Advertisement. [ABSTRACT FROM AUTHOR]

One of the most critical challenges for high-performance computing (HPC) scientific visualization is execution on massively threaded processors. Of the many fundamental changes we are seeing in HPC systems, one of the most profound is a reliance on new processor types optimized for execution bandwidth over latency hiding. Our current production scientific visualization software is not designed for these new types of architectures. To address this issue, the VTK-m framework serves as a container for algorithms, provides flexible data representation, and simplifies the design of visualization algorithms on new and future computer architecture. [ABSTRACT FROM PUBLISHER]

Bringing new safety-critical medical devices to market faces several major challenges, but modeling and formal methods can facilitate this process from early system requirements verification to platform-level testing to late-stage clinical trials. [ABSTRACT FROM AUTHOR]

Will OSs in 2025 still resemble the Unix-like consensus of today, or will a very different design achieve widespread adoption? [ABSTRACT FROM AUTHOR]

Prospective authors are requested to submit new, unpublished manuscripts for inclusion in the upcoming event described in this call for papers. [ABSTRACT FROM PUBLISHER]

In the late 1960s, tensions were erupting in corporate and academic computing cultures in the United States and abroad with competing views about the state of computer programming and possible future implications. A discourse of "software crisis" was ignited in 1968 when NATO hosted a conference on the topic of software engineering. The author examines the rhetoric of crisis, revolution, and promise in computer programming cultures by viewing it through the lens of two dissimilar leaders, Grace Hopper and Edsger Dijkstra, who articulated views through discourses about computer programming that reveal multiple ideals and tensions. As representatives and exemplars of different communities, they emphasized pragmatic versus theoretical stances, respectively. The historical context they operated in also highlights the cultural complexities of gender in computer programming, a durable phenomenon that continues today. [ABSTRACT FROM PUBLISHER]

Beginning in the mid-1960s, electromechanical telecommunications switches were increasingly replaced by computer-controlled switches. Production and development of this equipment relied on the construction of its software. This software was shaped by practices, ideas, and ideals appropriated from the computer industry and computer science as much as by concerns and constraints of the telecommunications industry itself. [ABSTRACT FROM PUBLISHER]