Matthies, C., Dobrigkeit, F.: Towards Empirically Validated Remedies for Scrum Retrospective Headaches.Proceedings of the 53rd Hawaii International Conference on System Sciences (HICSS) (2020).
Agile methods, especially Scrum, have become staples of the modern software development industry. Retrospective meetings are Scrum's instrument for process improvement and adaptation. They are considered one of the most important aspects of the Scrum method and its implementation in organizations. However, Retrospectives face their own challenges. Agile practitioners have highlighted common problems, i.e. headaches, that repeatedly appear in meetings and negatively impact the quality of process improvement efforts. To remedy these headaches, Retrospective activities, which can help teams think together and break the usual routine, have been proposed. In this research, we present case studies of educational and industry teams, investigating the effects of eleven Retrospective activities on five identified headaches. While we find evidence for the claimed benefits of activities in the majority of studied cases, application of remedies also led to new headaches arising.
Matthies, C., Dobrigkeit, F., Hesse, G.: Mining for Process Improvements: Analyzing Software Repositories in Agile Retrospectives.IEEE/ACM International Conference on Software Engineering Workshops (ICSEW) (2020).
Software Repositories contain knowledge on how software engineering teams work, communicate, and collaborate. It can be used to develop a data-informed view of a team's development process, which in turn can be employed for process improvement initiatives. In modern, Agile development methods, process improvement takes place in Retrospective meetings, in which the last development iteration is discussed. However, previously proposed activities that take place in these meetings often do not rely on project data, instead depending solely on the perceptions of team members. We propose new Retrospective activities, based on mining the software repositories of individual teams, to complement existing approaches with more objective, data-informed process views.
Matthies, C., Dobrigkeit, F., Ernst, A.: Counteracting Agile Retrospective Problems with Retrospective Activities. In: Walker, A., O'Connor, R.V., and Messnarz, R. (eds.) Systems, Software and Services Process Improvement. EuroSPI 2019. Communications in Computer and Information Science. pp. 532-545. Springer International Publishing (2019).
Retrospective meetings are a fundamental part of Agile software development methods. Effective retrospectives can positively impact teamwork, productivity, and work satisfaction. In this paper, we focus on problems that commonly occur during these meetings. To address them, we suggest retrospective activities that are already used in practice. These activities provide structure and guide the team through the meeting. We created a mapping between a selection of these activities and the problems they attempt to solve. We evaluated the created mapping through multiple case studies with software development teams in educational and professional contexts. Our results verify the existence of a relationship between specific retrospective activities and connected retrospective problems. Furthermore, using observational studies we could verify parts of the created problem-activity mapping.
Matthies, C.: Agile Process Improvement in Retrospectives.2019 IEEE/ACM 41st International Conference on Software Engineering: Companion Proceedings (ICSE-Companion). pp. 150-152. IEEE (2019).
Working in iterations and repeatedly improving team workflows based on collected feedback is fundamental to agile software development processes. Scrum, the most popular agile method, provides dedicated retrospective meetings to reflect on the last development iteration and to decide on process improvement actions. However, agile methods do not prescribe how these improvement actions should be identified, managed or tracked in detail. The approaches to detect and remove problems in software development processes are therefore often based on intuition and prior experiences and perceptions of team members. Previous research in this area has focused on approaches to elicit a team's improvement opportunities as well as measurements regarding the work performed in an iteration, e.g. Scrum burn-down charts. Little research deals with the quality and nature of identified problems or how progress towards removing issues is measured. In this research, we investigate how agile development teams in the professional software industry organize their feedback and process improvement approaches. In particular, we focus on the structure and content of improvement and reflection meetings, i.e. retrospectives, and their outcomes. Researching how the vital mechanism of process improvement is implemented in practice in modern software development leads to a more complete picture of agile process improvement.
Matthies, C.: Feedback in Scrum: Data-Informed Retrospectives.2019 IEEE/ACM 41st International Conference on Software Engineering: Companion Proceedings (ICSE-Companion). pp. 198-201. IEEE (2019).
Improving the way that teams work together by reflecting and improving the executed process is at the heart of agile processes. The idea of iterative process improvement takes various forms in different agile development methodologies, e.g. Scrum Retrospectives. However, these methods do not prescribe how improvement steps should be conducted in detail. In this research we investigate how agile software teams can use their development data, such as commits or tickets, created during regular development activities, to drive and track process improvement steps. Our previous research focused on data-informed process improvement in the context of student teams, where controlled circumstances and deep domain knowledge allowed creation and usage of specific process measures. Encouraged by positive results in this area, we investigate the process improvement approaches employed in industry teams. Researching how the vital mechanism of process improvement is implemented and how development data is already being used in practice in modern software development leads to a more complete picture of agile process improvement. It is the first step in enabling a data-informed feedback and improvement process, tailored to a team's context and based on the development data of individual teams.
Matthies, C., Hesse, G.: Towards Using Data to Inform Decisions in Agile Software Development: Views of Available Data.Proceedings of the 14th International Conference on Software Technologies - Volume 1: ICSOFT. pp. 552-559. SciTePress (2019).
Software development comprises complex tasks which are performed by humans. It involves problem solving, domain understanding and communication skills as well as knowledge of a broad variety of technologies, architectures, and solution approaches. As such, software development projects include many situations where crucial decisions must be made. Making the appropriate organizational or technical choices for a given software team building a product can make the difference between project success or failure. Software development methods have introduced frameworks and sets of best practices for certain contexts, providing practitioners with established guidelines for these important choices. Current Agile methods employed in modern software development have highlighted the importance of the human factors in software development. These methods rely on short feedback loops and the self-organization of teams to enable collaborative decision making. While Agile methods stress the importance of empirical process control, i.e. relying on data to make decisions, they do not prescribe in detail how this goal should be achieved. In this paper, we describe the types and abstraction levels of data and decisions within modern software development teams and identify the benefits that usage of this data enables. We argue that the principles of data-driven decision making are highly applicable, yet underused, in modern Agile software development.
Hesse, G., Sinzig, W., Matthies, C., Uflacker, M.: Application of Data Stream Processing Technologies in Industry 4.0: What is Missing?Proceedings of the 8th International Conference on Data Science, Technology and Applications - Volume 1: DATA. pp. 304-310. SciTePress (2019).
Industry 4.0 is becoming more and more important for manufacturers as the developments in the area of Internet of Things advance. Another technology gaining more attention is data stream processing systems. Although such streaming frameworks seem to be a natural fit for Industry 4.0 scenarios, their application in this context is still low. The contributions in this paper are threefold. Firstly, we present industry findings that we derived from site inspections with a focus on Industry 4.0. Moreover, our view on Industry 4.0 and important related aspects is elaborated. As a third contribution, we illustrate our opinion on why data stream processing technologies could act as an enabler for Industry 4.0 and point out possible obstacles on this way.
Hesse, G., Matthies, C., Glass, K., Huegle, J., Uflacker, M.: Quantitative Impact Evaluation of an Abstraction Layer for Data Stream Processing Systems.2019 IEEE 39th International Conference on Distributed Computing Systems (ICDCS). pp. 1381-1392 (2019).
With the demand to process ever-growing data volumes, a variety of new data stream processing frameworks have been developed. Moving an implementation from one such system to another, e.g., for performance reasons, requires adapting existing applications to new interfaces. Apache Beam addresses these high substitution costs by providing an abstraction layer that enables executing programs on any of the supported streaming frameworks. In this paper, we present a novel benchmark architecture for comparing the performance impact of using Apache Beam on three streaming frameworks: Apache Spark Streaming, Apache Flink, and Apache Apex. We find significant performance penalties when using Apache Beam for application development in the surveyed systems. Overall, usage of Apache Beam for the examined streaming applications caused a high variance of query execution times with a slowdown of up to a factor of 58 compared to queries developed without the abstraction layer. All developed benchmark artifacts are publicly available to ensure reproducible results.
Hesse, G., Matthies, C., Sinzig, W., Uflacker, M.: Adding Value by Combining Business and Sensor Data: An Industry 4.0 Use Case. In: Li, G., Yang, J., Gama, J., Natwichai, J., and Tong, Y. (eds.) Database Systems for Advanced Applications. DASFAA 2019. Lecture Notes in Computer Science. pp. 528-532. Springer International Publishing (2019).
Industry 4.0 and the Internet of Things are recent developments that have lead to the creation of new kinds of manufacturing data. Linking this new kind of sensor data to traditional business information is crucial for enterprises to take advantage of the data's full potential. In this paper, we present a demo which allows experiencing this data integration, both vertically between technical and business contexts and horizontally along the value chain. The tool simulates a manufacturing company, continuously producing both business and sensor data, and supports issuing ad-hoc queries that answer specific questions related to the business. In order to adapt to different environments, users can configure sensor characteristics to their needs.
Matthies, C., Dobrigkeit, F., Hesse, G.: An Additional Set of (Automated) Eyes: Chatbots for Agile Retrospectives.2019 IEEE/ACM 1st International Workshop on Bots in Software Engineering (BotSE). pp. 34-37. IEEE (2019).
With the recent advances in natural-language processing, combined with the ability to analyze large amounts of data across various domains, software bots can become virtual team members, providing an additional set of automated eyes and additional perspectives for informing and supporting teamwork. In this paper, we propose employing chatbots in the domain of software development with a focus on supporting analyses and measurements of teams' project data. The software project artifacts produced by agile teams during regular development activities, e.g. commits in a version control system, represent detailed information on how a team works and collaborates. Analyses of this data are especially relevant for agile retrospective meetings, where adaptations and improvements to the executed development process are discussed. Development teams can use these measurements to track the progress of identified improvement actions over development iterations. Chatbots provide a convenient user interface for interacting with the outcomes of retrospectives and the associated measurements in a chat-based channel that is already being employed by team members.
Matthies, C., Huegle, J., Dürschmid, T., Teusner, R.: Attitudes, Beliefs, and Development Data Concerning Agile Software Development Practices.2019 IEEE/ACM 41st International Conference on Software Engineering: Software Engineering Education and Training (ICSE-SEET). pp. 158-169. IEEE (2019).
The perceptions and attitudes of developers impact how software projects are run and which development practices are employed in development teams. Recent agile methodologies have taken this into account, focusing on collaboration and shared team culture. In this research, we investigate the perceptions of agile development practices and their usage in Scrum software development teams. Although perceptions collected through surveys of 42 participating students did not evolve significantly over time, our analyses show that the Scrum role significantly impacted participants' views of employed development practices. We find that using the version control system according to agile ideas was consistently rated most related to the values of the Agile Manifesto. Furthermore, we investigate how common software development artifacts can be used to gain insights into team behavior and present the development data measurements we employed. We show that we can reliably detect well-defined agile practices, such Test-Driven Development, in this data and that usage of these practices coincided with participants' self-assessments.
Matthies, C.: Scrum2Kanban: Integrating Kanban and Scrum in a University Software Engineering Capstone Course.Proceedings of the 2nd International Workshop on Software Engineering Education for Millennials. pp. 48-55. ACM, New York, NY, USA (2018).
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.
Hesse, G., Reissaus, B., Matthies, C., Lorenz, M., Kraus, M., Uflacker, M.: Senska - Towards an Enterprise Streaming Benchmark.TPC Technology Conference (TPCTC). pp. 25-40. , Cham (2018).
In the light of growing data volumes and continuing digitization in fields such as Industry 4.0 or Internet of Things, data stream processing have gained popularity and importance. Especially enterprises can benefit from this development by augmenting their vital, core business data with up-to-date streaming information. Enriching this transactional data with detailed information from high-frequency data streams allows answering new analytical questions as well as improving current analyses, e.g., regarding predictive maintenance. Comparing such data stream processing architectures for use in an enterprise context, i.e., when combining streaming and business data, is currently a challenging task as there is no suitable benchmark.
Teusner, R., Matthies, C., Staubitz, T.: What Stays in Mind? - Retention Rates in Programming MOOCs.2018 IEEE Frontiers in Education Conference (FIE) (2018).
This work presents insights about the long-term effects and retention rates of knowledge acquired within MOOCs. In 2015 and 2017, we conducted two introductory MOOCs on object-oriented programming in Java with each over 10,000 registered participants. In this paper, we analyze course scores, quiz results and self-stated skill levels of our participants. The aim of our analysis is to uncover factors influencing the retention of acquired knowledge, such as time passed or knowledge application, in order to improve long-term success. While we know that some participants learned the programming basics within our course, we lack information on whether this knowledge was applied and fortified after the course's end. To fill this knowledge gap, we conducted a survey in 2018 among all participants of our 2015 and 2017 programming MOOCs. The first part of the survey elicits responses on whether and how MOOC knowledge was applied and gives participants opportunity to voice individual feedback. The second part of the survey contains several questions of increasing difficulty and complexity regarding course content in order to learn about the consolidation of the acquired knowledge. We distinguish three programming knowledge areas in the survey: First, understanding of concepts, such as loops and boolean algebra. Second, syntax knowledge, such as specific keywords. Third, practical skills including debugging and coding. We further analyzed the long-term effects separately per participant skill group. While answer rates were low, the collected data shows a decrease of knowledge over time, relatively unaffected by skill level. Application of the acquired knowledge improves the memory retention rates of MOOC participants across all skill levels.
Matthies, C., Teusner, R., Hesse, G.: Beyond Surveys: Analyzing Software Development Artifacts to Assess Teaching Efforts.IEEE Frontiers in Education Conference (FIE). pp. 1-9 (2018).
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.
Matthies, C.: Relying on Development Data for Software Development Processes. In: Meinel, C., Plattner, H., Döllner, J., Weske, M., Polze, A., Hirschfeld, R., Naumann, F., Giese, H., Baudisch, P., Friedrich, T., and Müller, E. (eds.) Proceedings of the 10th Ph. D. Retreat of the HPI Research School on Service-oriented Systems Engineering. pp. 161-170. Universitätsverlag Potsdam, Potsdam, Germany (2018).
The way that developers work together, manage tasks and organize themselves impacts the software that is produced. There is thus the need to practice and uphold an effective software development process. When it comes to improving or finding weaknesses in the executed process, teams often rely on self-improvement sessions or mentoring by a knowledgeable third party. These methods rely on subjective evaluations and their results are hard to quantify. After changes are implemented it is difficult to assess their impact and whether an identified issue was fully resolved. In order to tackle these challenges we propose an approach relying on analysing data created by software development teams. Software developers create more than just code during regular development activities. Development artifacts, such as commits, tickets, wiki pages, code coverage statistics and build logs, contain information on how a team worked together. By aggregating, linking and analysing this already present data, insights into the development process of teams can be generated.
Matthies, C., Treffer, A., Uflacker, M.: Prof. CI: Employing Continuous Integration Services and GitHub Workflows to Teach Test-Driven Development.2017 IEEE Frontiers in Education Conference (FIE). pp. 1-8 (2017).
Teaching programming using Massive Open Online Courses (MOOCs) is gaining popularity due to their scalability and efficiency of knowledge distribution. However, participating in these courses usually means fully committing to the supplied programming environment in the browser. While this allows a consistent and controllable setup, learners do not gain experience with actual development tools, such as local code editors, testing frameworks, issue trackers or continuous integration (CI) services, which is critical for subsequent real-world projects. Furthermore, the tests for the functionality that is to be developed are oftentimes already available in MOOCs and simply need to be executed, leading to less involvement with developing appropriate tests. In order to tackle these issues while maintaining a high degree of automation and scalability, we developed Prof. CI, a novel approach to conducting online exercises. Prof. CI leverages the existing automation infrastructure that developers use daily, i.e. CI services and Github workflows, to teach test-driven development (TDD) practices. Participants work on their own repositories in Github and receive feedback and new challenges from the CI server when they push their code. We have successfully applied this approach in a pilot project with 30 undergraduate students learning the Ruby on Rails web development framework. Our evaluation shows that the exercise effectively increased students' motivation to write tests for their code. We also present the results of participant surveys, students' experiences and teachers' observations.
Teusner, R., Matthies, C., Giese, P.: Should I Bug You? Identifying Domain Experts in Software Projects Using Code Complexity Metrics.2017 IEEE International Conference on Software Quality, Reliability and Security (QRS). pp. 418-425 (2017).
In any sufficiently complex software system there are experts, having a deeper understanding of parts of the system than others. However, it is not always clear who these experts are and which particular parts of the system they can provide help with. We propose a framework to elicit the expertise of developers and recommend experts by analyzing complexity measures over time. Furthermore, teams can detect those parts of the software for which currently no, or only few experts exist and take preventive actions to keep the collective code knowledge and ownership high. We employed the developed approach at a medium-sized company. The results were evaluated with a survey, comparing the perceived and the computed expertise of developers. We show that aggregated code metrics can be used to identify experts for different software components. The identified experts were rated as acceptable candidates by developers in over 90% of all cases.
Hesse, G., Matthies, C., Reissaus, B., Uflacker, M.: A New Application Benchmark for Data Stream Processing Architectures in an Enterprise Context: Doctoral Symposium.ACM International Conference on Distributed and Event-based Systems (DEBS). pp. 359-362 (2017).
Against the backdrop of ever-growing data volumes and trends like the Internet of Things (IoT) or Industry 4.0, Data Stream Processing Systems (DSPSs) or data stream processing architectures in general receive a greater interest. Continuously analyzing streams of data allows immediate responses to environmental changes. A challenging task in that context is assessing and comparing data stream processing architectures in order to identify the most suitable one for certain settings. The present paper provides an overview about performance benchmarks that can be used for analyzing data stream processing applications. By describing shortcomings of these benchmarks, the need for a new application benchmark in this area, especially for a benchmark covering enterprise architectures, is highlighted. A key role in such an enterprise context is the combination of streaming data and business data, which is barely covered in current data stream processing benchmarks. Furthermore, first ideas towards the development of a solution, i.e., a new application benchmark that is able to fill the existing gap, are depicted.
Matthies, C., Kowark, T., Uflacker, M., Plattner, H.: Agile Metrics for a University Software Engineering Course.2016 IEEE Frontiers in Education Conference (FIE). pp. 1-5. IEEE (2016).
Teaching agile software development by pairing lectures with hands-on projects has become the norm. This approach poses the problem of grading and evaluating practical project work as well as process conformance during development. Yet, few best practices exist for measuring the success of students in implementing agile practices. Most university courses rely on observations during the course or final oral exams. In this paper, we propose a set of metrics which give insights into the adherence to agile practices in teams. The metrics identify instances in development data, e.g. commits or user stories, where agile processes were not followed. The identified violations can serve as starting points for further investigation and team discussions. With contextual knowledge of the violation, the executed process or the metric itself can be refined. The metrics reflect our experiences with running a software engineering course over the last five years. They measure aspects which students frequently have issues with and that diminish process adoption and student engagement. We present the proposed metrics, which were tested in the latest course installment, alongside tutoring, lectures, and oral exams.
Kowark, T., Matthies, C., Uflacker, M., Plattner, H.: Lightweight Collection and Storage of Software Repository Data with DataRover.Proceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering. pp. 810-815. ACM, New York, NY, USA (2016).
The ease of setting up collaboration infrastructures for software engineering projects creates a challenge for researchers that aim to analyze the resulting data. As teams can choose from various available software-as-a-service solutions and can configure them with a few clicks, researchers have to create and maintain multiple implementations for collecting and aggregating the collaboration data in order to perform their analyses across different setups. The DataRover system presented in this paper simplifies this task by only requiring custom source code for API authentication and querying. Data transformation and linkage is performed based on mappings, which users can define based on sample responses through a graphical front end. This allows storing the same input data in formats and databases most suitable for the intended analysis without requiring additional coding. Furthermore, API responses are continuously monitored to detect changes and allow users to update their mappings and data collectors accordingly. A screencast of the described use cases is available at https: //youtu.be/mt4ztff4SfU.
Matthies, C., Kowark, T., Richly, K., Uflacker, M., Plattner, H.: How Surveys, Tutors, and Software Help to Assess Scrum Adoption in a Classroom Software Engineering Project.Proceedings of the 38th International Conference on Software Engineering Companion. pp. 313-322. ACM, New York, NY, USA (2016).
Agile methods are best taught in a hands-on fashion in realistic projects. The main challenge in doing so is to assess whether students apply the methods correctly without requiring complete supervision throughout the entire project. This paper presents experiences from a classroom project where 38 students developed a single system using a scaled version of Scrum. Surveys helped us to identify which elements of Scrum correlated most with student satisfaction or posed the biggest challenges. These insights were augmented by a team of tutors, which accompanied main meetings throughout the project to provide feedback to the teams, and captured impressions of method application in practice. Finally, we performed a post-hoc, tool-supported analysis of collaboration artifacts to detect concrete indicators for anti-patterns in Scrum adoption. Through the combination of these techniques we were able to understand how students implemented Scrum in this course and which elements require further lecturing and tutoring in future iterations. Automated analysis of collaboration artifacts proved to be a promising addition to the development process that could potentially reduce manual efforts in future courses and allow for more concrete and targeted feedback, as well as more objective assessment.
Matthies, C., Kowark, T., Richly, K., Uflacker, M., Plattner, H.: ScrumLint: Identifying Violations of Agile Practices Using Development Artifacts.Proceedings of the 9th International Workshop on Cooperative and Human Aspects of Software Engineering. pp. 40-43. ACM, New York, NY, USA (2016).
Linting tools automatically identify source code fragments that do not follow a set of predefined standards. Such feedback tools are equally desirable for "linting" agile development processes. However, providing concrete feedback on process conformance is a challenging task, due to the intentional lack of formal agile process models. In this paper, we present ScrumLint, a tool that tackles this issue by analyzing development artifacts. On the basis of experiences with an undergraduate agile software engineering course, we defined a collection of process metrics. These contain the core ideas of agile methods and report deviations. Using this approach, development teams receive immediate feedback on their executed development practices. They can use this knowledge to improve their workflows, or can adapt the metrics to better reflect their project reality.
Matthies, C., Kowark, T., Uflacker, M.: Teaching Agile the Agile Way — Employing Self-Organizing Teams in a University Software Engineering Course.2016 American Society for Engineering Education (ASEE) International Forum (2016).
Teaching students the basics of agile software development, by pairing lectures with a practical project, has been a part of computer science curricula for the last decades. However, the structure of these projects is often not agile and adaptable itself, in the way how teams are formed, workload is assigned, and meetings are organised. This restricts the areas that students can gather firsthand experiences in. In this paper we describe a university software engineering course which applies the values of the Agile Manifesto to the course design itself. Students work in self-organizing teams and are given significant authority and responsibility for their work, including planning, scheduling, and workload assignment. During the project they are guided by tutors and supported by a minimal amount of traditional lectures. We regularly assess learning progress and satisfaction via surveys and compare the results to those of more controlled course setups. We have observed positive student attitudes towards the self-organizing approach, with no adverse effects of the novel course design in terms of participant satisfaction or learning success. This confirms that the benefits of agile values, reported in the literature, are also applicable in the domain of education on the subject and can help increase student engagement and provide a better learning experience.
