The massive emergence of Open Source Software (OSS) projects led to the rapid increment of data available to software engineers and those who would like to contribute to an OSS project. There is an arising need for a way to analyze and draw conclusions about the value of an OSS project, from an epistemic point of view. OSS projects have been used for a long time as vehicles for learning programming and software engineering. However, there is a need for more evidence about the scientific value conveyed by OSS projects. We posit that if we deeply study the dialogues of software engineers involved in the communities of the various projects and draw conclusions from them, this can be an additional way of assessing OSS projects. Learning analytics, data mining and data science provide diverse statistical and computational approaches to analyzing data. In this work, we describe Epistemic Network Analysis (ENA), a network analysis technique used by a growing community of researchers to support thick descriptions based on large volumes of data. ENA is based on the theory of epistemic frames. The theory of epistemic frames models the ways of being, thinking and acting inside some community of practice. In this research, we focus on the epistemic frame of software engineering and discuss the elements of this frame: the knowledge, the set of skills and values and the set of processes for making and justifying decisions. We coded the discourses of two well-known open source projects, LibreOffice and OpenOffice, and we used the online tool ENA WebKit to analyze the coded rows of the discourses, but also to visualize and compare the networks of different units of data. We conducted three types of experiments and comparisons on the mean networks of the two projects, on the networks of the different bugs, as well as on the networks of some software engineers who participated in the discussions, and we came to conclusions about how epistemic these dialogues were and therefore assessing their educational value. This is an introductory work utilizing the ENA method for OSS discourse analysis. We believe that the rational presented in this paper can lead to a set of processes on evaluating OSS projects based on their epistemology and at the same time, become an educational tool for software engineering courses and research groups.

Abstract Open source software (OSS) has been developing for more than two decades. It originated as a movement with the introduction of the first free/libre OSS operating system, became a popular trend among the developer community, led to enterprise solutions widely embraced by the global market, and began garnering attention from significant players in the software industry (such as IBM's acquisition of RedHat). Throughout the years, numerous software assessment models have been suggested, some of which were created specifically for OSS projects. Most of these assessment models focus on software quality and maintainability. Some models are taking under consideration health aspects of OSS projects. Despite the multitude of these models, there is yet to be a universally accepted model for assessing OSS projects. In this work, we aim to adapt the City Resilience Framework (CRF) for use in OSS projects to establish a strong theoretical foundation for OSS evaluation focusing on the project's resilience as it evolves over time. We would like to highlight that our goal with the proposed assessment model is not to compare two OSS solutions with each other, in terms of resilience, or even do a resilience ranking between the available OSS tools. We are aiming to investigate resilience of an OSS project as it evolves and identify possible opportunities of improvements in the four dimensions we are defining. These dimensions are as follows: source code, business and legal, integration and reuse, and social (community). The CRF is a framework that was introduced to measure urban resilience and most specifically how cities' resilience is changing as they evolve. We believe that a software evaluation model that focuses on resilience can complement the pre‐existing models based on software quality and software health. Although concepts that are related to resilience, like sustainability or viability, already appear in literature, to our best knowledge, there is no OSS assessment model that evaluates the resilience of an OSS project. We argue that cities and OSS projects are both dynamically evolving systems with similar characteristics. The proposed framework utilizes both quantitative and qualitative indicators, which is viewed as an advantage. Lastly, we would like to emphasize that the framework has been tested on the enterprise software domain as part of this study, evaluating five major versions of six OSS projects, Laravel, Composer, PHPMyAdmin, OKApi, PatternalPHP, and PHPExcel, the first three of which are intuitively considered resilient and the three latter nonresilient, to provide a preliminary validation of the models' ability to distinguish between resilient and not resilient projects.

Technical skills are insufficient to gain employment in big organizations and in-demand professions in the current labor market. Current and aspiring firm executives place a significant focus on the development of soft skills since they are crucial to work performance. To improve the soft and hard skills of students through the usage of a learning management system in their lessons, a gamification framework must be developed. To do this, skills are categorized into four distinct groups: Communication, Punctuality, Information and Digital Literacy, and Professionalism. A grading rubric is intended to assist the framework in assigning points to users based on their engagement with the learning management system. Each skill will be awarded between 0 and 3 points according the grading rubric. To encourage students to engage more with the system, conventional gamification components are included. Future milestones involve the development of a digital wallet to store the framework's acquired badges.

Customized compute acceleration in the datacenter is key to the wider roll-out of applications based on deep neural network (DNN) inference. In this article, we investigate how to maximize the performance and scalability of field-programmable gate array (FPGA)-based pipeline dataflow DNN inference accelerators (DFAs) automatically on computing infrastructures consisting of multi-die, network-connected FPGAs. We present Elastic-DF, a novel resource partitioning tool and associated FPGA runtime infrastructure that integrates with the DNN compiler FINN. Elastic-DF allocates FPGA resources to DNN layers and layers to individual FPGA dies to maximize the total performance of the multi-FPGA system. In the resulting Elastic-DF mapping, the accelerator may be instantiated multiple times, and each instance may be segmented across multiple FPGAs transparently, whereby the segments communicate peer-to-peer through 100 Gbps Ethernet FPGA infrastructure, without host involvement. When applied to ResNet-50, Elastic-DF provides a 44% latency decrease on Alveo U280. For MobileNetV1 on Alveo U200 and U280, Elastic-DF enables a 78% throughput increase, eliminating the performance difference between these cards and the larger Alveo U250. Elastic-DF also increases operating frequency in all our experiments, on average by over 20%. Elastic-DF therefore increases performance portability between different sizes of FPGA and increases the critical throughput per cost metric of datacenter inference.

Abstract Game mechanics are high‐level descriptions of common game requirements; however, they do not provide any guidance on their code implementation. Nevertheless, their implementation involves high volumes of essential complexity, which in turn leads to the introduction of accidental complexity (long methods, code repetition, etc.). A possible solution to this problem is to map game mechanics to design patterns, in order to provide template instantiations that handle structural complexity. The aim of this study is twofold: (a) introduce template instantiations of game mechanics with Gang of Four (GoF) patterns and (b) evaluate such mappings in terms of extendibility and reusability. To achieve these objectives, we developed an online repository of mappings between GoF patterns and game mechanics and conducted an experiment to explore the benefits of the mapping. The results of the study suggest that the implementation of game mechanics with GoF patterns is beneficial, because the time to extent the current implementation or reuse code chunks is not prolonged, whereas the implementations are less faulty. Finally, the suggested mapping will equip game mechanics with sample implementations (that adhere to good design principles—ensuring extendibility) that can be reused, acting as a starting point for source code development.

Refactoring is a prevalent technique that can be applied for improving software structural quality. Refactorings can be applied at different levels of granularity to resolve 'bad smells' that can be identified in various artifacts (e.g., methods, classes, packages). A fundamental software engineering principle that can be applied at various levels of granularity is the Single Responsibility Principle (SRP), whose violation leads to the creation of lengthy, complex and non-cohesive artifacts; incurring smells like Long Method, God Class, and Large Package. Such artifacts, apart from being large in size tend to implement more than one functionalities, leading to decreased cohesion, and increased coupling. In this paper, we study the effect of applying refactorings that lead to conformance to the SRP, at all three levels of granularity to identify possible differences between them. To study these differences, we performed an industrial case study on two large-scale software systems (more than 1,500 classes). Since SRP is by definition related to modularity, as a success measure for the refactoring we use coupling and cohesion metrics. The results of the study can prove beneficial for both researchers and practitioners, since various implications can be drawn.

Context: Technical Debt (TD) quantification has been studied in the literature and is supported by various tools; however, there is no common ground on what information shall be presented to stakeholders. Similarly to other quality monitoring processes, it is desirable to provide several views of quality through a dashboard, in which metrics concerning the phenomenon of interest are displayed. Objective: The aim of this study is to investigate the indicators that shall be presented in such a dashboard, so as to: (a) be meaningful for industrial stakeholders, (b) present all necessary information, and (c) be simple enough so that stakeholders can use them. Method: We explore TD Management (TDM) activities (i.e., measurement, prioritization, repayment) and choose the main concepts that need to be visualized, based on existing literature and toolsupport. Next, we perform a survey with 60 software engineers (i.e., architects, developers, etc.) working for 11 software development companies located in 9 countries, to understand their needs for TDM. Results / Conclusions: The results of the study suggest that different stakeholders need a different view of the quality dashboard, but also some commonalities can be identified. For example, on the one hand, managers are mostly interested in financial concepts, whereas on the other hand developers are more interested in the nature of the problems that exist in the code. The outcomes of this study can be useful to both researchers and practitioners, in the sense that the former can focus their efforts on aspects that are meaningful to industry, whereas the latter to develop meaningful dashboards, with multiple views.

Abstract To capitalize upon the benefits of software reuse, an efficient selection among candidate reusable assets should be performed in terms of functional fitness and adaptability. The reusability of assets is usually measured through reusability indices. However, these do not capture all facets of reusability, such as structural characteristics, external quality attributes, and documentation. In this paper, we propose a reusability index (REI) as a synthesis of various software metrics and evaluate its ability to quantify reuse, based on IEEE Standard on Software Metrics Validity. The proposed index is compared with existing ones through a case study on 80 reusable open‐source assets. To illustrate the applicability of the proposed index, we performed a pilot study, where real‐world reuse decisions have been compared with decisions imposed by the use of metrics (including REI). The results of the study suggest that the proposed index presents the highest predictive and discriminative power; it is the most consistent in ranking reusable assets and the most strongly correlated to their levels of reuse. The findings of the paper are discussed to understand the most important aspects in reusability assessment (interpretation of results), and interesting implications for research and practice are provided.

Empirical evidence has pointed out that Extract Method refactorings are among the most commonly applied refactorings by software developers. The identification of Long Method code smells and the ranking of the associated refactoring opportunities is largely based on the use of metrics, primarily with measures of cohesion, size and coupling. Despite the relevance of these proper-ties to the presence of large, complex and non-cohesive pieces of code, the empirical validation of these metrics has exhibited relatively low accuracy (max precision: 66%) regarding their predictive power for long methods or extract method opportunities. In this work we perform an empirical validation of the ability of cohesion, coupling and size metrics to predict the existence and the intensity of long method occurrences. According to the statistical analysis, the existence and the intensity of the Long Method smell can be effectively predicted by two size (LoC and NoLV), two coupling (MPC and RFC), and four cohesion (LCOM1, LCOM2, Coh, and CC) metrics. Furthermore, the integration of these metrics into a multiple logistic regression model can predict whether a method should be refactored with a precision of 89% and a recall of 91%. The model yields suggestions whose ranking is strongly correlated to the ranking based on the effect of the corresponding refactorings on source code (correl. coef. 0.520). The results are discussed by providing interpretations and implications for research and practice.

Modularity is one of the key principles of software design. In order for a software system to be modular, it should be organized into modules that are highly coherent internally, whereas at the same time as independent from other modules as possible. In this paper we explore coupling and cohesion metrics at the software package level-i.e., one of most basic levels of software functional decomposition in object-oriented (OO) systems, with the aim of investigating their relation to the technical debt of each package. Current state-of-the-art tools in TD measurement are working on the source code level, and the extent to which they can unveil limitations at the architecture level (e.g., violations of the modularity principle), has not been explored so far. To achieve this goal, we conducted a case study on 1,200 packages retrieved from 20 well-known open source software projects. The results of the study suggested that current measures of technical debt are able to identify / predict modules that lack modularity, and therefore suffer from Architectural Technical Debt (ATD). The results of the study are discussed both from the practitioners' and re-searchers' point of view.

One of the first steps towards the effective Technical Debt (TD) management is the quantification and continuous monitoring of the TD principal. In the current state-ofresearch and practice the most common ways to assess TD principal are the use of: (a) structural proxies—i.e., most commonly through quality metrics; and (b) monetized proxies—i.e., most commonly through the use of the SQALE (Software Quality Assessment based on Lifecycle Expectations) method. Although both approaches have merit, they seem to rely on different viewpoints of TD and their levels of agreement have not been evaluated so far. Therefore, in this paper, we empirically explore this relation by analyzing data obtained from 20 open source software projects and build a regression model that establishes a relationship between them. The results of the study suggest that a model of seven structural metrics, quantifying different aspects of quality (i.e., coupling, cohesion, complexity, size, and inheritance) can accurately estimate TD principal as appraised by SonarQube. The results of this case study are useful to both academia and industry. In particular, academia can gain knowledge on: (a) the reliability and agreement of TD principal assessment methods and (b) the structural characteristics of software that contribute to the accumulation of TD, whereas practitioners are provided with an alternative evaluation model with reduced number of parameters that can accurately assess TD, through traditional software quality metrics and tools.

In this paper we present a framework for the seamlessly utilization of hardware accelerators in heterogeneous SoCs that are used to speedup the processing of Spark data analytics applications.

Abstract Software cost estimation is a key process in project management. Estimations in the initial project phases are made with a lot of uncertainty that influences estimation accuracy which typically increases as the project progresses in time. Project data collected during the various project phases can be used in a progressive time‐dependent fashion to train software cost estimation models. Our motivation is to reduce uncertainty and increase confidence based on the understanding of patterns of effort distributions in development phases of real‐world projects. In this work, we study effort distributions and suggest a four‐stage progressive software cost estimation model, adjusting the initial effort estimates during the development life‐cycle based on newly available data. Initial estimates are reviewed on the basis of the experience gained as development progresses and as new information becomes available. The proposed model provides an early, a post‐planning, a post‐specifications, and a post‐design estimate, while it uses industrial data from the ISBSG (R10) dataset. The results reveal emerging patterns of effort distributions and indicate that the model provides effective estimations and exhibits high explanatory value. Contributions in lessons learned and practical implications are also provided.

Summary Software development highly depends on using functionality of external libraries and frameworks because of the inherent benefits of software reuse. As projects evolve over time, it is a common and beneficial task to upgrade the external libraries to their latest versions because bugs are solved or new functionality is implemented. Nonetheless, external libraries evolve as well and undergo architectural and structural changes and therefore, impact the projects that use them in the case of library upgrades. In this paper, we propose a metrics‐based approach in order to identify evolution patterns of candidate reuse libraries and ultimately, assist in selecting new libraries for reuse or upgrading existing libraries. We propose a metrics suite that measures structural and behavioral attributes of software systems' evolution that affect their possible reuse by other projects. The proposed metrics measure the overall stability of software systems in terms of their structural consistency and resilience to introducing new bugs, maintainers' focus on resolving the existing bugs and their focus on preserving the system's structural complexity low. Next, we identify patterns in the metrics' behavior during projects' evolution in order to provide insight about the implications in the case of their reuse. We present our findings of a set of nine popular projects, six of which are maintained by the Apache Software Foundation, and report the results concerning the derived metrics' values and the studied library evolution patterns. Copyright © 2017 John Wiley & Sons, Ltd.

This article proposes an approach for improving the software process of a small/medium company. The methodology is presented through a case study during which estimation models have been applied, evaluated and introduced in a telecommunication software development process. The proposed methodology uses Bayesian Belief Networks to represent the relationships among implementation, product and process metrics and their impact on the development effort. The estimation models that were derived were applied and evaluated on the on-going projects of the company. Finally, by performing the same analysis on data from the International Software Benchmarking Standards Group (ISBSG) repository, it is demonstrated how one company can utilize data from other companies when it lacks sufficient data of its own. Copyright © 2009 John Wiley & Sons, Ltd.

The Software Project Management Antipattern Intelligent System (PROMAISE) is proposed as a Web-enabled knowledge-base framework that uses antipattern OWL ontologies in order to provide intelligent and up to date advice to software project managers regarding the selection of appropriate antipatterns in a software project. Antipatterns provide information on commonly occurring solutions to problems that generate negative consequences. These mechanisms are documented using informal paper based structures that do not readily support knowledge sharing and reuse. Antipattern OWL ontologies can be used to build a dynamic antipattern knowledge base, which can update itself automatically. This will allow the accessibility and transferability of up-to-date computer-mediated software project management knowledge to software project managers by encoding antipatterns into computer understandable ontologies. PROMAISE can function with this knowledge base in order to assist software project managers in the process of selecting applicable antipatterns.

Software project management (SPM) is an ill-structured domain, where past experiences of project management can become valuable learning resources for novices. To support instruction in the domain, we have developed the eCASE-SPM Web environment, for engaging students in case-based instruction and help them develop SPM related problem solving skills. This work presents major design issues of the environment and initial research results regarding (a) a student-based evaluation, connecting also students' attitudes to their learning styles, and (b) the learning effectiveness of the environment, investigating the use of embedded question prompts as students' cognitive scaffolds. Results so far reveal interesting interactions between students' learning styles and their attitudes towards learning in the eCASE-SPM environment. Furthermore, there is strong indication that using question prompts may have beneficial effect on students' learning and problem solving abilities, although fading out of the scaffolding should be implemented to moderate students' workload.

In this paper we apply a machine learning approach to the problem of estimating the number of defects called Regression via Classification (RvC). RvC initially automatically discretizes the number of defects into a number of fault classes, then learns a model that predicts the fault class of a software system. Finally, RvC transforms the class output of the model back into a numeric prediction. This approach includes uncertainty in the models because apart from a certain number of faults, it also outputs an associated interval of values, within which this estimate lies, with a certain confidence. To evaluate this approach we perform a comparative experimental study of the effectiveness of several machine learning algorithms in a software dataset. The data was collected by Pekka Forselious and involves applications maintained by a bank of Finland.

This paper presents the application and evaluation by means of a controlled experiment of an instructional tool during an open and distance learning (ODL) course. The core issue of investigation is whether this instructional aid can support, guide and scaffold the distant student in his/her study. For this purpose, a controlled experiment was conducted with the participation of 191 undergraduate students. Descriptive statistics as well as a variety of statistical methods have been applied to the collected data, in order to test the research hypotheses. The results have shown a statistical significant difference in performance for the student group that used the tool. Finally, concerns about the application of the tool in a broader context and further research on the area are also presented

Case-based learning is expected to enhance students' awareness of the various contextual factors, which affect problem solving in ill structured domains. An interesting question is always how to engage students in efficient processing of the case-based learning material. In this paper, we present the design and preliminary evaluation results of the eCASE environment, a generic Web-based environment for supporting case-based instruction. eCASE allows instructors to develop appropriate study paths for students to criss-cross the case-based information landscape. Furthermore, it supports students' study by providing scripts, which scaffold them when processing the learning material. A script in eCASE models the cognitive processes related to context awareness and guides students to focus on important events, recall relative cases and reach useful conclusions. First evaluation results indicate that students acknowledge the learning efficiency of scripted material. However, design improvements are also necessary to make scripts more appealing and less monotonous for students

In spite of numerous traditional and agile software project management models proposed, process and project modeling still remains an open issue. This paper proposes a Bayesian network (BN) approach for modeling software project management antipatterns. This approach provides a framework for project managers, who would like to model the cause-effect relationships that underlie an antipattern, taking into account the inherent uncertainty of a software project. The approach is exemplified through a specific BN model of an antipattern. The antipattern is modeled using the empirical results of a controlled experiment on extreme programming (XP) that investigated the impact of developer personalities and temperaments on communication, collaboration-pair viability and effectiveness in pair programming. The resulting BN model provides the precise mathematical model of a project management antipattern and can be used to measure and handle uncertainty in mathematical terms

We describe a controlled experiment concerning the use of a learning aid during the instructional procedure. The core issue of investigation is whether this instructional aid can augment the cognitive transfer of the learners by personalizing the offered knowledge. A controlled experiment was performed with the participation of 79 students. The results have shown that for the transfer of simple information this "lesson sheet" does not provide any statistically significant advantage, yet for complex information a statistically significant better performance is observed for the student group that used the tool.

Software entities (software products or processes) are characterized by many attributes, each one in its turn can be measured by one or more measures. In several cases the software entities have to be evaluated as a whole, thus raising the problem of aggregating measures to give an overall, single view on the software entity. This paper presents a method to aggregate measures, which works by comparing the product/process with predefined, ideal entities, or profiles. Profiles are defined starting from ranges of values on measures of attributes. The method is based on two main phases, namely definition of the evaluation model and application of the evaluation model. It is presented through a simplified case study that deals with evaluating the level of quality of an asset to decide whether to accept it in a reuse repository. A plausible way of how the method could be applied to process maturity assessment is also provided. The advantages of the method are that it allows using ordinal scales, while it deals explicitly with preferences expressed, implicitly or explicitly, by the evaluator.

Software artifacts are characterised by many attributes, each one in its turn can be measured by one or more measures. In several cases the software artifact has to be evaluated as a whole, thus raising the problem of aggregating measures to give an overall, single view on the artifact.This paper presents a method to aggregate measures, that works comparing the artifact with predefined, ideal artifacts, or profiles. Profiles are defined starting fromranges of values on measures of attributes. The method is based on two main phases, namely definition of the evaluation model and application of the evaluation model, and is presented in a simplified case study that deals with evaluating the level of quality of an asset to decide if accepting it in a reuse repository. The advantages of the method are that it allows using ordinal scales, while it deals explicitly with preferences expressed, implicitly or explicitly, by the evaluator.

This paper presents an empirical study in an industrial context on the production of software using a framework. Frameworks are semicomplete applications, usually implemented as a hierarchy of classes. The framework is developed first, then several applications are derived from it. Frameworks are a reuse technique that supports the engineering of product lines. In the study, we compare quality (in the sense of rework effort) and productivity in traditional and framework-based software production. We observe that the latter is characterized by better productivity and quality, as well as a massive increase in productivity over time, that we attribute to the effect of learning the framework. Although we cannot extrapolate the results outside the local environment, enough evidence has been accumulated to stimulate future research work.