Following code style conventions in software projects is essential for maintaining overall code quality. Adhering to these conventions improves maintainability, understandability, and extensibility. Additionally, following best practices during software development enhances performance and reduces the likelihood of errors. This paper analyzes 1, 036 popular open-source JAVA projects on GitHub to study how code style and programming practices are adopted and evolve over time, examining their prevalence and the most common violations. Additionally, we study a subset of active repositories on a monthly basis to track changes in adherence to coding standards over time. We found widespread violations across repositories, with Javadoc and Naming violations being the most common. We also found a significant number of violations of the Google Java Style Guide in categories often missed by modern static analysis tools. Furthermore, repositories claiming to follow code-style practices exhibited slightly higher overall adherence to code-style and best-practices. The results provide valuable insights into the adoption of code style and programming practices, highlighting key areas for improvement in the open-source development community. Furthermore, the paper identifies important lessons learned and suggests future directions for improving code quality in JAVA projects.

Automated assessment of programming assignments is essential in software engineering education, especially for large classes where manual grading is impractical. While static analysis can evaluate code style and syntax correctness, it cannot assess the functional correctness of students' implementations. Dynamic analysis through software testing can verify program behavior and provide automated feedback to students. However, traditional unit and integration tests often restrict students' design freedom by requiring predefined interfaces and method declarations. In this paper, we present SYSCLI, a novel testing framework for system-level testing of JAVA-based command-Line interface applications. SYSCLI enables test suites that evaluate the functional correctness of students' implementations without limiting their design choices. We also share our experience using SYSCLI in a second-year programming course at the University of Auckland, which focuses on object-oriented programming and design patterns and enrolls over 300 students each offering. Analysis of student assignments from 2023 and 2024 shows that SYSCLI is effective in automating grading, allows software design flexibility, and provides actionable feedback to students. Our experience report offers valuable insights into assessing students' implementation of object-oriented concepts and design patterns.

There is a growing call for research into how digital technology usage during childhood contributes to shaping contemporary digital divides. To our knowledge, the current study is the first to examine ways of maximising children’s chances of developing modes of use that involve greater engagement with more advanced and creative digital activities. Drawing on our prior research identifying four distinct modes of using digital technologies in 8-year-old New Zealand children (Creative, Entertainment, Emergent and Limited), we used hierarchical logistic regression in a large sample (N = 3325) to explore the predictors of these modes of use. Several modifiable screen parenting practices associated with modes of use were identified. Collectively, these results indicate that parents can facilitate more constructive digital technology use by fostering active engagement with screens from an early age, discouraging passive screen time and environmental TV exposure, providing access to laptops or computers, implementing software controls judiciously and adhering to social media age restrictions. Socioeconomic status influenced all four modes of use, highlighting the persistence of first-order digital divides. Together our findings offer insights into how parents can support their children to develop more effective digital skills, which may go some way towards mitigating the impact of digital divides.

GitHub Copilot is an artificial intelligence tool for automatically generating source code from natural language problem descriptions. Since June 2022, Copilot has officially been available for free to all students as a plug-in to development environments like Visual Studio Code. Prior work exploring OpenAI Codex, the underlying model that powers Copilot, has shown it performs well on typical CS1 problems thus raising concerns about its potential impact on how introductory programming courses are taught. However, little is known about the types of problems for which Copilot does not perform well, or about the natural language interactions that a student might have with Copilot when resolving errors. We explore these questions by evaluating the performance of Copilot on a publicly available dataset of 166 programming problems. We find that it successfully solves around half of these problems on its very first attempt, and that it solves 60% of the remaining problems using only natural language changes to the problem description. We argue that this type of prompt engineering, which we believe will become a standard interaction between human and Copilot when it initially fails, is a potentially useful learning activity that promotes computational thinking skills, and is likely to change the nature of code writing skill development.

Despite instructors' best efforts in designing and delivering any given course, changes are likely required from time to time. This experience report presents the changes made in a second-year programming course for non-computing engineering majors over a decade's worth of effort, and the reasons behind those changes. The changes were often reactive--in response to student feedback. However, many other changes were inspired by the desire to trial new interventions in the hope of strengthening the students' positive experience. In addition to personnel and course content changes, the gradual evolvement included how labs, assignments, and activities were structured and executed. Teaching delivery evolved, along with a number of small-scale interventions that eventually became integral elements of the course. When COVID-19 demanded a sudden shift to online learning, the course was prepared to adapt quickly and successfully. The contributions here come in the form of lessons learned over the past decade: what worked, and what did not. We present the large range of changes---and their rationales--that are particularly relevant and applicable to programming courses targeting engineering students where the luxury of pedagogically-friendlier programming languages is not possible.

Qualitative research methodologies that collect data through interviews, focus groups and ethnographic studies, are valuable approaches to understand the educational experience. Participant drawings can be used as prompts to access implicit understandings and have been shown to contribute to effective data collection in related fields, but are not widely used in computing education research. We report on a case study in which sixteen New Zealand primary and secondary school digital technologies teachers were interviewed and asked to draw their ideal computing student. This case study illustrates how drawings can be used to enhance semi-structured interviews in the context of computing education. The contributions made here come in the form of a case study demonstrating the draw-a-person method in a computing education context, along with recommendations for researchers considering applying this method in their work.

A comprehensive understanding of computing has become a necessary skill for students in an increasingly digital world. Consequently, many countries around the world have updated their national pre-tertiary curriculum to include the topic of computing. However, the structure and presentation of these curricula varies greatly. This makes it difficult to compare the timing that students are exposed to computing and as a result, increases the difficulty for producing effective and well-timed educational resources that are relevant for varying implementations. This research investigates the structure of international computing curricula, identifying and comparing the timing that students are exposed to computing. This will better inform researchers and resource developers about where and when their interventions are most applicable. This will also provide valuable insights for the creation of future computing curricula, by informing curriculum designers about the perspectives of various curricula and the most common approaches they have taken.

Data structures and algorithms (DSA) are fundamental concepts introduced in the early stages of any undergraduate computing degree. Many students find DSA concepts challenging to learn, partly due to their abstract nature but also due to issues of low motivation. We examine these and other common difficulties faced by educators teaching DSA, and present a novel solution which combines a game-based learning approach with the use of engaging visualizations of algorithms in 2.5D. Game-based learning and algorithm visualizations are often employed in existing educational tools, but are rarely combined. Our game, DeCode, presents DSA concepts as in-game objects and animations within a 2.5D game-based world alongside traditional game-like mechanics such as progression. Feedback from an initial pilot study (n=51) suggests that students regard DeCode as an enjoyable and effective tool for learning DSA concepts. We also find evidence that DeCode's visualizations help students find efficient solutions to problems that have received prior attention in the literature, such as shifting all of the elements in an array.

High Performance Computing (HPC) is the ability to process data and perform complex calculations at extremely high speeds. Current HPC platforms can achieve calculations on the order of quadrillions of calculations per second with quintillions on the horizon. The past three decades witnessed a vast increase in the use of HPC across different scientific, engineering and business communities, for example, sequencing the genome, predicting climate changes, designing modern aerodynamics, or establishing customer preferences. Although HPC has been well incorporated into science curricula such as bioinformatics, the same cannot be said for most computing programs. This working group will explore how HPC can make inroads into computer science education, from the undergraduate to postgraduate levels. The group will address research questions designed to investigate topics such as identifying and handling barriers that inhibit the adoption of HPC in educational environments, how to incorporate HPC into various curricula, and how HPC can be leveraged to enhance applied critical thinking and problem solving skills. Four deliverables include: (1) a catalog of core HPC educational concepts, (2) HPC curricula for contemporary computing needs, such as in artificial intelligence, cyberanalytics, data science and engineering, or internet of things, (3) possible infrastructures for implementing HPC coursework, and (4) HPC-related feedback to the CC2020 project.

This paper reports on early stages of a machine learning research project, where phases of cognitive presence in MOOC discussions were manually coded in preparation for training automated cognitive classifiers. We present a manual-classification rubric combining Garrison, Anderson and Archer's [11] coding scheme with Park's [25] revised version for a target MOOC. The inter-rater reliability between two raters achieved 95.4% agreement with a Cohen's weighted kappa of 0.96, demonstrating our classification rubric is plausible for the target MOOC dataset. The classification rubric, originally intended for for-credit, undergraduate courses, can be applied to a MOOC context. We found that the main disagreements between two raters lay on adjacent cognitive phases, implying that additional categories may exist between cognitive phases in such MOOC discussion messages. Overall, our results suggest a reliable rubric for classifying cognitive phases in discussion messages of the target MOOC by two raters. This indicates we are in a position to apply machine learning algorithms which can also cater for data with inter-rater disagreements in future automated classification studies.

Summary OpenMP is a popular multiprocessing interface to parallelize different domains of applications. A previously proposed extension has made it possible for OpenMP to speedup event‐driven programs. There, a virtual target model extension is used to incrementally introduce asynchronous execution into an OpenMP program. At the same time it allows a mixture of nested parallelism with asynchronous processing. This new possibility raises the question how to use available processors/threads, for parallelism or for asynchronous execution? To investigate the best combination of asynchronization and parallelization, a performance model for measuring parallel event‐driven systems is proposed. Based on queue theory, the theoretical analysis discovers some interesting facts in an event‐driven system. Then, experiments are conducted to study the best practice of improving event‐driven programs and how to balance parallelism and asynchronous execution. By comparing it with the OpenMP tasking model, the evaluations demonstrate the effectiveness and flexibility of the virtual target model, which is able to achieve significantly better parallel event‐driven performance.

Summary Parallel computing techniques have been supported by programming languages in two major ways: either library‐based APIs or extended language constructs. Library‐based features are portable and offer fine‐grained control on parallelization details. However, they rely on individual programmer skills; thus, they may lead to inconsistent implementations and considerable code restructurings. On the contrary, language constructs promote environments that largely conceal the details of parallel programming techniques. However, they normally reduce programmer control over the granularity of parallelization and impose additional development concepts and compilation requirements that may sacrifice ease of use and portability. Therefore, approaches that balance between programmer control on parallelization details, intuitiveness of concepts, and portability can gain priority over other paradigms. In this paper, we discuss @PT (Annotation Parallel Task), a parallel computing framework that proposes Java annotations, standard Java components, as its language constructs. @PT takes an object‐oriented approach on efficient execution and management of asynchronous tasks, with a special focus on GUI‐responsive applications. This paper presents the annotation‐based programming interface of the framework and its fundamental parallelization concepts. Furthermore, it studies the usability and performance of @PT by comparisons with other Java parallelization approaches in a set of standard benchmarks. The observations suggest that @PT maintains a simple programming interface, whereas it performs efficiently in different parallel computing domains.

The sophisticated nature of parallel computing concepts makes parallel programming challenging. This has encouraged investigations for higher-level frameworks that conceal much of the complications behind abstraction layers. Paradigms in this category are mostly performance centric, and do not share the same sentiments for the robustness of asynchronous executions. This is while current applications demand consistency and soundness in addition to fast performance. Therefore, programming environments that offer high-level support for asynchronous exception handling will have higher chances for popularity. This paper discusses our latest enhancements to @PT, a parallel computing environment that is based on Java annotations. The proposed concept promotes the robustness of parallelized programs by adhering to the familiar exception handling standards of sequential codes, and reducing the asynchronous execution concerns in the API level. This study suggests that the concept simplifies efficient management of asynchronous exception handling concepts that appears to be challenging in parallel programming.

Design smells are design structures that indicate poor design quality. Many identified smells are difficult to teach as they require a degree of experience and judgement that novices, by definition, do not have. We have identified a design smell, which we call "unencapsulated collection", that is common in novice designs. It is simple to describe, allowing it to be objectively detected, and the refactoring steps needed to remove the smell are usually simple to illustrate. We give a description of the smell and present the results of an empirical study showing its prevalence. We outline the general steps for refactoring the smell, and illustrate it with a case study. The simplicity of this smell makes it a good candidate for teaching good design principles to novices.

Summary Task parallelism is an approach to parallel programming that has recently gained traction because of its compatibility with the predominant object‐oriented languages and its low overhead compared to threading approaches. Parallel Task is an Open Source task‐parallel compiler and runtime system for object‐oriented languages, in particular Java. It is very flexible and expressive, demonstrated by the fact that it can be directly employed to implement most parallel computing patterns. The only notable exception has been the pipeline pattern where many data items are streamed through a number of processing stages. This is not surprising, as task parallelism is generally not compatible with the pipeline pattern. In this paper, we investigate how the pipeline pattern can be elegantly and efficiently implemented in a task‐parallel environment. To do so, we extend Parallel Task with the concept of implicit futures to allow creating pipelines in an intuitive and object‐oriented manner. Our experimental evaluation uses the extended Parallel Task to implement pipelines of different lengths and characteristics and compares with manual implementations. The evaluation demonstrates very good performance and scalability of the proposed task‐parallel pipeline approach. Copyright © 2014 John Wiley & Sons, Ltd.

Directives based incremental parallelism is an uncomplicated and expressive parallelisation practice and has led to wide adoption of OpenMP. However, the OpenMP specification does not present a binding for the Java language and the OpenMP threading model finds limited use for GUI (Graphical User Interface) application development. This paper focuses on the study of a semantic interpretation of OpenMP in the context of an object orientated environment. It proposes novel concepts to extend OpenMP for applications with a Graphical User Interface (GUI), based on the distinction between parallelism and concurrency. We present a compiler-runtime system for OpenMP-like directives in Java, enhanced with GUI related constructs. Acknowledging the productivity gains of the incremental parallelism approach of OpenMP, the GUI related constructs enable the developer to incrementally introduce concurrency. We present and discuss the performance of programs written using our system by comparing them with previous attempts and traditional ways of parallelisation-concurrency, using the parallel Java Grande Forum (JGF) benchmarks and a set of GUI applications.

With the advent of multi-core processors, desktop application developers must finally face parallel computing and its challenges. A large portion of the computational load in a program rests within iterative computations. In object-oriented languages these are commonly handled using iterators which are inadequate for parallel programming. Consequently, the powerful Parallel Iterator concept was developed. This paper presents various developments of the Parallel Iterator, such as parallel traversal of complex collections with partial ordering (such as a tree). Other features include reductions, parallel remove semantics and exception handling. Along with the ease of use, the results reveal great speedup in comparison to traditional Java parallelism approaches.

The need to parallelise desktop applications is becoming increasingly essential with the mainstream adoption of multi-cores. In object-oriented languages, sequential iterators handle iterative computations of a sequential program; similarly, the parallel iterator was developed to handle the iterative computations of a parallel program. This paper presents the progress of the parallel iterator concept. New features, such as support for reductions and global break semantics, allow the parallel iterator to undertake more situations. With a slight contract modification, the parallel iterator interface now imitates that of the sequential iterator. All these features combine together to promote minimal, if any, code restructuring. The reduction frequently outperforms related work and the importance of providing simple and flexible fine-tuning capability is affirmed.