Novice Developers Research Articles

Enhancing Novice Developer Efficacy through UX Journey: Integrating User Experience and User Requirement to Develop Developer Skills

User experience and user requirements are two different approaches to software development. User requirements focus on meeting customer expectations and demands for software solutions, while user experience covers all aspects of software interaction with users. To increase the value of the software, the software must have usable and easy-to-use features with an attractive design or work environment that fits the user's behavior. Integrating software requirements and user experience can increase developer productivity by focusing on features that meet user requirements and expectations. This integration can also increase software development efficiency by addressing issues arising during development. This article addresses developers' challenges when addressing user needs and provides practical solutions widely accepted in industry and academia. Combining user experience and user needs into the UX Journey approach can increase developer productivity and confidence in software development. The design of the UX Journey is carried out by evaluating several existing design solution methods such as Design Thinking, IDEO, HPI, and Double Diamond to determine the existing conditions and needs for the problems faced. Then, by mapping the user, context, and domain, the model is obtained. appropriate. The proposed model comprises Discover, Explore, Test, and Listen activities. A trial was carried out on the respondents to test the method, and a feasibility test and an implementation schedule were obtained based on the statistical analysis of the initial user. It took 980-1500 minutes to complete the design solution. Focusing on features that align with user needs and improve problem-solving efficiency throughout development gives developers greater confidence in producing high-quality software.

Holistic personas to increase the novice developer productivity

A deeper understanding and integration with system users' thoughts and emotional experiences are required for user-engaged development. User experience (UX) journey integrates user requirements and problem-solving approaches. The integration of data-driven techniques and user-centric approaches in software development is investigated in this study. It focuses on using the Markov chain model to predict developer productivity based on data gathered while creating personas across three projects. Organizations can gain valuable insights into user needs and requirements by conducting purposeful activities such as strength, weaknesses, opportunities, and threats (SWOT) analysis, competitor analysis, hypothesis formulation, identification of behavioral variables, mapping interviews, and defining characteristics and objectives. The model has predictive capabilities that allow for more informed decision-making, more efficient resource allocation, and better project planning. The goal of the activity and the model ensure the development of software products that effectively meet the needs of users, resulting in a higher success rate for software development initiatives. This study emphasizes the importance of integrating quantitative and qualitative analysis to drive successful software development projects and increase productivity while meeting user needs. According to the findings of the research conducted from the three projects completed, the proposed methods have similarities, and predictions using the Markov chain can determine the success of novice developers.

Exploring Student Perceptions of Technological Pedagogical Content Knowledge (TPACK) in Translation Courses

Technological Pedagogical Content Knowledge (TPACK) is regarded as one of the most significant models for showcasing students' perceptions in translation courses. This study was undertaken to investigate the perceptions of both novice and experienced translation students from institute Pendidikan dan Bahasa Invada regarding the utilization of technological pedagogical content knowledge in professional development teaching. In pursuit of the study's three objectives, the mixmethod method was utilized by the two authors due to its appropriateness. Data gathering involved distributing a 20-item questionnaire to a purposive sample comprising 75 novice and experienced and female translation students chosen from institute Pendidikan dan Bahasa Invada during 2021/2022. Additionally, a significant proportion of the instructors demonstrated an average level of knowledge regarding TPACK. Their perceptions towards TPACK were notably positive. Moreover, the study's results highlighted the substantial role of educational backgrounds in digital technologies in the professional development of novice and experienced translation instructors at IPB Cirebon. The study's implications were deliberated upon, with recommendations proposed to equip all institution in cirebon with educational software, e-learning platforms, teaching software, and to provide novice and experienced translation students’ with sessions on new digital skills, cybersecurity workshops, and innovative digital skills training.

Elevated Novice Developer Productivity and Self-efficacy by Promoting UX Journey in Software Requirement Elicitation

This study explores the effectiveness of the UX Journey methodology in increasing developer productivity and self-efficacy. Materials: The UX journey, consisting of around 30 activities, offers a user-centric approach to developing solutions, with 86 volunteer respondents from 505 populations. Method: Through a comparative analysis of developer productivity metrics and the General Self-Efficacy Scale questionnaire, this study investigates the impact of UX Journey on self-efficacy before and after implementation. Results: The study's findings reveal a significant positive correlation between UX Journey and increased productivity and an association between self-efficacy variables. By incorporating a comprehensive set of activities and a user-centric approach, the UX Journey enables developers to navigate the design process efficiently while gaining a deeper understanding of user needs. The positive correlation between the UX Journey and increased productivity, as well as the relationships between self-efficacy variables, emphasize the value of this methodology in fostering practical design thinking. Implication for Further Research: While this study has limitations regarding sample size and contextual specificity, it provides valuable insight into the benefits of UX Journey and paves the way for further research. In addition, the study focused on specific design projects within a particular context, which might restrict the broader applicability of the results. Significant results indicate that the proposed method is as effective as the elicitation method in general, with the advantage that the developer can understand the needs and empathy of the users. UX journeys can enhance the design process and foster a deeper understanding of users' needs across multiple domains.

End-to-End Dataset Collection System for Sport Activities

Datasets are key to developing new machine learning-based applications but are very costly to prepare, which hinders research and development in the field. We propose an edge-to-cloud end-to-end system architecture optimized for sport activity recognition dataset collection and application deployment. Tests in authentic contexts of use in four different sports have revealed the system’s ability to effectively collect machine learning-usable data, with an energy consumption compatible with the timeframe of most of the sport types. The proposed architecture relies on a key feature of the Measurify internet of things framework for the management of measurement data (i.e., .csv dataset management) and supports a workflow designed for efficient data labeling of signal timeseries. The architecture is independent of any specific sport, and a new dataset generation application can be set up in a few days, even by novice developers. With a view to concretely supporting the R&D community, our work is released open-source.

Perceptions of Novice and Experienced Instructors of Translation at Selected Saudi Universities Toward Technological Pedagogical Content Knowledge for Teaching Professional Development

Technological Pedagogical Content Knowledge (TPACK) is considered one of the most significant models for presenting teachers’ capabilities and proficiencies in effectively using technology to teach. This study was conducted to explore the perceptions of both novice and experienced instructors of translation from selected Saudi universities toward the use of technological pedagogical content knowledge in teaching professional development. To achieve the three objectives of the study, the two authors employed the descriptive survey method because of its suitability. For gathering data, a 20-item questionnaire was distributed to a purposive sample containing 100 novice and experienced male and female instructors of translation who were randomly selected from some several universities in Saudi Arabia during the first semester of 2023. The findings of this study revealed very many that of the selected translation instructors had positive attitudes toward the use of technological applications for teaching English as a foreign language (EFL). Moreover, many of the selected translation instructors showed that they had an average level of knowledge regarding TPACK. The findings also revealed that the selected instructors’ perceptions toward TPACK were considerable. Furthermore, the results of the study also proved that educational background in digital technologies plays a significant role in the professional development of novice and experienced translation instructors at Saudi universities. The implications of the study’s results were discussed, and recommendations were suggested for providing all universities in Saudi Arabia with educational software, e-learning platform, teaching software and novice and experienced instructors of translation with new digital skills session, cybersecurity workshop and innovative digital skills training.

Access to struct members and undefined behavior of C code

During software development, novice developers usually receive a lot of error messages and just warnings of various kinds. And if the code simply won't run when there are errors, then the program usually starts when there are various warnings. And here it is important to understand what consequences the presence of warnings of various kinds can lead to. This work aims to study the code's undefined behavior when working with struc-tures in the C programming language when issuing a corresponding compiler warn-ing about returning the address of a local or temporary variable. In the procedural programming language C, there is an ancestor of the OOP class — the structure struct, which encapsulates only the state of the entity. And the question arises — is it possible to work with separate components-fields of such a structure analogously to OOP languages? For research, a simple structure was taken, which contains information about the person's name, surname, and phone number. To access parts of the structure, pseudogetters were used — functions that returned a pointer to the corresponding part of the structure. The research was conducted in the Visual Studio 2019 environment under the control of the Windows 10 operating system when the default C language standard - MSVC and the more modern ISO standard C17 (2018) was selected in the project settings. As a result, a truly undefined behavior of the code was obtained, when the re-sult of the work of the code fragment (function call) depends on many factors: the length of the array, the standard of the C language, the position of a certain part in the structure. An attempt to conduct similar research under the control of the Linux Mint oper-ating system using the gcc compiler version 5.4 was unsuccessful. When compiling the code, a similar warning about returning the address of a local variable was also issued, as in the case of Visual Studio. But when the program was launched, it sim-ply crashed with a message about a segmentation error. Thus, both the Visual Studio 2019 compiler and the gcc compiler warned us about undefined code behavior. But this uncertain behavior was radically different for operating systems and compilers. If after gcc under the Linux OS, the code simply does not work at all and the program stops its work with a segmentation error mes-sage, then after Visual Studio under Windows, inexperienced developers with im-proper testing and verification of the code can miss the code that "does not always work", which can lead to unexpected results, not always pleasant, to say the least. And that's why software developers, especially beginners, should pay attention not only to compilation errors but also to warnings, even if the code works.

A case study on researcher identity development of novice and experienced teacher educators: A different or similar research journey?

This qualitative study aims to investigate the researcher identity development of novice and experienced researchers. In the study, which adopted the case study, one of the qualitative research designs, the maximum diversity and criterion sampling methods were used. Data were collected through interviews with seven novice and five experienced teacher educators. Data were analyzed by content analysis through MAXQDA software. Results showed that experienced and novice teacher educators shared similar views while depicting research and revealing the influential factors in developing researcher identity. It was found that researcher identity was developed through the interaction of three main components: academic, social, and individual factors. While individual factors were at the core of a researcher identity development process, academic and social factors influenced researcher identity through three phases: exploration, engagement, and continuous development. For each phase, there were academic and social factors that had a prevalent influence on researcher identity construction.

Live software documentation of design pattern instances.

Approaches to documenting the software patterns of a system can support intentionally and manually documenting them or automatically extracting them from the source code. Some of the approaches that we review do not maintain proximity between code and documentation. Others do not update the documentation after the code is changed. All of them present a low level of liveness. This work proposes an approach to improve the understandability of a software system by documenting the design patterns it uses. We regard the creation and the documentation of software as part of the same process and attempt to streamline the two activities. We achieve this by increasing the feedback about the pattern instances present in the code, during development-i.e., by increasing liveness. Moreover, our approach maintains proximity between code and documentation and allows us to visualize the pattern instances under the same environment. We developed a prototype-DesignPatternDoc-for IntelliJ IDEA that continuously identifies pattern instances in the code, suggests them to the developer, generates the respective pattern-instance documentation, and enables live editing and visualization of that documentation. To evaluate this approach, we conducted a controlled experiment with 21 novice developers. We asked participants to complete three tasks that involved understanding and evolving small software systems-up to six classes and 100 lines of code-and recorded the duration and the number of context switches. The results show that our approach helps developers spend less time understanding and documenting a software system when compared to using tools with a lower degree of liveness. Additionally, embedding documentation in the IDE and maintaining it close to the source code reduces context switching significantly.

Productivity and Quality Challenges of Novice Developers in Agile Engineering Environments - A Comparative Study

The Agile methodology has significantly transformed the landscape of software development, offering a dynamic approach that prioritizes adaptability and customer feedback. This paper harnesses insights from the authoritative State of Agile report, an annual publication produced by CollabNet and Digital.ai. Findings of six financial years (2015-2021) reveal the current positioning of the software development community in terms of agile adoption and the prevalent trends. This finding was elaborated with a micro survey, conducted targeting various agile roles within software development companies focusing on novice developers. An in-depth exploration offers a granular view, underscoring the reasons behind the significance pinpointed in the State of Agile reports. Overall, this research provides a comprehensive understanding of Agile's impact, its evolving trends, and its implications for diverse software development teams.

OCTSharp: an open-source and real-time OCT imaging software based on C.

Optical coherence tomography (OCT) demands massive data processing and real-time displaying during high-speed imaging. Current OCT imaging software is predominantly based on C++, aiming to maximize performance through low-level hardware management. However, the steep learning curve of C++ hinders agile prototyping, particularly for research purposes. Moreover, manual memory management poses challenges for novice developers and may lead to potential security issues. To address these limitations, OCTSharp is developed as an open-source OCT software based on the memory-safe language C#. Within the managed C# environment, OCTSharp offers synchronized hardware control, minimal memory management, and GPU-based parallel processing. The software has been thoroughly tested and proven capable of supporting real-time image acquisition, processing, and visualization with spectral-domain OCT systems equipped with the latest advanced hardware. With these enhancements, OCTSharp is positioned to serve as an open-source platform tailored for various applications.

Semantic-Enriched Code Knowledge Graph to Reveal Unknowns in Smart Contract Code Reuse

Programmers who work with smart contract development often encounter challenges in reusing code from repositories. This is due to the presence of two unknowns that can lead to non-functional and functional failures. These unknowns are implicit collaborations between functions and subtle differences among similar functions. Current code mining methods can extract syntax and semantic knowledge (known knowledge), but they cannot uncover these unknowns due to a significant gap between the known and the unknown. To address this issue, we formulate knowledge acquisition as a knowledge deduction task and propose an analytic flow that uses the function clone as a bridge to gradually deduce the known knowledge into the problem-solving knowledge that can reveal the unknowns. This flow comprises five methods: clone detection, co-occurrence probability calculation, function usage frequency accumulation, description propagation, and control flow graph annotation. This provides a systematic and coherent approach to knowledge deduction. We then structure all of the knowledge into a semantic-enriched code Knowledge Graph (KG) and integrate this KG into two software engineering tasks: code recommendation and crowd-scaled coding practice checking. As a proof of concept, we apply our approach to 5,140 smart contract files available on Etherscan.io and confirm high accuracy of our KG construction steps. In our experiments, our code KG effectively improved code recommendation accuracy by 6% to 45%, increased diversity by 61% to 102%, and enhanced NDCG by 1% to 21%. Furthermore, compared to traditional analysis tools and the debugging-with-the-crowd method, our KG improved time efficiency by 30 to 380 seconds, vulnerability determination accuracy by 20% to 33%, and vulnerability fixing accuracy by 24% to 40% for novice developers who identified and fixed vulnerable smart contract functions.

GitHub Copilot AI pair programmer: Asset or Liability?

Automatic program synthesis is a long-lasting dream in software engineering. Recently, a promising Deep Learning (DL) based solution, called Copilot, has been proposed by OpenAI and Microsoft as an industrial product. Although some studies evaluate the correctness of Copilot solutions and report its issues, more empirical evaluations are necessary to understand how developers can benefit from it effectively. In this paper, we study the capabilities of Copilot in two different programming tasks: (i) generating (and reproducing) correct and efficient solutions for fundamental algorithmic problems, and (ii) comparing Copilot’s proposed solutions with those of human programmers on a set of programming tasks. For the former, we assess the performance and functionality of Copilot in solving selected fundamental problems in computer science, like sorting and implementing data structures. In the latter, a dataset of programming problems with human-provided solutions is used. The results show that Copilot is capable of providing solutions for almost all fundamental algorithmic problems, however, some solutions are buggy and non-reproducible. Moreover, Copilot has some difficulties in combining multiple methods to generate a solution. Comparing Copilot to humans, our results show that the correct ratio of humans’ solutions is greater than Copilot’s suggestions, while the buggy solutions generated by Copilot require less effort to be repaired. Based on our findings, if Copilot is used by expert developers in software projects, it can become an asset since its suggestions could be comparable to humans’ contributions in terms of quality. However, Copilot can become a liability if it is used by novice developers who may fail to filter its buggy or non-optimal solutions due to a lack of expertise.

SmartCLIDE design pattern assistant: A decision‐tree based approach

AbstractDesign patterns are well‐known solutions to recurring design problems that are widely adopted in the software industry, either as formal means of communication or as a way to improve structural quality, enabling proper software extension. However, the adoption and correct instantiation of patterns is not a trivial task and requires substantial design experience. Some patterns are conceptually close or present similar design alternatives, leading novice developers to improper pattern selection, thereby reducing maintainability. Additionally, the mis‐instantiation of a GoF (Gang‐of‐Four) design pattern, leads to phenomena such as pattern grime or architecture decay. To alleviate this problem, in this work we propose an approach that can help software engineers to more easily and safely select the proper design pattern, for a given design problem. The approach relies on decision trees, which are constructed using domain knowledge, while options are conveyed to software engineers through an Eclipse Theia plugin. To assess the usefulness and the perceived benefits of the approach, as well as the usability of the tool support, we have conducted an industrial validation study, using various data collection methods, such as questionnaires, focus groups, and task analysis. The results of the study suggest that the proposed approach is promising, since it increases the probability of the proper pattern being selected, and various useful future work suggestions have been obtained by the practitioners.

Investigating Novice Developers’ Code Commenting Trends Using Machine Learning Techniques

Code comments are considered an efficient way to document the functionality of a particular block of code. Code commenting is a common practice among developers to explain the purpose of the code in order to improve code comprehension and readability. Researchers investigated the effect of code comments on software development tasks and demonstrated the use of comments in several ways, including maintenance, reusability, bug detection, etc. Given the importance of code comments, it becomes vital for novice developers to brush up on their code commenting skills. In this study, we initially investigated what types of comments novice students document in their source code and further categorized those comments using a machine learning approach. The work involves the initial manual classification of code comments and then building a machine learning model to classify student code comments automatically. The findings of our study revealed that novice developers/students’ comments are mainly related to Literal (26.66%) and Insufficient (26.66%). Further, we proposed and extended the taxonomy of such source code comments by adding a few more categories, i.e., License (5.18%), Profile (4.80%), Irrelevant (4.80%), Commented Code (4.44%), Autogenerated (1.48%), and Improper (1.10%). Moreover, we assessed our approach with three different machine-learning classifiers. Our implementation of machine learning models found that Decision Tree resulted in the overall highest accuracy, i.e., 85%. This study helps in predicting the type of code comments for a novice developer using a machine learning approach that can be implemented to generate automated feedback for students, thus saving teachers time for manual one-on-one feedback, which is a time-consuming activity.

End-user development for interactive web-based virtual reality scenes

Recent advances in Virtual Reality (VR) technology and the increased availability of VR-equipped devices enable a wide range of consumer-oriented applications. For novice developers, however, creating interactive scenes for VR applications is a complex and cumbersome task that requires high technical knowledge which is often missing. This hinders the potential of enabling novices to create, modify, and execute their own interactive VR scenes. Although recent authoring tools for interactive VR scenes are promising, most of them focus on experts as the target group and neglect the novices with low programming knowledge. To lower the entry barrier, we provide an open-source web-based End-User Development (EUD) tool, called VREUD, that supports the rapid construction and execution of interactive VR scenes. To address the aspect of construction, VREUD enables the specification of the VR scene including interactions and tasks. Furthermore, our tool supports the execution and immersive experience of the created interactive VR scenes on VR head-mounted displays. Based on a user study, we have analyzed the effectiveness, efficiency, and user satisfaction of VREUD which shows promising results to empower novices in creating their interactive VR scenes.

Visual notations in container orchestrations: an empirical study with Docker Compose

Container orchestration tools supporting infrastructure-as-code allow new forms of collaboration between developers and operatives. Still, their text-based nature permits naive mistakes and is more difficult to read as complexity increases. We can find few examples of low-code approaches for defining the orchestration of containers, and there seems to be a lack of empirical studies showing the benefits and limitations of such approaches. We hypothesize that a complete visual notation for Docker-based orchestrations could reduce the effort, the error rate, and the development time. Therefore, we developed a tool featuring such a visual notation for Docker Compose configurations, and we empirically evaluated it in a controlled experiment with novice developers. The results show a significant reduction in development time and error-proneness when defining Docker Compose files, supporting our hypothesis. The participants also thought the prototype easier to use and useful, and wanted to use it in the future.

Newcomer OSS-Candidates: Characterizing Contributions of Novice Developers to GitHub

The ability of an Open Source Software (OSS) project to attract, onboard, and retain any newcomer is vital to its livelihood. Although, evidence suggests an upsurge in novice developers joining social coding platforms (such as GitHub), the extent to which their activities result in a OSS contribution is unknown. Henceforth, we execute the protocols of a registered report to study activities of a “Newcomer OSS-Candidate”, who is a novice developer that is new to that social coding platform, and has the intention to later onboard an OSS project. Using GitHub as a case platform, we analyze 171 identified Newcomer OSS-Candidates to characterize their contribution activities. Results show that Newcomer OSS-Candidates are likely to target software based repositories (i.e., 66%), and their first contributions are mainly associated with development (commits) and maintenance (PRs). Newcomer OSS-Candidates are less likely to practice social coding, but eventually end up onboarding (i.e., 30% quantitative, 70% follow-up survey) an OSS project. Furthermore, they cite finding a way to start as the most challenging barrier to contribute. Our work reveals insights on how newcomers to social coding platforms are potential sources of OSS contributions.

Helping novice developers harness security issues in cloud-IoT systems

The development of cloud-connected Internet of Things (IoT) systems is becoming more and more affordable, even to novice programmers, thanks to dedicated cloud platforms that already integrate the core functionality needed by an IoT system. In this context, a growing number of IoT systems are being developed and deployed on open networks, often without integrating adequate security in the process. Novice IoT programmers, in particular, tend to overlook security issues, as confirmed by a small user study. Starting from this risk, the paper analyzes the security features available in two major cloud-IoT platforms (Amazon Web Services and Microsoft Azure) and highlights those settings, tools, and practices designed to ensure more secure implementations. We observed that these platforms would reasonably address many security problems detected in the study, if only the correct features were identified and used. The paper finally contributes a set of guidelines to support novice IoT developers in avoiding the main and recurrent security issues in their projects and better exploiting cloud-IoT platforms’ inherent security features.

SECRS TEMPLATE TO AID NOVICE DEVELOPERS IN SECURITY REQUIREMENTS IDENTIFICATION AND DOCUMENTATION

The security requirements are one of the non-functional requirements (NFR) which acts as a constraint on the functions of the system to be built. Security requirements are important and may affect the entire quality of the system. Unfortunately, many organizations do not pay much attention to it. The security problems should be focused on the early phases of the development process i.e. in the requirements phase to stop the problems spreading down in the later phases and in turn to avoid the rework. Subsequently, when security requirements are to be focused, proper guidance should be provided which should assist requirements engineers. Many security requirements engineering methods were developed in the past which require different level of expertise such as SQUARE process which requires requirements engineer to have a certain level of security expertise. Moreover, it lacks proper guidance especially for novice developers in applying the existing security requirements engineering (SecRE) methods to identify security requirements. Hence, this study intends to address the gap by developing a guided template to assist novice developers in the security requirements identification and documentation. The main objectives of the research are: 1) to study and investigate the existing security requirements engineering (SecRE) methods. 2) To develop a template to aid novice developers in identifying and documenting security requirements. The developed template is applied to two case studies of software projects to determine its usability and applicability. The results of the case studies evaluation show that both the usability and applicability of the template is good. The template is also evaluated by several experts and software practitioners. The evaluation results show that the SecRS template is found to be satisfying the usability and applicability factors; thereby confirming that the proposed template achieves its desired objective of aiding the novice developers to identify and document security requirements correctly.