Critical Software Engineering Research Articles

On the effectiveness of graph data augmentation for source code learning

The methodology that employs deep learning to handle software engineering tasks, such as bug detection, is commonly referred to as source code learning. Given the inherent graph nature of source code, graph learning, bolstered by graph neural networks (GNNs), has seen an increasing adoption in the domain of source code learning. Similar to other contexts within deep learning, source code learning also relies on extensive high-quality training data, and the scarcity of such data has become a primary impediment that leads to performance bottlenecks. In practice, data augmentation is often used as a countermeasure to mitigate this issue, by synthesizing additional training data based on existing ones. However, most existing practice of data augmentation in source code learning is limited to simple program transformation methods, such as code refactoring, thus not sufficiently effective. In this work, in light of the graph nature of source code, we propose to apply the data augmentation methods used for graph-structured data in graph learning to the tasks of source code learning, and we conduct a comprehensive empirical study to evaluate whether such new data augmentation approaches bring better effectiveness, in terms of producing more accurate and robust models. Specifically, we evaluate four critical software engineering tasks and seven neural network architectures to assess the effectiveness of five data augmentation methods. Experimental results identify that, compared to the data augmentation-free training approach, the Manifold-Mixup method can significantly improve both the accuracy and robustness of the trained models of source code learning, for up to 1.60% and 4.09%, respectively.

A manifesto for applicable formal methods

Recently, formal methods have been used in large industrial organisations (including AWS, Facebook/Meta, and Microsoft) and have proved to be an effective part of a software engineering process finding important bugs. Perhaps because of that, practitioners are interested in using them more often. Nevertheless, formal methods are far less applied than expected, particularly for safety-critical systems where they are strongly recommended and have the most significant potential. We hypothesise that formal methods still seem not applicable enough or ready for their intended use in such areas. In critical software engineering, what do we mean when we speak of a formal method? And what does it mean for such a method to be applicable both from a scientific and practical viewpoint? Based on what the literature tells about the first question, with this manifesto, we identify key challenges and lay out a set of guiding principles that, when followed by a formal method, give rise to its mature applicability in a given scope. Rather than exercising criticism of past developments, this manifesto strives to foster increased use of formal methods in any appropriate context to the maximum benefit.

Architecting the Future of Software Engineering

To meet future demand for software capabilities, improvements in critical software engineering technologies are needed. This article presents a research road map and call to action that highlights the need for continual investment in software engineering research.

Performance Evolution of Software Engineering Development and Project Management: A Critical Evolution Software Engineering Process

Among the many pressing concerns in the realm of computers, software project development is among the highest. System development life cycle is a part of this (SDLC). A key goal of the software development life cycle (SDLC) is to reduce the likelihood of errors while improving the quality of the final result. Without a well-defined set of steps, the software development process is a pretty complicated affair. Method established to standardize and streamline software development. The introduction of the SDLC (Software Development Life Cycle) existence. What we have here is a methodical and organized approach to the process of creating software. Using the SDLC as a guide, entails a wide variety of steps and processes that must be completed before the final programmer is released. Software comes in many forms. Types of software development life cycles, each with their own benefits and drawbacks, are commonly employed in the software development process. Disadvantages Five of these software development life cycle (SDLC) models, including the waterfall model, the v-shaped model, and the prototype model, are presented in this study. Existing models are compared using a spiral and an iterative structure.

Passages

Federico Biancuzzi and Shane Warden's Masterminds of Programming: Conversations with the Creators of Major Programming Languages is a treasure. The book consists of interviews with the creators of, in order, C++, Python, APL, Forth, BASIC, AWK, Lua, Haskell, ML, SQL, Objective C, Java, C#, UML, Perl, PostScript, and Eiffel. Each chapter asks similar, but not identical questions, and the above-mentioned masterminds, including Larry Wall, James Gosling, Brian Kernighan, Bertrand Meyer, Robin Milner, Simon Peyton-Jones, Guido van Rossum, and Bjarne Stroustrop give a wide variety of answers. Some of the masterminds are charming, and many are contentious, even cranky; they are also, almost all, full of deep insights into the deepest problems of software engineering. This insight comes in two forms; first, programming languages are the mechanisms by which software engineering solutions are almost always produced. Second, perhaps even more importantly, creating and evolving a widely-used programming language is a heroic, Herculean, critical software engineering task. All of these masterminds have succeeded in a massive software engineering task; they are not mere ivory tower thinkers about software engineering, but have, in some cases, entire lives shaped by a single, extremely complex, software project. More on that key point below.

Misaligned values in software engineering organizations

AbstractThe values of software organizations are crucial for achieving high performance; in particular, agile development approaches emphasize their importance. Researchers have thus far often assumed that a specific set of values, compatible with the development methodologies, must be adopted homogeneously throughout the company. It is not clear, however, to what extent such assumptions are accurate. Preliminary findings have highlighted the misalignment of values between groups as a source of problems when engineers discuss their challenges. Therefore, in this study, we examine how discrepancies in values between groups affect software companies' performance. To meet our objectives, we chose a mixed method research design. First, we collected qualitative data by interviewing fourteen (N = 14) employees working in four different organizations and processed it using thematic analysis. We then surveyed seven organizations (N = 184). Our analysis indicated that value misalignment between groups is related to organizational performance. The aligned companies were more effective, more satisfied, had higher trust, and fewer conflicts. Our efforts provide encouraging findings in a critical software engineering research area. They can help to explain why some companies are more efficient than others and, thus, point the way to interventions to address organizational challenges.

Assessing requirements-related risks through probabilistic goals and obstacles

Requirements completeness is among the most critical and difficult software engineering challenges. Missing requirements often result from poor risk analysis at requirements engineering time. Obstacle analysis is a goal-oriented form of risk analysis aimed at anticipating exceptional conditions in which the software should behave adequately. In the identify-assess-control cycles of such analysis, the assessment step is not well supported by existing techniques. This step is concerned with evaluating how likely the obstacles to goals are and how likely and severe their consequences are. Those key factors drive the selection of most appropriate countermeasures to be integrated in the system goal model for increased completeness. Moreover, obstacles to probabilistic goals are currently not supported; such goals prescribe that some corresponding target property should be satisfied in at least X % of the cases. The paper presents a probabilistic framework for goal specification and obstacle assessment. The specification language for goals and obstacles is extended with a probabilistic layer where probabilities have a precise semantics grounded on system-specific phenomena. The probability of a root obstacle to a goal is thereby computed by up-propagation of probabilities of finer-grained obstacles through the obstacle refinement tree. The probability and severity of obstacle consequences is in turn computed by up-propagation from the obstructed leaf goals through the goal refinement graph. The paper shows how the computed information can be used to prioritize obstacles for countermeasure selection toward a more complete and robust goal model. A detailed evaluation of our framework on a non-trivial carpooling support system is also reported.

Assessing PSP effect in training disciplined software development: A Plan–Track–Review model

Context In training disciplined software development, the PSP is said to result in such effect as increased estimation accuracy, better software quality, earlier defect detection, and improved productivity. But a systematic mechanism that can be easily adopted to assess and interpret PSP effect is scarce within the existing literature. Objective The purpose of this study is to explore the possibility of devising a feasible assessment model that ties up critical software engineering values with the pertinent PSP metrics. Method A systematic review of the literature was conducted to establish such an assessment model (we called a Plan–Track–Review model). Both mean and median approaches along with a set of simplified procedures were used to assess the commonly accepted PSP training effects. A set of statistical analyses further followed to increase understanding of the relationships among the PSP metrics and to help interpret the application results. Results Based on the results of this study, PSP training effect on the controllability, manageability, and reliability of a software engineer is quite positive and largely consistent with the literature. However, its effect on one’s predictability on project in general (and on project size in particular) is not implied as said in the literature. As for one’s overall project efficiency, our results show a moderate improvement. Our initial finding also suggests that a prior stage PSP effect could have an impact on later stage training outcomes. Conclusion It is concluded that this Plan–Track–Review model with the associated framework can be used to assess PSP effect regarding a disciplined software development. The generated summary report serves to provide useful feedback for both PSP instructors and students based on internal as well as external standards.

Explication of object-oriented databases

The growing use of Object-Oriented Databases (OODBs) has necessitated the inclusion of OODBs in introductory database courses. Typically, such an analysis is conducted after the explication of the dominant industry standard: the Relational Database model (RDB). Like the RDB model, the OODB model can be easily motivated. Unlike the RDB model, an established data model with defined normal forms, the OODB model cannot be easily evaluated for "goodness". We address this deficiency by examining the criteria of coupling and cohesion in database design. This approach affords the instructor the ability to better present OODBs as well as the opportunity to re-emphasize critical software engineering concepts.

Human–formalism interaction: Studies in communication through formalism

A recurrent theme in studying the interaction between human and formalism is the understanding of how people interact with representations in reasoning and communication. In contrast to the best known theories, which approach the question of the impact of representation upon reasoning through explanations in terms of human computational architecture, we present here a more fundamental approach. This approach separates the problem into two parts—issues about computational complexity arising from the nature of the semantic interpretation (issues which are abstract with regard to architecture); and issues about how human computational architecture in particular can be brought to bear on different representations. On this view, for example, diagrams are often logically inexpressive and this is why they lead to efficient inference. This paper presents experiences in applying this semantic approach to the empirical study of modality assignment in three disparate domains: logic teaching, safety critical software engineering and the teaching of formality. We show how, in each of these cases, an account of the semantics of representations in simple formal terms permits the analysis and modelling of what would otherwise be incomprehensibly complicated behavioural phenomena. The results of these apparently diverse studies indicate that individual differences in what might be termed cognitive styles have a significant effect upon a humans use and understanding of various formalisms. This, we argue, is evidence that HCI researchers require a more analytical means to relate the cognitive and social sides of HCI than has previously been available. Furthermore, we also take the studies presented here as evidence that our approach is a substantial step towards providing such a means of analysis.