There are many aspects of code quality, some of which are difficult to capture or to measure. Despite the importance of software quality, there is a lack of commonly accepted measures or indicators for code quality that can be linked to quality attributes. We investigate software developers’ perceptions of source code quality and the practices they recommend to achieve these qualities. We analyze data from semi-structured interviews with 34 professional software developers, programming teachers and students from Europe and the U.S. For the interviews, participants were asked to bring code examples to exemplify what they consider good and bad code, respectively. Readability and structure were used most commonly as defining properties for quality code. Together with documentation, they were also suggested as the most common target properties for quality improvement. When discussing actual code, developers focused on structure, comprehensibility and readability as quality properties. When analyzing relationships between properties, the most commonly talked about target property was comprehensibility. Documentation, structure and readability were named most frequently as source properties to achieve good comprehensibility. Some of the most important source code properties contributing to code quality as perceived by developers lack clear definitions and are difficult to capture. More research is therefore necessary to measure the structure, comprehensibility and readability of code in ways that matter for developers and to relate these measures of code structure, comprehensibility and readability to common software quality attributes.

This paper presents the activities of the Applied IoT Lab at the Department of Computer Science and Media Technology, Linnaeus University (LNU), Kalmar, Sweden. The lab is actively engaged in IoT-based educational programs, including a series of workshops and pilot cases. The lab is funded by the European Union and two Swedish counties – Kalmar and Kronoberg. The workshops and pilot cases are part of the research project named IoT Lab for Small and Medium-sized Enterprises (SMEs). One of the lab’s main objectives is to strengthen and support local companies with IoT. The project IoT Lab for SMEs also aims to spread knowledge and inspire the local community about the possibilities of using IoT technologies by organizing open lab days, in-depth lectures, and seminars. This paper introduces Applied IoT Lab at LNU, its educational programs, and industry-academic cooperation, including workshops and a number of ongoing pilot cases.

The Internet of Things (IoT) have shown numerous potential applications that can enhance our quality of life. IoT is becoming a core technology to bring smart homes, smart cities, and smart industries into reality. However, with potential benefits comes a challenge of sustainability, and one major concern is to minimize energy consumption. In a citywide area, managing the operation of such large-scale IoT networking is one of the complex tasks. One of the ways is to utilize dynamic sensing scheduling where the IoT device goes to the sleep mode and prevents unnecessary data transmission. In this paper, we propose a dynamic sensing (DynaSens) algorithm for an IoT-based waste management system. This algorithm helps to reduce the waste bin overflowing, thus, provides better sanitation, and it is also helpful in reducing the fuel cost of waste collection vehicles. Our work utilizes measured values such as current consumption, LiDAR measurement time, and LoRa transmission time as the input data for the simulation experiment to evaluate energy consumption. We also assessed DynaSens using a real dataset obtained from a recycling house. We use Pycom LoPy4 micro-controller as a development board. For a number of garbage-thrown scenarios, DynaSens enables longer battery longevity by reducing the repeated execution of the same tasks. © 2022 IEEE.

The core of this work-in-progress is that the best way to learn how to code is to practice by solving problems. However, if students have trouble with this, they can get frustrated and give up. Automated Tutoring Systems (ATS) aim to provide hints to help them solve the problems they encounter. Many of the existing systems offer general hints, e.g., “check the conditional statement” or help the student interpret the compiler or test-case errors. While this can be useful, we think that an ATS should provide interactive and specialized feedback for each program. We snowballed through publications on promising ATS and found that there are several such systems (in 27 publications), but we could also identify many challenges and that our requirements were not met by any existing system. For example, few of them work on general-purpose programming languages, e.g., Java, or scale to realistic problems consisting of multiple methods and classes. From the search, we find ATS based on Automated Program Repair (APR) shows the most promise. However, while program repair has the potential to generate specialized hints to help guide the student to a working state, studies that looked into these have identified further challenges. For example, many APR ATS tools only show the repaired program to the students, who then have to compare and modify their program accordingly. Another issue is that APR generally only modifies a few lines, so if the student solution is far from correct, the repair might fail. This can be solved by partial repair, i.e., the program is repaired so at least one additional test-case passes. While this increases the repair rate, it might make hints more difficult or point the students in a non-obvious or even “wrong” direction. The APR can take several minutes, which also makes it unsuitable for interactive ATS. We take a design science approach to define an ATS based on APR that attempts to address the identified challenges. We give a review of the state-of-the-art for the required components, e.g., APR, how to generate hints from differences between two programs. From this, we suggest a threestep roadmap; 1. identify suitable APR-tools, 2. construct an oversized test-suite, and 3. adopt APR to the tutoring context.

Context. Code quality is a key issue in software development. The ability to develop high quality software is therefore a key learning goal of computing programs. However, there are no universally accepted measures to assess the quality of code and current standards are considered weak. Furthermore, there are many facets to code quality. Defining and explaining the concept of code quality is therefore a challenge faced by many educators. Objectives. In this working group, we investigated code quality as perceived by students, educators, and professional developers, in particular, the differences in their views of code quality and which quality aspects they consider as more or less important. Furthermore, we investigated their sources for information about code quality and its assessment. Methods. We interviewed 34 students, educators and professional developers regarding their perceptions of code quality. For the interviews they brought along code from their own experience to discuss and exemplify code quality. Results. There was no common definition of code quality among or within these groups. Quality was mostly described in terms of indicators that could measure an aspect of code quality. Among these indicators, readability was named most frequently by all groups. The groups showed significant differences in the sources they use for learning about code quality with education ranked lowest in all groups. Conclusions. Code quality should be discussed more thoroughly in educational programs.

Learning programming with tutor tools has grown in popularity. These tools present programming assignments and provide feedback in the form of test-cases and compilation errors. Our timeline visualization of data from one such tool allows us to tell a story about what files were accessed and for how long, in what order files were edited, grown or shrunk, what errors the student ran into, and how those errors were addressed. This can be done without a need to read and replay the entire programming session. In sum, the tool has been used to visualize logs from students that tried to solve programming assignments and we find interesting stories that can help us improve how we address new assignments.

We wanted to introduce peer reviews for the final report in a course on Software Testing. The students had however experienced issues with peer reviews in a previous course which made this a challenge. To get a better understanding of the situation, we distributed a pre-questionnaire to the students. 48 of the 83 students provided their expectations on peer reviews. To deal with some of the perceived issues, we developed a peer review tool where we introduce anonymity, grading of reviews, teacher interventions, as well as let students score and comment on the reviews they receive. In total, 67 reports were submitted by 83 students and 325 reviews were completed. The post-questionnaire was answered by 48 students (not necessarily the same respondents as for the pre-questionnaire as both were collected anonymously). While 27 of the students expected incorrect feedback only 13 students agreed to have got incorrect feedback in the post-questionnaire. The students reported that they found the feedback from their peers more valuable (+15%) than expected, and 88% of the students reported that they learned from doing peer reviews. Overall, we find that the students' attitudes towards peer reviews have improved.

Code quality is a key issue in software development. The ability to develop software of high quality is therefore a key learning goal of computing programs. However, there are no universally accepted measures to assess the quality of code and current standards are consideredweak. Furthermore, there are many facets to code quality. Defining and explaining the concept of code quality is therefore a challenge faced by many educators. In this working group, we investigate the perceptions of code quality of students, teachers, and professional programmers. In particular, we are interested in the differences in views of code quality by students, educators, and professional programmers and which quality aspects they consider as more or less important. Furthermore, we are interested in which sources of information on code quality and its assessment are used by these groups. Eventually, this will help us to develop resources that can be used to broaden students' views on software quality.

Static architectural conformance checking can be used to find architectural violations, cases where the implementation does not adhere to the architecture, and prevent architectural erosion. We implement a software service for automated conformance checking and investigate the effect this has on the number of architectural violations in software projects. The service is implemented using our heuristic-based approach to static architecture conformance checking of the Model-View-Controller pattern. The service is integrated in the source code management system of each project, so a report is generated every time the source code is modified. The service was evaluated in a field experiment that consisted of eight student projects. We found that the four projects that used the service produced significantly fewer violations compared to those that did not.

It is not possible to directly observe how students work in an online programming course. This makes it harder for teachers to help struggling students. By using an online programming environment, we have the opportunity to record what the students actually do to solve an assignment. These recordings can be analyzed to provide teachers with valuable information. We developed such an online programming tool with fine-grained event logging and used it to observe how our students solve problems. Our tool provides descriptive statistics and accurate replays of a student's programming sessions, including mouse movements. We used the tool in a course and collected 1028 detailed recordings. In this article, we compare fine-grained logging to existing coarse-grained logging solutions to estimate assignment-solving time. We find that time aggregations are improved by including time for active reading and navigation, both enabled by the increased granularity. We also divide the time users spent into editing (on average 14.8%), active use (on average 37.8%), passive use (on average 29.0%), and estimate time used for breaks (on average 18.2%). There is a correlation between assignment solving time for students who pass assignments early and students that pass later but also a case where the times differ significantly. Our tool can help improve computer engineering education by providing insights into how students solve programming assignments and thus enable teachers to target their teaching and/or improve instructions and assignments.