Search

Technology has changed the way we work. These have increased the productivity in the workplace. The purpose of having a conference paper app is to aid researcher to improve the effectiveness and efficiency of management of conference paper. Without a proper management of these substances, people might suffer from the inconvenience by using a desktop system to complete certain tasks and monitor them efficiently. However, based on investigating the existing applications, a few shortcomings have been identified. Certain shortcoming leads us to develop a new mobile application to fix the identified shortcomings. Some others include complex navigation of user interfaces, this cause a poor user experience for users. Hence, this project proposes a development of a mobile application that is called CPMA, which serve as a better alternative tool to allow users managing and monitoring information related to conference paper in a more efficient way. This app specifically developed for researchers in higher learning institutions who are needed to proceed with conference paper. Software development methodology named prototyping will be adopted, which consisted of phases such as planning, repeated phases (analysis, design, implementation and system prototype), implementation and final system. The essential significance of this project is to provide a platform for researcher to manage and monitor conference paper in a savvy manner. By the time of completing this project, users are expected to access this application without any costs and increase the efficiency and effectiveness of managing conference paper. To ensure the security is presented in a tabular form for each online marketplace. [ABSTRACT FROM AUTHOR]

Is it really better to print everything, including software models, or is it better to view them on screen? With the ever increasing complexity of software systems, software modeling is integral to software development. Software models facilitate and automate many activities during development, such as code and test case generation. However, a core goal of software modeling is to communicate and collaborate. Software models are presented to team members on many mediums and two of the most common mediums are paper and computer screens. Reading from paper or screen is ostensibly considered to have the same effect on model comprehension. However, the literature on text reading has indicated that the reading experiences can be very different which in turn effects various metrics related to reader performance. This paper reports on an experiment that was conducted to investigate the effect of reading software models on paper in comparison with reading them on a computer screen with respect to cognitive effectiveness. Cognitive effectiveness here refers to the ease by which a model reader can read a model. The experiment used a total of 74 software engineering students as subjects. The experiment results provide strong evidence that displaying diagrams on a screen allows subjects to read them quicker. There is also evidence that indicates that on screen viewing induces fewer reading errors. [ABSTRACT FROM AUTHOR]

Today's software industry is global, virtual, and depending more than ever on strong and reliable processes. Stakeholders and infrastructure are distributed across the globe, posing challenges that go beyond those with co‐located teams and servers. Software Engineering continues to be a complex undertaking, with projects challenged to meet expectations, especially regarding costs. We know that Software Engineering is an ever‐changing discipline, with the result that firms and their employees must regularly embrace new methods, tools, technologies, and processes. In 2020, the International Conference on Global Software Engineering (ICGSE) and the International Conference on Systems and Software Processes (ICSSP) joined forces aiming to create a holistic understanding of the software landscape both from the perspective of human and infrastructure distribution and also the processes to support software development. Unfortunately, these challenges have become even more personal to many more in 2020 due to the disruption introduced by the COVID‐19 pandemic, which forced both conferences to be held virtually. As an outcome of the joint event, we selected a set of the best papers from the two conferences, which were invited to submit extended versions to this Special Issue in the Journal of Software: Maintenance and Evolution. Dedicated committees were established to identify the best papers. Eight papers were invited and ultimately, seven of these invited papers have made it into this Special Issue. [ABSTRACT FROM AUTHOR]

Over and above technical skills, software development graduates need to also poses team-based skills, such as, leadership, oral communication and project management by the time they graduate from tertiary institutions. In order to fulfil this requirement, institutions introduced a project-based module, generally referred to as capstone, to be undertaken by students on the their final year. The essence of this module, amongst other things, is to expose students to the real-world professional experience through partnership with industry. Much research has been conducted on students software projects, but very little investigation has gone into understanding how students evaluate the success of their projects. In is in this light that this study was conducted. A systematic literature review (SLR) was performed on empirical studies published between 2000 and 2022, to establish criteria used by students in evaluating software project success. The investigation led to the discovery of one (1) paper, which identified three most important success criteria used by students. However, this study identified some short-comings (eg students had to pretend to be employed graduates when evaluating the imaginary projects) with the approach used by the abovementioned research paper in determining the students' success criteria. Beside the fact that there is only one study that was found that addresses the study's phenomenon, the identified short-comings on the paper indicate that there is a need for empirical research studies on this matter. [ABSTRACT FROM AUTHOR]

The classification of the IEC-62304 considers the risks of failure due to the software, and ranges from "failure of the software does not contribute to a dangerous situation" (class A) to "failure of the software results in death or serious injury" (class C). Using off-the-shelf software One may wonder whether it's allowed to incorporate tools or off-the-shelf software in your in-house developed software product. Keywords: in vitro diagnostics regulation (IVDR); medical device software; quality management; software development EN in vitro diagnostics regulation (IVDR) medical device software quality management software development 982 988 7 05/26/22 20220601 NES 220601 Introduction The right treatment starts with the right diagnosis. IVDR software can often be seen as software that will drive or inform clinical management, i.e. the results from the software are used to diagnose a patient or to provide information about which treatment to start. [Extracted from the article]

This article examines the role of technology firms in computerizing psychological tests from the 1960s to 1980s. It focuses on National Computer Systems (NCS)'s development of computer software to interpret the Minnesota Multiphasic Personality Inventory. NCS trumpeted their computerized interpretation as a way to free up clerical labor and mitigate human bias, even as psychologists cautioned that proprietary algorithms risked obscuring decision rules. Clinics, courtrooms, and businesses all had competing interests in the use of computerized personality tests. I argue that test developers promoted computerized psychological tests as technical fixes for bias, even as courts and psychologists pointed to the complex layers of technological and social mediation embedded in software programs for psychological tests. This article contributes to histories of computing emphasizing the importance of intellectual property law in software development; to the relationship between labor, technology, and expertise; and to scholarship on the history and politics of algorithms. [ABSTRACT FROM AUTHOR]

Software development effort and cost estimation (SDECE) is one of the most important tasks in the field of software engineering. A large number of research papers have been published on this topic in the last five decades. Investigating research trends using a systematic literature review when such a large number of research papers are published is a very tedious and time-consuming task. Therefore, in this research paper, we propose a generic automated text mining framework to investigate research trends by analyzing the title, author's keywords, and abstract of the research papers. The proposed framework is used to investigate research trends by analyzing the title, keywords, and abstract of select 1015 research papers published on SDECE in the last five decades. We have identified the most popular SDECE techniques in each decade to understand how SDECE has evolved in the past five decades. It is found that artificial neural network, fuzzy logic, regression, analogy-based approach, and COCOMO methods are the most used techniques for SDECE followed by optimization, use case point, machine learning, and function point analysis. The NASA and ISBSG are the most used dataset for SDECE. The MMRE, MRE, and PRED are the most used accuracy measures for SDECE. Results of the proposed framework are validated by comparing it with the outcome of the previously published review work and we found that the results are consistent. We have also carried out a detailed bibliometric analysis and metareview of the review and survey papers published on SDECE. This research study is significant for the development of new models for cost and effort estimations. [ABSTRACT FROM AUTHOR]

The goal of the testing process is to find errors and defects in the software being developed so that they can be fixed and corrected before they are delivered to the customer. Regression testing is an essential quality testing technique during the maintenance phase of the program as it is performed to ensure the integrity of the program after modifications have been made. With the development of the software, the test suite becomes too large to be fully implemented within the given test cost in terms of budget and time. Therefore, the cost of regression testing using different techniques should be reduced, here we dealt many methods such as retest all technique, regression test selection technique (RTS) and test case prioritization technique (TCP). The efficiency of these techniques is evaluated through the use of many metrics such as average percentage of fault detected (APFD), average percentage block coverage (APBC) and average percentage decision coverage (APDC). In this paper we dealt with these different techniques used in test case selection and test case prioritization and the metrics used to evaluate their efficiency by using different techniques of artificial intelligent and describe the best of all. [ABSTRACT FROM AUTHOR]

Recently, many open-source products have been used under the situations of general software development, because the cost saving and standardization. Therefore, many open-source products are gathering attention from many software development companies. Then, the reliability/quality of open-source products becomes very important factor for the software development. This paper focuses on the reliability/quality evaluation of open-source products. In particular, the large quantity fault data sets recorded on Bugzilla of open-source products is used in many open-source development projects. Then, the large amount of data sets of software faults is recorded on the Bugzilla. This paper proposes the reliability/quality evaluation approach based on the deep machine learning by using the large quantity fault data on the Bugzilla. Moreover, the large quantity fault data sets are analyzed by the deep machine learning based on the fine-tuning. [ABSTRACT FROM AUTHOR]

Software testing is an important and cost intensive activity in software development. The major contribution in cost is due to test case generations. Requirement-based testing is an approach in which test cases are derivative from requirements without considering the implementation's internal structure. Requirement-based testing includes functional and nonfunctional requirements. The objective of this study is to explore the approaches that generate test cases from requirements. A systematic literature review based on two research questions and extensive quality assessment criteria includes studies. The study identifies 30 primary studies from 410 studies spanned from 2000 to 2018. The review's finding shows that 53% of journal papers, 42% of conference papers, and 5% of book chapters' address requirements-based testing. Most of the studies use UML, activity, and use case diagrams for test case generation from requirements. One of the significant lessons learned is that most software testing errors are traced back to errors in natural language requirements. A substantial amount of work focuses on UML diagrams for test case generations, which cannot capture all the system's developed attributes. Furthermore, there is a lack of UML-based models that can generate test cases from natural language requirements by refining them in context. Coverage criteria indicate how efficiently the testing has been performed 12.37% of studies use requirements coverage, 20% of studies cover path coverage, and 17% study basic coverage. [ABSTRACT FROM AUTHOR]

Technical debt is a concept used to describe the lack of good practices during software development, leading to several problems and costs. Identification and management strategies can help reduce these difficulties. In a previous study, Alves et al. (2016) analyzed the research landscape of such strategies from 2010 to 2014. This paper replicates and updates their study to explore the evolution of technical debt identification and management research landscape over a decade, including literature from 2010 until 2022. We analyzed 117 papers from the ACM Digital Library, IEEE Xplore, Science Direct, and Springer Link. Newly suggested strategies include automatically identifying admitted debt in comments, commits, and source code. Between 2015 and 2022, more empirical evaluations have been performed, and the general research focus has changed to a more holistic approach. Therefore, the research area evolved and reached a new level of maturity compared to previous results from Alves et al. (2016). Not only are code aspects considered for technical debt, but other aspects have also been investigated (e.g., models for the development process). [ABSTRACT FROM AUTHOR]

Code smells violate software development principles that make the software more prone to errors and changes. Researchers have developed code smell detectors using manual and semi-automatic methods to identify these issues. However, three key challenges have limited the practical use of these detectors: developers' subjective perceptions of code smells, lack of consensus in the detection process, and difficulty in setting appropriate detection thresholds. While code smell detection using machine learning has progressed significantly, there still appears to be a gap in understanding the effective utilization of deep learning (DL) approaches. This paper aims to review and identify current methods for code smell detection using DL techniques. A systematic literature review is conducted on 35 primary studies from a collection of 8739 publications between 2013 and the present. The analysis reveals that common code smells detected include Feature Envy, God Classes, Long Methods, Complex Classes, and Large Classes. The most popular DL algorithms used are Recurrent Neural Networks (RNN) and Convolutional Neural Networks (CNN), often combined with other techniques for better results. Algorithms that train models on large datasets with fewer independent variables demonstrate exemplary performance. The paper also highlights open issues and provides guidelines for future metric identification and selection research. [ABSTRACT FROM AUTHOR]

Augmented reality (AR) technology enables paper maps to dynamically express three-dimensional geographic information, realizing the fusion of virtual and real information. However, in the current mainstream AR development software, the virtual information usually consists of prefabricated components (prefabs), and the content creation for AR maps heavily relies on manual prefabrication. It leads to repetitive and error-prone prefabrication work, which restricts the design of the dynamic, interactive functions of AR maps. To solve this problem, this paper explored the possibility of automatically generating AR map prefabs using object detection models to establish a data conversion interface from paper maps to AR maps. First, we compared and analyzed various object detection models and selected YOLOv8x to recognize map point symbols. Then, we proposed a method to automatically generate AR map prefabs based on the predicted bounding boxes of the object detection model, which could generate prefabs with corresponding categories and positional information. Finally, we developed an AR map prototype system based on Android mobile devices. We designed an interaction method for information queries in the system to verify the effectiveness of the method proposed in this paper. The validation results indicate that our method can be practically applied to the AR map prefabrication process and can quickly generate AR map prefabs with high information accuracy. It alleviated the repetitive workload established through the manual prefabrication method and had specific feasibility and practicality. Moreover, it could provide solid data support for developing dynamic interactive functions of AR maps. [ABSTRACT FROM AUTHOR]

Software fault prediction is an important activity in the testing phase of the software development life cycle and involves various statistical and machine learning techniques. These techniques are useful for making accurate predictions to improve software quality. Researchers have used different techniques on different datasets to build fault prediction in software projects, but these techniques vary and are not generalised. As a result, it creates challenges that make it difficult to choose a suitable technique for software fault prediction in a particular context or project. This mapping study focuses on research published from 1997 to 2020 involving fault prediction techniques, intending to determine a classification of fault prediction techniques based on problem types that researchers need to solve. This study conducted a systematic mapping study to structure and categorise the research evidence that has been published in fault prediction. A total of 82 papers are mapped to a classification scheme. This study identified research gaps and specific issues for practitioners, including the need to classify fault prediction techniques according to problem types and to provide a systematic way to identify suitable techniques for fault prediction models. [ABSTRACT FROM AUTHOR]

The HCS12 microcontroller and DRAGON12-Light Trainer boards are extensively utilized in microprocessor system design education. This paper details the rationale, approach, and outcomes from implementing the DRAGON12-Light Trainer board in teaching an upper-level undergraduate microprocessors course at Oakland University. The course's primary goal is for students to acquire the skills necessary to design both hardware and software for microprocessor-based systems, with applications across various industries. The paper assesses the effectiveness of employing the Motorola HCS12 microcontroller for its real-world relevance and integrates the Freescale CodeWarrior IDE v5.1 environment for software development. This research uniquely contributes by measuring the improvement in students' practical skills, specifically in hardware and software design using assembly and C programming, through hands-on lab assignments. It reports on the development of students' abilities to engage in microprocessor-based system design and critically evaluates the applied aspects of pedagogy by incorporating the DRAGON12-Light Trainer in lab exercises, such as those involving 'Measuring Human Reaction Time' and 'Servo motor interfacing.' Quantitative results, derived from student surveys and assessments, indicate significant improvements in students' programming competencies. The paper provides statistical results showcasing the increase in students' self-rated confidence levels in assembly and C language programming before and after course completion. Additionally, qualitative insights are discussed, reflecting students' experiences and the perceived applicability of the skills they acquired. These results underscore the pedagogical value of integrating practical training devices like the DRAGON12-Light Trainer board into microprocessors curricula. [ABSTRACT FROM AUTHOR]

This paper provides a concise overview of Agile and DevOps methodologies in software engineering. It aims to introduce readers to the fundamental principles of Agile and DevOps, accompanied by brief descriptions and practical examples. The advantages and disadvantages of each methodology are discussed, followed by a comparative analysis highlighting key differences. Understanding these methodologies is crucial in today’s IT landscape, as they are commonly employed in various organizations, impacting project management, team collaboration, and product delivery. This paper serves as a valuable resource for individuals seeking a basic understanding of Agile and DevOps methodologies in software engineering. [ABSTRACT FROM AUTHOR]

Summary: Context: Software performance is crucial for ensuring the quality of software products. As one of the non‐functional requirements, the few efforts devoted to software performance have often been neglected until a later phase in the software development life cycle (SDLC). The lack of clarity of what software performance research literature is available prevents researchers from understanding what software performance research fields are available. It also creates difficulty for practitioners to adopt state‐of‐the‐art software performance techniques. Software performance research is not as organized as other established research topics such as software testing. Thus, it is essential to conduct a systematic mapping study as a first step to provide an overview of the latest research literature available in software performance. Objective: The objective of this systematic mapping study is to survey and map software performance research literature into suitable categories and to synthesize the literature data for future access and reference. Method: This systematic mapping study conducts a manual examination by querying research literature in noble journals and proceedings in software engineering in the past decade. We examine each paper manually and identify primary studies for further analysis and synthesis according to the pre‐defined inclusion criteria. Lastly, we map the primary studies based on their corresponding classification category. Results: This systematic mapping study provides a state‐of‐the‐art literature mapping in software performance research. We have carefully examined 222 primary studies out of 2000+ research literature. We have identified six software performance research categories and 15 subcategories. We generate the primary study mapping and report five research findings. Conclusions: Unlike established research fields, it is unclear what types of software performance research categories are available to the community. This work takes the systematic mapping study approach to survey and map the latest software performance research literature. The study results provide an overview of the paper distribution and a reference for researchers to navigate research literature on software performance. [ABSTRACT FROM AUTHOR]

Task prioritization is one of the most researched areas in software development. Given the huge number of papers written on the topic, it might be challenging for IT practitioners–software developers, and IT project managers–to find the most appropriate tools or methods developed to date to deal with this important issue. The main goal of this work is therefore to review the current state of research and practice on task prioritization in the Software Engineering domain and to individuate the most effective ranking tools and techniques used in the industry. For this purpose, we conducted a systematic literature review guided and inspired by the Preferred Reporting Items for Systematic Reviews and Meta-Analyses, otherwise known as the PRISMA statement. Based on our analysis, we can make a number of important observations for the field. Firstly, we found that most of the task prioritization approaches developed to date involve a specific type of prioritization strategy—bug prioritization. Secondly, the most recent works we review investigate task prioritization in terms of "pull request prioritization" and "issue prioritization," (and we speculate that the number of such works will significantly increase due to the explosion of version control and issue management software systems). Thirdly, we remark that the most frequently used metrics for measuring the quality of a prioritization model are f-score, precision, recall, and accuracy. [ABSTRACT FROM AUTHOR]

Software Industry is evolving at a very fast pace since last two decades. Many software developments, testing and test case generation approaches have evolved in last two decades to deliver quality products and services. Testing plays a vital role to ensure the quality and reliability of software products. In this paper authors attempted to conduct a systematic study of testing tools and techniques. Six most popular e-resources called IEEE, Springer, Association for Computing Machinery (ACM), Elsevier, Wiley and Google Scholar to download 738 manuscripts out of which 125 were selected to conduct the study. Out of 125 manuscripts selected, a good number approx. 79% are from reputed journals and around 21% are from good conference of repute. Testing tools discussed in this paper have broadly been divided into five different categories: open source, academic and research, commercial, academic and open source, and commercial & open source. The paper also discusses several benchmarked datasets viz. Evosuite 10, SF100 Corpus, Defects4J repository, Neo4j, JSON, Mocha JS, and Node JS to name a few. Aim of this paper is to make the researchers aware of the various test case generation tools and techniques introduced in the last 11 years with their salient features. [ABSTRACT FROM AUTHOR]

Crowdsourcing is an emerging approach in software development, where software is developed by unknown, heterogeneous people around the globe, via an open call by the employer. Crowdsourcing, when used with agile, faces challenges because of the different development methodologies. Agile development methodology has practices that involve face-to-face frequent interaction, whereas crowdsourcing is a distributed development with no or limited face-to-face interaction. Both concepts are actively being used in the software development industry due to their benefits. However, there is a need to explore the integration of both methodologies for an effective and efficient software development. In this regard, the first step is to identify the challenges of integrating crowdsourcing and agile. In this paper, we intend to identify the possible challenges that may be faced while executing agile along with crowdsourcing. For this, we have conducted a Systematic Literature Review. Five main categories of challenges are presented which are: team issues, coordination and communication issues, organizational issues, project-related issues and task-related issues. A list of possible challenges of Agile–Crowd Software Development (ACSD) is presented in this study. [ABSTRACT FROM AUTHOR]

This study was aimed at developing an automatic exam system as an intelligent and high-quality higher math examination solution for Department of Computer Engineering at Pai Chai University (PCU) based on S/W Engineering. As a research and development (R&D) project, the study used the rational unified process (RUP) method for software development. RUP describes how to effectively use commercial and reliable methods to develop and deploy software system. It is a heavyweight process; therefore, it is particularly suitable for large teams to develop large projects. This paper describes the RUP process of this R&D project what we named it as Automatic Higher Mathematically Exam System (AHMES). AHMES provides a new way to automatically generate exam questions. In the study, our team and the requesting department collected the requirements and selected methods and tools. Then, our team designed and implemented the framework of the system, completed the development of some main functions, tested and summarized the system, and planned the future work. [ABSTRACT FROM AUTHOR]

This paper provides an introduction to the UML in the field of software engineering. The first part gives information about the UML class diagrams. Second part of this paper provides an introduction to the formal specification of UML diagrams using OCL. It also provides a detail about why formalization of UML diagrams is important. It also gives introduction about how constraints are applied to the UML diagrams using OCL. It provides knowledge about different kinds of constraints which any applied on UML class diagram. Last part of this paper shows the source code implementation in java of Bank account example of OCL constraints. [ABSTRACT FROM AUTHOR]

Unit testing is a fundamental aspect of software development, ensuring the correctness and robustness of code implementations. Traditionally, unit tests are manually crafted by developers based on their understanding of the code and its requirements. However, this process can be time-consuming, errorprone, and may overlook certain edge cases. In recent years, there has been growing interest in leveraging large language models (LLMs) for automating the generation of unit tests. LLMs, such as GPT (Generative Pre-trained Transformer), CodeT5, StarCoder, LLaMA, have demonstrated remarkable capabilities in natural language understanding and code generation tasks. By using LLMs, researchers aim to develop techniques that automatically generate unit tests from code snippets or specifications, thus optimizing the software testing process. This paper presents a literature review of articles that use LLMs for unit test generation tasks. It also discusses the history of the most commonly used large language models and their parameters, including the first time they have been used for code generation tasks. The result of this study presents the large language models for code and unit test generation tasks and their increasing popularity in code generation domain, indicating a great promise for the future of unit test generation using LLMs. [ABSTRACT FROM AUTHOR]

Runtime verification can be used to find bugs early, during software development, by monitoring test executions against formal specifications (specs). The quality of runtime verification depends on the quality of the specs. While previous research has produced many specs for the Java API, manually or through automatic mining, there has been no large-scale study of their bug-finding effectiveness. Our conference paper presented the first in-depth study of the bug-finding effectiveness of previously proposed specs. We used JavaMOP to monitor 182 manually written and 17 automatically mined specs against more than 18K manually written and 2.1M automatically generated test methods in 200 open-source projects. The average runtime overhead was under 4.3 × . We inspected 652 violations of manually written specs and (randomly sampled) 200 violations of automatically mined specs. We reported 95 bugs, out of which developers already fixed or accepted 76. However, most violations, 82.81% of 652 and 97.89% of 200, were false alarms. Based on our empirical results, we conclude that (1) runtime verification technology has matured enough to incur tolerable runtime overhead during testing, and (2) the existing API specifications can find many bugs that developers are willing to fix; however, (3) the false alarm rates are worrisome and suggest that substantial effort needs to be spent on engineering better specs and properly evaluating their effectiveness. We repeated our experiments on a different set of 18 projects and inspected all resulting 742 violations. The results are similar, and our conclusions are the same. [ABSTRACT FROM AUTHOR]

Performance/security trade-off is widely noticed in CFI research, however, we observe that not every CFI scheme is subject to the trade-off. Motivated by the key observation, we ask three questions: ➊ does trade-off really exist in different CFI schemes? ➋ if trade-off do exist, how do previous works comply with it? ➌ how can it inspire future research? Although the three questions probably cannot be directly answered, they are inspiring. We find that a deeper understanding of the nature of the trade-off will help answer the three questions. Accordingly, we proposed the GPT conjecture to pinpoint the trade-off in designing CFI schemes, which says that at most two out of three properties (fine granularity, acceptable performance, and preventive protection) could be achieved. [ABSTRACT FROM AUTHOR]

The research paper represents a novel approach to the design and optimization of a compiler for a domain-specific language (DSL) focused on geometric shape creation and manipulation. The primary objective is to develop a compiler capable of generating efficient machine code while offering users a high level of abstraction. The paper begins with an overview of DSLs and compilers, emphasizing their importance in software development. Next, it outlines the specific requirements of the geometric shape DSL and proposes a compiler design that addresses them. This innovative approach considers DSL's unique features, such as shape creation and manipulation, and aims to generate high-quality machine code. The paper also discusses optimization techniques to enhance the generated code's quality and performance, including loop unrolling and instruction scheduling. These optimizations are particularly suited to the DSL, which focuses on geometric shape creation and manipulation and are integral to achieving efficient machine code generation. In conclusion, the paper emphasizes the novelty of this approach to DSL compiler design and anticipates exciting results from testing the compiler developed for the geometric shape DSL. [ABSTRACT FROM AUTHOR]

UML diagrams are a base for the planning of development in most software projects. It is used for representing different artefacts during software development and project structure. The use case is one of the diagrams in Unified Modelling Language (UML), which allows describing the dynamic flow of the system. There are a lot of tools that are used for creating this diagram before starting the actual coding process, and the diagram needs to be specific and easily understandable. Meantime, the creation of a UML use case diagram from scratch for complex systems can be time-consuming and confusing for people, which needs to be optimised. The authors of the paper attempt to solve the addressed problem. Therefore, in this research paper a new definition for UML use case diagrams will be introduced, where the main question will be whether it is possible to formalise use case modelling by introducing pre-defined use case patterns. This is academic research and discussion, which is based on the analysis of advanced UML tools, which use case diagram templates contain. The solution to this research question contains an initial set of UML use case patterns, created by analysing of the existing use case diagram templates. Moreover, in order to validate work, the pre-defined patterns were demonstrated on a developed prototype. The operation principle of the prototype focused on giving the ability to the user to construct a use case diagram by the combination of pre-defined patterns. The prototype can be useful for the development/management process in case of correct implementation. It will allow decreasing spent time on the use case diagram creation as well as avoid creating anti-patterns. [ABSTRACT FROM AUTHOR]

When adopting and using a Software Development Method (SDM), it is important to stay true to the philosophy of the method; otherwise, software developers might execute activities that do not lead to the intended outcomes. Currently, no overview of SDM research addresses software developers' reasoning behind adopting and using SDMs. Accordingly, this paper aims to survey existing SDM research to scrutinize the current knowledge base on software developers' type of reasoning behind SDM adoption and use. We executed a systematic literature review and analyzed existing research using two steps. First, we classified papers based on what type of reasoning was addressed regarding SDM adoption and use: rational, irrational, and non-rational. Second, we made a thematic synthesis across these three types of reasoning to provide a more detailed characterization of the existing research. We elicited 28 studies addressing software developers' reasoning and identified five research themes. Building on these themes, we framed four future research directions with four broad research questions, which can be used as a basis for future research. [ABSTRACT FROM AUTHOR]

Purpose: Numerous approaches from the field of economics already exist for the improvement of business processes. In the field of software development, work has been done on improving development processes. For years, the focus here has been on agile approaches. Although various approaches for improving business processes exist, it is becoming increasingly difficult to adapt business processes to the fast-moving conditions of the market and the business environment. Agile approaches address this issue. Thus, not only software development processes, but also business processes should benefit from agile approaches. Design/methodology/approach: To this end, values and principles of the Agile Manifesto, agile methods such as Scrum, and various agile practices such as the Kanban board should be applied in business processes. This paper examines the work already done on this topic. With the help of a systematic literature review (SLR), literature studies dealing with the implementation of the agile approach in business processes are identified. Findings: This paper presents, investigates and contrasts 12 primary sources dealing with agile and business processes and shows how they are different/ equal regarding three research questions. Originality/value: We provide an overview of existing approaches handling the combination of agile and business processes to improve business processes. [ABSTRACT FROM AUTHOR]

This research paper explores the role of code analyzer that takes the help of tokenization in its working. To assure code quality and maintainability, code analysis is essential in software development. In the context of the Java programming language, this paper provides a creative approach to code analysis utilizing tokenization. Our code analyzer allows for an accurate assessment of code structure, dependencies, and patterns by tokenizing source code into understandable units. The suggested analyzer, which uses token-based methodologies, aids in the correct identification of possible defects, and performance bottlenecks. It provides vital information for developers to improve code readability, modularization, and best practices adherence. The experimental findings show that the tokenization-based technique is successful and efficient in increasing overall code quality and maintainability. [ABSTRACT FROM AUTHOR]

Scaled agile development approaches are now used widely in modern software engineering, allowing businesses to improve teamwork, productivity, and product quality. The incorporation of artificial intelligence (AI) into scaled agile development methods (SADMs) has emerged as a potential strategy in response to the ongoing demand for simplified procedures and the increasing complexity of software projects. This paper explores the intersection of AI-driven assistants within the context of the scaled agile framework (SAFe) for large-scale software development, as it stands out as the most widely adopted framework. Our paper pursues three principal objectives: (1) an evaluation of the challenges and impediments encountered by organizations during the implementation of SADMs, (2) an assessment of the potential advantages stemming from the incorporation of AI in large-scale contexts, and (3) the compilation of aspects of SADMs that AI-driven assistants enhance. Through a comprehensive systematic literature review, we identified and described 18 distinct challenges that organizations confront. In the course of our research, we pinpointed seven benefits and five challenges associated with the implementation of AI in SADMs. These findings were systematically categorized based on their occurrence either within the development phase or the phases encompassing planning and control. Furthermore, we compiled a list of 15 different AI-driven assistants and tools, subjecting them to a more detailed examination, and employing them to address the challenges we uncovered during our research. One of the key takeaways from this paper is the exceptional versatility and effectiveness of AI-driven assistants, demonstrating their capability to tackle a broader spectrum of problems. In conclusion, this paper not only sheds light on the transformative potential of AI, but also provides invaluable insights for organizations aiming to enhance their agility and management capabilities. [ABSTRACT FROM AUTHOR]

Copyright of AL-yarmouk Journall is the property of Republic of Iraq Ministry of Higher Education & Scientific Research (MOHESR) and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Debugging-the process of identifying, localizing and fixing bugs-is a key activity in software development . Due to issues such as non-determinism and difficulties of reproducing failures, debugging concurrent software is significantly more challenging than debugging sequential software. A number of methods, models and tools for debugging concurrent and multicore software have been proposed, but the body of work partially lacks a common terminology and a more recent view of the problems to solve. This suggests the need for a classification, and an up-to-date comprehensive overview of the area. This paper presents the results of a systematic mapping study in the field of debugging of concurrent and multicore software in the last decade (2005-2014). The study is guided by two objectives: (1) to summarize the recent publication trends and (2) to clarify current research gaps in the field. Through a multi-stage selection process, we identified 145 relevant papers. Based on these, we summarize the publication trend in the field by showing distribution of publications with respect to year, publication venues, representation of academia and industry, and active research institutes. We also identify research gaps in the field based on attributes such as types of concurrency bugs, types of debugging processes, types of research and research contributions. The main observations from the study are that during the years 2005-2014: (1) there is no focal conference or venue to publish papers in this area; hence, a large variety of conferences and journal venues (90) are used to publish relevant papers in this area; (2) in terms of publication contribution, academia was more active in this area than industry; (3) most publications in the field address the data race bug; (4) bug identification is the most common stage of debugging addressed by articles in the period; (5) there are six types of research approaches found, with solution proposals being the most common one; and (6) the published papers essentially focus on four different types of contributions, with 'methods' being the most common type. We can further conclude that there are still quite a number of aspects that are not sufficiently covered in the field, most notably including (1) exploring correction and fixing bugs in terms of debugging process; (2) order violation, suspension and starvation in terms of concurrency bugs; (3) validation and evaluation research in the matter of research type; (4) metric in terms of research contribution. It is clear that the concurrent, parallel and multicore software community needs broader studies in debugging. This systematic mapping study can help direct such efforts. [ABSTRACT FROM AUTHOR]

The modern world greatly depends on information systems and the software that governs them. The software architecture defines and designs the holistic structure that the software will have, its components, the interaction between them and all the development is done around it. The purpose of this systematic literature review (SLR) is to analyse the software architectures used in educational websites, methodologies, technological components and empirical results. The search of the SLR yielded 23 studies from the most significant academic sources in education and software engineering. The results of the SLR show that the analysed educational websites were proposing a software architecture, developing a system, proposing a model, assessing of a platform, proposing a Folksonomy‐Based Ontology Maintenance, reviewing smart home design, and proposing a Web‐based platform to aid parallel, distributed and high‐performance computing education. Of the 23 selected studies, 13 carried out an evaluation of their research with either students, teachers, professionals or a combination of these. In conclusion, the selected studies present narrated experiments of projects or individuals that seek to improve collaborative learning in the educational area. Finally, an important finding is that the proposed software architectures do not contemplate laws or quality standards for universal access. [ABSTRACT FROM AUTHOR]

This paper describes the first years of what became known as the Tomotherapy Research Group at the Department of Medical Physics at the University of Wisconsin‐Madison (UW). The group's roots were in algorithm and software development for radiation therapy dose calculations. The concept of helical tomotherapy sprang from the design of a treatment unit which could make the computation easier which in turn created a treatment unit that created the capability to do image‐guided radiotherapy. The paper discusses the genesis of our concepts and some of the difficulties encountered along the way. [ABSTRACT FROM AUTHOR]

The paper casts a spotlight on one of the manifold legal questions that arise with the proliferation of artificial intelligence. This new technology is attractive for many fields, including public administration, where it promises greater accuracy and efficiency, freeing up resources for better interaction and engagement with citizens. However, public powers are bound by certain constitutional constraints that must be observed, regardless of whether decisions are made by humans or machines. This includes the non-delegation principle, which aims to limit the delegation and sub-delegation of decisions affecting citizens' rights in order to ensure governmental accountability, reviewability, and contestability. This puts some constraints on the automation of decision-making by public entities, as algorithmic decision-making entails delegating decisions to software development companies on the one hand, and to algorithms on the other. The present paper reveals and explains these constraints and concludes with suggestions to navigate these conflicts in a manner that satisfies the rule of law while maximizing the benefits of new technologies. [ABSTRACT FROM AUTHOR]

What is project management leadership? If we consider the most important traits, can some of them be replaced by artificial intelligence? We'll explore some of the tools you can use today to streamline your administrative burden. Will these tools replace a human in the loop managing the actual project, or just enhance their ability to lead? To answer that question, we first have to ask what we think leadership is, can it be reduced to a checklist, and what tools are available today to make those decisions? The term "AI" covers many tasks including machine learning and deep learning. Every software vendor seems to claim it now has AI, and is the best solution. The output is still determined by processing data and looking for patterns and decisions were made during software development on priorities and guardrails. If we consider repetitive tasks, or ones that need to process vast amounts of data, the tools seem tailor made for projects. By definition, a project is a one-time event. It may be close in execution to other projects, but each is stand alone. It doesn't mean you can't learn, but it does mean there is a new path to blaze. Will we let computers make decisions? Will we require each decision to have human oversight? What if the computer (that has been programmed) makes what we consider to be a faulty decision? Who is to blame? As project management practices evolve, organizations are increasingly turning to innovative technologies to address the complexities of project execution. Artificial Intelligence (AI) offers a transformative approach to project management, providing intelligent automation, predictive analytics, and data-driven insights. This paper explores the role of AI in revolutionizing traditional project management methodologies. [ABSTRACT FROM AUTHOR]

In the rapid development of urban construction, underground pipelines play a crucial role. However, the current underground pipelines have poor association with relevant management departments, and there are deficiencies in data completeness, accuracy, and information content. Managing and sharing information resources is relatively difficult, transforming the constructed 3D underground pipeline geographic information systems into an 'Information silo'. This results in redundant construction and resource wastage of underground utilities. The complex distribution characteristics of underground utilities make rapid batch modeling and post-model maintenance challenging. Therefore, researching a 3D spatial data fusion model for urban underground utilities becomes particularly important. Given the above problem, this paper proposes a spatial data fusion model for underground pipeline scene modeling. It elaborates on the geometric, semantic, and temporal characteristics of underground pipelines, encapsulating these features. With underground pipeline objects as the core and pipeline characteristics as the foundation, a spatial data fusion model integrating multiple characteristics of underground pipelines has been constructed. Through software development, the data model designed in this paper facilitates rapid construction of underground pipeline scenes. This further enhances the consistency and integrity of underground pipeline data, enabling shared resources and comprehensive supervision of facility operations on a daily basis. [ABSTRACT FROM AUTHOR]

The Software Development (SD) process requires collaboration and sharing of information in order to achieve the best results required and Social Media (SM) has helped this process immensely. SM is frequently utilized by programmers to strengthen their SD tools. In particular, communication is a key component in collaborative development, when designing large-scale software. An engineer can ask his colleagues around the world for help in solving problems or contact users for feedback. However, there is still a need to do research about the benefits as well as limitation of usage of SM in SD process. This study examines research conducted from 2009 until 2019 to help the researchers as well as businesses to learn more about the relation between SM and SD. Inclusion and exclusion criteria is imposed to sort out the research done during the mentioned time period. Type of data extracted from the selected papers includes authors' name(s), title of the paper, year of publication, type of publication, country of origin, method used, data analysis, study setting and data collection approach. Furthermore, this paper answers to the questions posed in the study, such as what are the potential limitations of using SM for SD, and what reasons are given by the organizations for utilization of SM for SD. This paper provides a systematic literature review of 31 studies on SM and SD. [ABSTRACT FROM AUTHOR]

In recent years, microservices, as an emerging technology in software development, have been favored by developers due to their lightweight and low-coupling features, and have been rapidly applied to the Internet of Things (IoT) and Internet of Vehicles (IoV), etc. Microservices deployed in each unit of the IoV use wireless links to transmit data, which exposes a larger attack surface, and it is precisely because of these features that the secure and efficient placement of microservices in the environment poses a serious challenge. Improving the security of all nodes in an IoV can significantly increase the service provider's operational costs and can create security resource redundancy issues. As the application of reinforcement learning matures, it is enabling faster convergence of algorithms by designing agents, and it performs well in large-scale data environments. Inspired by this, this paper firstly models the placement network and placement behavior abstractly and sets security constraints. The environment information is fully extracted, and an asynchronous reinforcement-learning-based algorithm is designed to improve the effect of microservice placement and reduce the security redundancy based on ensuring the security requirements of microservices. The experimental results show that the algorithm proposed in this paper has good results in terms of the fit of the security index with user requirements and request acceptance rate. [ABSTRACT FROM AUTHOR]

General-purpose Petri Net Simulator (GPenSIM) is a new tool for modelling and simulating discrete systems. GPenSIM was developed using the Iterative Approach, which divides the software development life-cycle into smaller tasks. In each iteration, we add more functionality. However, GPenSIM was created to model industrial applications and academic purposes (teaching and research). Hence, in each iteration, some industrial, real-life, and large discrete systems are modelled, and the experiences received from these projects are also incorporated into the tool development. This paper follows the development of GPenSIM through three major iterations and explains the importance and lessons learned during these iterations. [ABSTRACT FROM AUTHOR]

Test-driven development (TDD) is an agile practice of writing test code before production code, following three stages: red, green, and refactor. In the red stage, the test code is written; in the green stage, the minimum code necessary to make the test pass is implemented, and in the refactor stage, improvements are made to the code. This practice is widespread across the industry, and various studies have been conducted to understand its benefits and impacts on the software development process. Despite its popularity, TDD studies often focus on the technical aspects of the practice, such as the external/internal quality of the code, productivity, test smells, and code comprehension, rather than the context in which it is practiced. In this paper, we present a systematic literature review using Scopus, Web of Science, and Google Scholar that focuses on the TDD practice and the influences that lead to the introduction of test smells/anti-patterns in the test code. The findings suggest that organizational structure influences the testing strategy. Additionally, there is a tendency to use test smells and TDD anti-patterns interchangeably, and test smells negatively impact code comprehension. Furthermore, TDD styles and the relationship between TDD practice and the generation of test smells are frequently overlooked in the literature. [ABSTRACT FROM AUTHOR]

Effort estimation is a crucial aspect of software development, as it helps project managers plan, control, and schedule the development of software systems. This research study compares various machine learning techniques for estimating effort in software development, focusing on the most widely used and recent methods. The paper begins by highlighting the significance of effort estimation and its associated difficulties. It then presents a comprehensive overview of the different categories of effort estimation techniques, including algorithmic, model-based, and expert-based methods. The study concludes by comparing methods for a given software development project. Random Forest Regression algorithm performs well on the given dataset tested along with various Regression algorithms, including Support Vector, Linear, and Decision Tree Regression. Additionally, the research identifies areas for future investigation in software effort estimation, including the requirement for more accurate and reliable methods and the need to address the inherent complexity and uncertainty in software development projects. This paper provides a comprehensive examination of the current state-of-the-art in software effort estimation, serving as a resource for researchers in the field of software engineering. [ABSTRACT FROM AUTHOR]

Summary: Software developers usually search existing code snippets in open source code repositories to modify and reuse them. Therefore, how to get the right code snippet from the open‐source code repository quickly and accurately is the focus of current software development research. Nowadays, code search is one of the solutions. To improve the accuracy of source code feature information representation and the accuracy of code search. A multilayer self‐ attention residual network‐based code search model (MSARN‐CS) is proposed in this paper. In the MSARN‐CS model, not only the weight of each word in the code sequence unit is considered but also the effect of embedding between code sequence units is calculated. In addition, an optimization model of residuals is introduced to compensate for the loss of information in the code sequences during the model training. To verify the search effectiveness of the MSARN‐CS model, three other baseline models are compared on the basis of extensive source code data. The experimental results show that the MSARN‐CS model has better search results compared with the baseline model. For parameter Recall@1, the experimental result of MSARN‐CS model was 9.547, which as 100.90%, 73.87%, 60.37%, and 2.55% better compared to CODEnn, CRLCS, SAN‐CS‐ and SAN‐CS, respectively. For the parameter Recall@5, the results improved by 26.67%, 36.23%, 36.21%, and 1.63%, respectively, and for the parameter Recall@10, the results improved by 13.92%, 25.70%, 20.78%, and 2.23%, respectively. For the parameter mean reciprocal rank, the results improved by 52.89%, 76.17%, 63.38%, and 3.88%, respectively. For the parameter normalized discounted cumulative gain, the results improved by 54.22%, 60.55%, 50.28%, and 3.30%, respectively. The MSARN‐CS model proposed in the paper can effectively improve the accuracy of code search and enhance the programming efficiency of developers. [ABSTRACT FROM AUTHOR]

Software design patterns have a considerable impact on the software development life cycle. Design pattern (DP) is a reliable and reusable solution provided by software experts to obtain quality software design. However, due to the large number of design patterns, selecting the appropriate one is quite difficult. To overcome this difficulty, several approaches with different methods have been presented to suggest the appropriate DP. Despite conducting a number of studies that have explored some aspects of this field, such as design pattern selection tools and techniques, there is a need for a deeper understanding, analysis, classification, and thorough review of the design pattern selection process. So far, no systematic review of design pattern selection approaches is available. This paper aims to classify existing approaches, provide several criteria for comparing approaches, analyze each one, and identify and analyze the most important elements in this field, including open issues, data sets, and so on. The present investigation paper will help future research to employ the existing approaches taking into account the specification of each one and it also raises awareness about the approaches used in previous research and their potential limitations. [ABSTRACT FROM AUTHOR]

Copyright of Military Technical Courier / Vojnotehnicki Glasnik is the property of Military Technical Courier / Vojnotehnicki Glasnik and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Project management development has become increasingly advanced, with many methods, tools, certifications, guidelines and recommendations created to enhance its professional edge. There are some professional organisations like PMI, IPMA, Axelos and many agile project managementrelated institutions, experienced in project management, who deliver the latest and possibly greatest guidelines and recommendations. Agile Manifesto has presented four key values and twelve principles as mandatory rules for software development projects delivering complex and custom-made software products and services. However, project management rules and values largely depend on the people themselves – project managers, project teams and their organisational context. Each project manager (PM) has different knowledge and experience, a different set of competencies and skills, making them professional, and a different set of values driving them to what is most important in the project management profession. The primary goal of this paper is to respond to the vital question about the possibility of creating the project manager's manifesto and present the individual case study as an example with the guidelines and values representing the most important ones from the perspective of the project manager's professionals. The second goal is to present how the project manager's manifesto can be created from scratch in a given organisational context using elements of the design thinking method. The elements of the design thinking method were applied to gather example case studies. The example of an individual project manager's manifesto is presented as empirical research results. The research results focus on responding to the key title question and a few related ones: What is important to the PM in their project management profession? What is the direction of work for each PM? What are PM's beliefs, and what areas would they like to change? What are the PM's values that are identified in their profession? The results showed it is possible to create the project manager's manifesto from scratch adapted to the specific group of people working together in the project and its organisational context. An example of a case study with applied elements of the design thinking method resulted in an example PM manifesto presenting ten rules and values of the professional project manager. They are related to methods, standards and practices; PM's competencies and experience; the integrity of projects, people, customers, communication and transparency; data-driven decisions; PM's autonomy and project organisation context. [ABSTRACT FROM AUTHOR]

Software refactoring focuses on improving software quality by applying changes to the internal structure that do not alter the observable behavior. Determining which refactorings should be applied and presented to developers the most relevant and optimal refactorings is often challenging. Existing literature suggests that one of the potential sources to identify and recommend required refactorings is the past software development and evolution histories which are often archived in software repositories. In this article, we review a selection of existing literature that has attempted to propose approaches that facilitate refactoring by exploiting information mined from software repositories. Based on the reviewed papers, existing works leverage software history mining to support analysis of code smells, refactoring, and guiding software changes. First, past history information is used to detect design flaws in source code commonly referred to as code smells. Moreover, other studies analyze the evolution of code smells to establish how and when they are introduced into the code base and get resolved. Second, software repositories mining provides useful insights that can be used in predicting the need for refactoring and what specific refactoring operations are required. In addition, past history can be used in detecting and analyzing previously applied refactorings to establish software change facts, for instance, how developers refactor code and the motivation behind it. Finally, change patterns are used to predict further changes that might be required and recommend a set of files for change during a given modification task. The paper further suggests other exciting possibilities that can be pursued in the future in this research direction. This article is categorized under:Algorithmic Development > Text MiningApplication Areas > Data Mining Software Tools [ABSTRACT FROM AUTHOR]

This paper reviews the literature on automatic code generation of user-centered serious games. We decided to break the study in two parts: one study about serious games with model driven engineering, and another study about user-centered serious games. This paper presents an extension of a paper presented at CONISOFT 20 where a systematic review of 5 years old at the time of writing was presented exclusively. The systematic literature review conducted in this paper covers a decade of information from January 2012 to June 2022. The main objective is to know the literature that helps to mitigate the costs and time of software development in serious games. The overall conclusion is that there is still work to be done to combine serious user-centered games and automatic generation. This paper is a systematic review that identifies relevant publications and provides an overview of research areas and publication venues. In addition, Research perspectives were classified according to common objectives, techniques, and approaches. Finally, is presented point out challenges and opportunities for future research and development. [ABSTRACT FROM AUTHOR]