1,923 research outputs found
The Co-Evolution of Test Maintenance and Code Maintenance through the lens of Fine-Grained Semantic Changes
Automatic testing is a widely adopted technique for improving software
quality. Software developers add, remove and update test methods and test
classes as part of the software development process as well as during the
evolution phase, following the initial release. In this work we conduct a large
scale study of 61 popular open source projects and report the relationships we
have established between test maintenance, production code maintenance, and
semantic changes (e.g, statement added, method removed, etc.). performed in
developers' commits.
We build predictive models, and show that the number of tests in a software
project can be well predicted by employing code maintenance profiles (i.e., how
many commits were performed in each of the maintenance activities: corrective,
perfective, adaptive). Our findings also reveal that more often than not,
developers perform code fixes without performing complementary test maintenance
in the same commit (e.g., update an existing test or add a new one). When
developers do perform test maintenance, it is likely to be affected by the
semantic changes they perform as part of their commit.
Our work is based on studying 61 popular open source projects, comprised of
over 240,000 commits consisting of over 16,000,000 semantic change type
instances, performed by over 4,000 software engineers.Comment: postprint, ICSME 201
Why Modern Open Source Projects Fail
Open source is experiencing a renaissance period, due to the appearance of
modern platforms and workflows for developing and maintaining public code. As a
result, developers are creating open source software at speeds never seen
before. Consequently, these projects are also facing unprecedented mortality
rates. To better understand the reasons for the failure of modern open source
projects, this paper describes the results of a survey with the maintainers of
104 popular GitHub systems that have been deprecated. We provide a set of nine
reasons for the failure of these open source projects. We also show that some
maintenance practices -- specifically the adoption of contributing guidelines
and continuous integration -- have an important association with a project
failure or success. Finally, we discuss and reveal the principal strategies
developers have tried to overcome the failure of the studied projects.Comment: Paper accepted at 25th International Symposium on the Foundations of
Software Engineering (FSE), pages 1-11, 201
Investigating the Impact of Continuous Integration Practices on the Productivity and Quality of Open-Source Projects
Background: Much research has been conducted to investigate the impact of
Continuous Integration (CI) on the productivity and quality of open-source
projects. Most of studies have analyzed the impact of adopting a CI server
service (e.g, Travis-CI) but did not analyze CI sub-practices. Aims: We aim to
evaluate the impact of five CI sub-practices with respect to the productivity
and quality of GitHub open-source projects. Method: We collect CI sub-practices
of 90 relevant open-source projects for a period of 2 years. We use regression
models to analyze whether projects upholding the CI sub-practices are more
productive and/or generate fewer bugs. We also perform a qualitative document
analysis to understand whether CI best practices are related to a higher
quality of projects. Results: Our findings reveal a correlation between the
Build Activity and Commit Activity sub-practices and the number of merged pull
requests. We also observe a correlation between the Build Activity, Build
Health and Time to Fix Broken Builds sub-practices and number of bug-related
issues. The qualitative analysis reveals that projects with the best values for
CI sub-practices face fewer CI-related problems compared to projects that
exhibit the worst values for CI sub-practices. Conclusions: We recommend that
projects should strive to uphold the several CI sub-practices as they can
impact in the productivity and quality of projects.Comment: Paper accepted for publication by The ACM/IEEE International
Symposium on Empirical Software Engineering and Measurement (ESEM
Healthy or Not: A Way to Predict Ecosystem Health in GitHub
With the development of open source community, through the interaction of developers, the collaborative development of software, and the sharing of software tools, the formation of open source software ecosystem has matured. Natural ecosystems provide ecological services on which human beings depend. Maintaining a healthy natural ecosystem is a necessity for the sustainable development of mankind. Similarly, maintaining a healthy ecosystem of open source software is also a prerequisite for the sustainable development of open source communities, such as GitHub. This paper takes GitHub as an example to analyze the health condition of open source ecosystem and, also, it is a research area in Symmetry. Firstly, the paper presents the healthy definition of GitHub open source ecosystem health and, then, according to the main components of natural ecosystem health, the paper proposes the health indicators and health indicators evaluation method. Based on the above, the GitHub ecosystem health prediction method is proposed. By analyzing the projects and data collected in GitHub, it is found that, using the proposed evaluation indicators and method, we can analyze the healthy development trend of the GitHub ecosystem and contribute to the stability of ecosystem development
Beyond Surveys: Analyzing Software Development Artifacts to Assess Teaching Efforts
This Innovative Practice Full Paper presents an approach of using software
development artifacts to gauge student behavior and the effectiveness of
changes to curriculum design. There is an ongoing need to adapt university
courses to changing requirements and shifts in industry. As an educator it is
therefore vital to have access to methods, with which to ascertain the effects
of curriculum design changes. In this paper, we present our approach of
analyzing software repositories in order to gauge student behavior during
project work. We evaluate this approach in a case study of a university
undergraduate software development course teaching agile development
methodologies. Surveys revealed positive attitudes towards the course and the
change of employed development methodology from Scrum to Kanban. However,
surveys were not usable to ascertain the degree to which students had adapted
their workflows and whether they had done so in accordance with course goals.
Therefore, we analyzed students' software repository data, which represents
information that can be collected by educators to reveal insights into learning
successes and detailed student behavior. We analyze the software repositories
created during the last five courses, and evaluate differences in workflows
between Kanban and Scrum usage
Scrum2Kanban: Integrating Kanban and Scrum in a University Software Engineering Capstone Course
Using university capstone courses to teach agile software development
methodologies has become commonplace, as agile methods have gained support in
professional software development. This usually means students are introduced
to and work with the currently most popular agile methodology: Scrum. However,
as the agile methods employed in the industry change and are adapted to
different contexts, university courses must follow suit. A prime example of
this is the Kanban method, which has recently gathered attention in the
industry. In this paper, we describe a capstone course design, which adds the
hands-on learning of the lean principles advocated by Kanban into a capstone
project run with Scrum. This both ensures that students are aware of recent
process frameworks and ideas as well as gain a more thorough overview of how
agile methods can be employed in practice. We describe the details of the
course and analyze the participating students' perceptions as well as our
observations. We analyze the development artifacts, created by students during
the course in respect to the two different development methodologies. We
further present a summary of the lessons learned as well as recommendations for
future similar courses. The survey conducted at the end of the course revealed
an overwhelmingly positive attitude of students towards the integration of
Kanban into the course
Analysis Software Developer Productivity Based On Work Schedule Scheme With Git Commit Metric And Deployment With CI/CD
Pada bulan Desember 2019, terjadi pandemi COVID-19 sehingga membuat PT. XYZ mewajibkan karyawannya untuk bekerja dari rumah dan bekerja dari kantor secara bergantian berdasarkan skema jadwal kerja yang ditentukan oleh PT. XYZ secara acak berdasarkan tim yang ada. Produktivitas bagi Pengembang Perangkat Lunak saat ini masih belum memiliki nilai yang pasti tentang bagaimana menilai produktivitas seorang Pengembang Perangkat Lunak. Hal inilah yang membuat penelitian ini dilakukan untuk mengkaji lebih lanjut produktivitas pengembang perangkat lunak di PT. XYZ berada di antara skema jadwal kerja tersebut. Dalam penelitian ini kami melakukan investigasi terhadap produktivitas pengembang perangkat lunak berdasarkan skema jadwal kerja yang telah ditentukan dari perusahaan, PT.XYZ menerapkan 3 skema untuk jadwal karyawan, yang kemudian disesuaikan dengan kondisi pandemi COVID yang terjadi agar sesuai dengan peraturan pemerintah , skemanya adalah, 2 hari WFO 3 hari WFH, 3 hari WFO 2 hari WFH, 4 hari WFO 1 hari WFH untuk menghindari banyaknya karyawan yang bekerja dari kantor pusat PT. XYZ, kemudian kumpulan data yang dikumpulkan dari aktivitas kontribusi pada repositori PT.XYZ GitHub berdasarkan git commit dan bergabung ke cabang master, kemudian akan di-deploy menggunakan CI/CD. sesuai dengan skema jadwal kerja. Dalam penelitian ini ditemukan bahwa skema jadwal kerja 3 WFH dan 2 WFO memiliki tingkat produktivitas yang lebih tinggi dibandingkan dengan skema lainnya. Dari jenis proyek, Back-end memiliki kontribusi lebih dibandingkan dengan Front-end serta bahasa pemrograman
- …