dataesr/scientific-paragraphs-categorization huggingface dataset:
The Sonar web server synchronizes its Maven repository with the Maven repository of the user where all the artefacts are stored. mvn sonar:sonar is used to to make Sonar perform dynamic analysis, i. e. , running test cases and creating reports. After the analysis, the reports are published in the repository of the Sonar server, which can be accessed at the default address http://localhost:9000/. Bug collection (Project Level): For each bug, JIRA records the affected version of the software. We collected all of the closed and resolved bugs for the checked out version of the software. We perform this step manually for each software project, as each project has a unique name used by JIRA and each project has a different checked out version. We obtained the JIRA name of each project by searching the project's website.
For example, the project Twitter4J 13  in our dataset, for which we use version 3. 0. 0, has JIRA name TFJ. Bug collection (File Level): For each bug at the project level, we collect the bug key assigned by JIRA, which is unique for given repository. For example, one of the bugs in Twitter4J has a key TFJ-730. Then, we search the git logs to find all the commits associated with the bug key, and from these commits, we collect the changed files. A single commit can also fix multiple (n > 1) bugs. In this case, the number of bugs for the file affected by that commit is n. b) Statistical Tests: We use commonly accepted statistical analysis to find the correlation between the collected software metrics and the code coverage. Spearman's rho: Spearman's rank correlation coefficient (ρ) is a non-parametric test that is used to measure the strength of monotonic relationship between sets of data  [34].
B. Statistics In this section, we present some statistics describing the data we collected for this study. We also provide the values of the project-level statistics characterizing our dataset. a) Lines of code (LOC): We used Sonar to count the total number of lines of code in each project. Sonar excludes blank lines, comments and test cases while calculating LOC. Figure  1a  shows the distribution of the LOC for the projects in our dataset. 13 projects have between 5,000 and 10,000 LOC, 36 projects have between 10,000 and 25,000 LOC, 24 have projects between 25,000 and 50,000 LOC, 13 projects have between 50,000 and 100,000 LOC and 14 projects have more than 100,000 LOC. The largest project in our dataset contains 237,938 LOC. b) Cyclomatic complexity (CC): Cyclomatic complexity measures the number of linearly independent paths in the source code of a software application  [29].
This measure increases by 1 whenever a new method is called or when a new decision point is encountered, such as an if, while, for, &&, case etc. Cyclomatic complexity is often useful in knowing the number of test cases that might be required for independent path testing  [38]  and a file or project with low complexity is usually easier to comprehend and test  [11]. Figure  1b  shows the distribution of cyclomatic complexity. Our dataset has 45 projects with complexity between 1,000 and 5,000, 29 projects with complexity between 5,000 and 10,000, 10,000. 17 projects with complexity between 10,000 and 25,000 and 9 projects with complexity above 25,000. The highest value of complexity is 55,940. c) Test Cases: Sonar also gives information about the total number of test cases in each project, which includes the number of test cases that passed and the test cases that failed.
Sonar also provides the number of test cases that were skipped. A test case could be skipped due to missing dependencies, compilation errors, etc. Figure  1c  shows the distribution of test cases in our dataset. The graph shows all the test cases present in the project including the skipped and failing tests. 16 projects have fewer than 100 test cases, 44 projects have between 100 and 500 test cases, 19 projects have between 500 to 1,000 test cases, and 21 projects in our dataset have more than 1000 test cases. The number of test cases in our dataset varies from 1 to 9,390. The mean and the median number of test cases per project are 907. 1 and 359. 5, respectively. d) Developer contributions: We use git log, which contains the commit history of the project, to get the number of developers who have contributed to the project.
Coupling between classes can occur through method calls, field accesses, inheritance, arguments, return types, and exceptions. A large value of efferent coupling indicates that the stability of one class is dependent on the stability of other classes and makes the software a tightly coupled system, which is difficult to maintain, test and reuse  [35]. g) Delta: Delta represents the number of changes made to the files during the development of the particular version of the software. Classes that are changed more often have a higher value of delta and are usually unstable  [39]. Delta has been found to be a better predictor of the number of faults than other metrics such as lines of code  [16]. We use git tags to find all the tags of a repository and check the website of the project to find the stable version immediately preceding the version that we have selected for our dataset.
A. RQ1: Coverage & Defects (Project Level) In this question, we investigate the correlation between code coverage and post-release defects at the project level. Motivation: Code coverage gives us an idea of the thoroughness of testing by providing information about the amount of code that is tested. Increasing coverage, however, requires more work in terms of test case development, and may also increase the test suite running time. Thus, it is useful to understand whether an increase in code coverage is likely to lead to a decrease in post-release bugs. Methodology: We calculate lines of code, coverage, cyclomatic complexity and efferent couplings values by running Sonar for every release. We analyze the projects' JIRA bug repositories to calculate the number of post-release bugs. The detail on how the number of post-release bugs is computed   We derive additional metrics such as number of bugs/LOC, number of bugs/complexity and coverage/complexity.
The Spearman's ρ and Kendall's τ values are -0. 359 (p-value=0. 0002) and -0. 253 (p-value=0. 0002), respectively, which shows a moderate negative correlation between normalized coverage and of bugs. However, there is an insignificant correlation between normalized coverage and number of bugs/LOC (ρ=0. 175, p-value=0. 081; τ =0. 116, p-value=0. 089). Thus, we can reject the null hypothesis for coverage/complexity and number of bugs, but cannot reject the null hypothesis for coverage /complexity and number of bugs/LOC. To understand the correlations between coverage and various metrics for projects of different sizes, we divide the dataset into different categories based on the project size. We compute quartiles to divide the projects into three categories: those whose size is less than the lower quartile (25% of the projects), those whose size is between the lower and upper quartile (50% of the projects), and those whose size is above the upper quartile (25% of the projects).
We name these three categories as: small (<13,562 LOC), medium (≥13,562 LOC & <52,890 LOC) and large (≥52,890 LOC), respectively. We then compute correlations for each category separately. The null hypotheses are that there are no significant correlations between coverage and various metrics for projects of different sizes, while the alternate hypotheses state that there are significant correlations between coverage and various metrics. Table  II  shows the Spearman's and Kendall's correlations between coverage and different metrics for the three categories. We observe that the correlations are insignificant (p-value>0. 05) for all the categories. Thus, we cannot reject the null hypothesis for all the correlations. To understand the correlations between coverage and various metrics for projects of different cyclomatic complexities, we divide our dataset into two categories based on the median value of cyclomatic complexity: low complexity (<5,713) and high complexity (≥5,713).
B. RQ2: Coverage & Defects (File Level) Here, we investigate the correlation between the coverage level of each file and the number of bugs associated with that file. We also assess the number of bugs in terms of other metrics such as cyclomatic complexity, lines of code (LOC) and efferent couplings. Motivation: The coverage level provides information about the testedness of a project. However, a project may consist of many source code files with diverse properties. Thus, we want to analyse the correlation between coverage and postrelease bugs at the file level. Analysing this correlation can enhance our understanding of the impact of coverage on the bugs reported after the release of the software and exhibit which files are adequately tested. Methodology: We calculate lines of code, coverage, cyclomatic complexity and efferent couplings values by running Sonar for every release.
Thus, we can reject the null hypothesis. To understand the correlations between coverage and various metrics for files, we divide the dataset into different categories based on the size of the project they belong to. We club files based on the corresponding project size: small (<13,562 LOC), medium (≥13,562 LOC & <52,890 LOC) and large (≥52,890 LOC). We then compute correlations for each category separately. Table  IX  shows the correlations between coverage and different metrics for the three categories. The null hypotheses in this case are that there are no significant correlations between coverage and various metrics for files present in projects of different sizes, while the alternate hypotheses state that there are significant correlations between coverage and various metrics. We observe that for files present in projects of small and large sizes, the correlations between coverage and different metrics are insignificant.
For files in medium projects, we observe no correlation between coverage and different metrics. From the p-values, we can reject the null hypothesis for files in medium size projects, however, we cannot reject the null hypotheses for files in small and large size projects. To understand the correlations between coverage and various metrics for files of projects with different cyclomatic complexities, we group files based on project complexity. We divide our dataset into two categories based on the median value of project cyclomatic complexity: low complexity (<5,713) and high complexity (≥5,713). We then compute correlations between coverage and different metrics for each of the two categories. The null hypotheses in this case are that there are no significant correlations between coverage and various metrics for files present in low and high complexity projects, while the alternate hypotheses state that there are significant correlations between coverage and various metrics these two categories.
From the regression model, we find that the number of bugs decreases with the increase in the value of coverage, although the impact is very small. By categorizing files based on size of the project they belong to, we observe no correlation between coverage and other metrics for files in medium sized projects and insignificant correlation for files in small and large projects. For files present in low and high complexity projects, we observe no and insignificant correlation between coverage and various metrics, respectively. V. THREATS TO VALIDITY In this section, we describe several threats to validity for our empirical study. External Validity: These threats relate to the generalizability of the results. In this study, we have investigated 100 large and popular open-source Java projects from GitHub.
GitHub is a one of the largest repositories and hosts millions of projects of different sizes and from various domains. We have tried to ensure that our dataset consists of projects of substantial size (>5K LOC). Internal Validity: These threats are related to the environment under which experiments were carried We use Sonar to calculate several metrics such as lines of code, cyclomatic complexity, number of test cases and code coverage. Sonar uses Maven's directory structure to calculate these metrics. In this study, we do not consider projects that do not use Maven i. e. , they do not contain a pom. xml file. It is possible that projects that do not entirely follow Maven's structure may be interpreted wrongly. This could lead to Maven wrongly calculating certain metrics such lines of code or miss test cases in the project, which can affect the coverage value.
We find that a large number of projects exhibit low coverage and when the size and complexity increases, coverage decreases at the project level but increases at the file level. In two other studies, we examine the correlation between the number of test cases in a project with several metrics such as programming languages, the number of bugs, the number of bug reporters and the number of developers  [22] ,  [23]. To count the number of test cases, we used a heuristic i. e. , all the files that contain the "test" in their file name. In this paper, we investigate 100 large open-source projects from GitHub to analyse the impact of code coverage on the number of postrelease bugs at the project and file level. We use Sonar to calculate the number of test cases and also to run test cases to analyze the impact of coverage on real bugs.
B. Large Scale Studies on GitHub Jiang et al. collect thousands of forks from GitHub to understand why and how developers fork what from GitHub  [19]. They conduct surveys, analyze programming languages and owners of forked repositories. They have several interesting findings a) developers forks repositories to submit pull requests, fix bugs, add nee features etc. and they use various sources such as search engines, external sites (e. g. , Twitter, Reddit), social relationships to find repositories to fork, b) developers are more likely to fork repositories written in their preferred language, and c) developers mostly fork repositories from creators. Zhang et al. propose an approach to detect similar repositories on GitHub  [40]. They make use of GitHub stars and readme files and use three heuristics: a) repositories with similar readme file content are likely to be similar, b) repositories starred by users having similar interests are likely to be similar, and c) respositories starred within a short period of time are likely to be similar.
Based on these heuristics, they build a recommendation system named RepoPal and compare it with state-of-the-art approach CLAN using one thousand repositories on GitHub. Sharma et al. collect 10,000 popular projects on GitHub and propose a cataloging system to group similar projects into categories  [33]. They automatically extract descriptive segments from readme files and aply LDA-GA, a state-of-the-art topic modeling algorithm that combines Latent Dirichlet Allocation (LDA) and Genetic Algorithm (GA), to identify categories. Their approach can identify new categories to complement exisitng GitHub categories and also identify new projects for existing categories. Casalnuovo et al. study 69 C and C++ projects to understand the correlation between asserts and defect occurrence and how assertion use is related to ownership and experience of methods by developers  [8].
They find that assertions are widely used in these projects and adding asserts has a small yet significant relationship with defect occurrence. They also find that asserts tend to be added to methods with higher ownership and developers with more experience have higher likelihood of adding asserts. Kochhar et al. perform a partial replication of Casalnuovo et al. study  [8]  to understand the correlation between assert usage and defect occurrence on a large dataset of 185 Java projects from GitHub  [24]. They collect several metrics such as number of asserts, number of defects, number of developers and number of lines changed to a method and also perform an in-depth qualitative study on 575 distinct methods, each containing at least one assert statement to understand assert usage patterns.
They find similar results as Casalnuovo et al. that asserts have a small yet significant relationship with defect occcurence. Furthermore, they find that asserts are used for several purposes such as null check, process state check, initialization check, resource check, resource lock check, minimum and maximum value constraint check, collection data and length check and implausible condition check. Vasilescu et al. analyse 246 projects from GitHub to investigate the impact of usage of Continuous Integration (CI) on quality and productivity  [37]. Their results show that teams using CI have more pull requests accepted from core contributors and fewer rejections from external contributors. Gousios et al. analyse pull-based software development model on a dataset on 291 projects from GitHub  [15].
They find that only 14% of the active projects use pull-requests and 60% of the pull-requests are processed in a day. Kochhar et al. analyse a large dataset of 628 projects from GitHub to understand the impact of using multiple languages on software quality  [27]. They build multiple regression models to study the effect of different languages on the number of bug fixing commits after controlling for factors such as project age, project size, team size, and the number of commits. They find that using multiple languages increases defect proneness and popular languages such as C++, Objective-C, Java etc. are more defect prone when used in multi-language setting. Vasilescu et al. use mixed-methods approach by surveying thousands of developers and analysing thousands of projects to investigate how gender and tenure diversity relate to team productivity and turnover  [36].
For most of the settings considered in this work, the relationship between test coverage and postrelease bugs are either non-existent or unclear (i. e. , statistically insignificant). Designing test cases for the sole purpose of increasing coverage may or may not translate to higher bug finding rate. In the future, we plan to analyse datasets from other open-source platforms to mitigate the external validity threats. Furthermore, we plan to collect a larger dataset of projects having significant representation across low, medium and high coverage levels to investigate the impact of different coverage levels on the number of post-release bugs.
Therefore, stated preference survey allows the acquisition of the necessary data to accurately estimate the most likely effects of the policies. A limited number of papers have considered specific stated preferences (SP) and behavioural models towards freight analysis  (Anand et al. , 2012; Gatta and Marcucci, 2016)  to capture freight stakeholder's opinions and to warrant a better understanding of policy effects  (Gatta and Marcucci, 2016). Marcucci et al. (2007)  quantify the willingness of private operators to use urban distribution centres. Puckett et al. (2007)  used a stated choice experiment to capture independent preferences and the effects of interactivity among buyers and sellers on urban freight services. The methodological procedure is to administer one questionnaire to assess sensitivities of buyers and sellers of urban freight services, considering the trade-offs between travel time and cost.
Phases of the methodological approach for the investigation The study was organized in four phases: (i) draft of the questionnaire for the profile of the respondents and the revealed preference survey; (ii) draft of the Stated Preference (SP) survey; (iii) data collection; (iv) data processing. In the first phase, we developed a questionnaire to get respondents' profiles (gender, age, income, education, neighborhood, and occupation) and revealed preference data about ecommerce habits (frequency, products purchased, average purchase price). Another data that we intended to acquire in this step was to understand the preferences regarding ADSs (features, location, mode of transportation, distance, time, and information system available). In the second phase, we designed the SP survey, including the variables of interest (attributes) and values (options) of the variables to be evaluated by respondents  (Kroes and Sheldon, 1988).
The respondents were invited to participate in the survey through email (on a voluntary basis). After answering the profile and the revealed preference survey, the respondents were also invited to participate in the SP survey (the SP survey was not applied to the whole sample). A sample analysis is presented in the next sub-section. In the fourth phase, data regarding online shoppers' profile and revealed preference were processed and analyzed using electronic spreadsheets. To discuss the results, it is important to notice that the average profile of our respondents matched the average Brazilian online shopper's profile, described by E-bit, a national reference on e-commerce data. The revealed preference results were then compared with data from the literature review (especially  Browne et al.
, 2001; Morganti and Dablanc, 2014; Iwan et al. , 2016). Moreover, SP data was processed using the "LMPC" software developed by  Souza (1999) , which provides the coefficient of each attribute and statistical tests to check the validity of the results. The validation of the data is done automatically in the data processing. The analyst can check the results of this validation using statistical outputs, such as the coefficient of determination (R 2 ) and t-test. The general fit of the model was evaluated using the R 2 , which varies between 0 and 1 (full-compliance data). We used the coefficients to analyze the probability of use of ADS in the scenarios analyzed through the multinomial logit model. For that, a utility function of each scenario analyzed was determined, and a multinomial logit model was estimated to determine the probability of an alternative to be chosen, considering the proposed ones.
99 of monthly income represented less than 9% of the collected data. Part of this sample (124 people) answered stated preference survey. Each interviewee imply in 4 answers (one for each set of alternative), resulting 496 answers. We considered the treatment of outliers, which is built in the LMPC software, to identify the divergent interviews in relation to the general behaviour of the population sampled. According to  Souza (2006) , LMPC software considers the probability value of each individual utility interview and determines, by descriptive methods, data diverged from the sampled set. Divergent interviews occur due misinterpretation of the alternatives by the respondents. To identify the discrete data,  Souza (1999)  proposed a review of the data through a specific algorithm, which considers the individual utility of each interview and determines, through descriptive methods, the data that deviate from the sampled set.
Link Existence and Movement Direction Monitoring It is important to be able to estimate if a link is about the break in order to anticipate and find a new next-hop. In order to do so, we monitor the existence of links and try to anticipate if the link is about the break or not based on the variation of RSSI values. In RRD+ every node monitors links between itself and nodes in the parents set in order to avoid packet loss when link does not exist. The parents set contains neighbour nodes that have lower rank values. We use the RSSI values to estimate link quality. RSSI values are obtained from acknowledgement messages (ACK) and DIO messages. At the initial stage, network topology is constructed using DIO messages and RSSI values are obtained from these messages. After topology construction, for each successfully received data packet, receivers will send an ACK.