Software Development Paradigm Research Articles

TypeTaxonScript: sugarifying and enhancing data structures in biological systematics and biodiversity research.

Object-oriented programming (OOP) embodies a software development paradigm grounded in representing real-world entities as objects, facilitating a more efficient and structured modelling approach. In this article, we explore the synergy between OOP principles and the TypeScript (TS) programming language to create a JSON-formatted database designed for storing arrays of biological features. This fusion of technologies fosters a controlled and modular code script, streamlining the integration, manipulation, expansion, and analysis of biological data, all while enhancing syntax for improved human readability, such as through the use of dot notation. We advocate for biologists to embrace Git technology, akin to the practices of programmers and coders, for initiating versioned and collaborative projects. Leveraging the widely accessible and acclaimed IDE, Visual Studio Code, provides an additional advantage. Not only does it support running a Node.js environment, which is essential for running TS, but it also efficiently manages GitHub versioning. We provide a use case involving taxonomic data structure, focusing on angiosperm legume plants. This method is characterized by its simplicity, as the tools employed are both fully accessible and free of charge, and it is widely adopted by communities of professional programmers. Moreover, we are dedicated to facilitating practical implementation and comprehension through a comprehensive tutorial, a readily available pre-built database at GitHub, and a new package at npm.

Management Consulting in the Artificial Intelligence – LLM Era

Abstract Management Consulting is one of the oldest and most well-established professional services across the world. Consultants have developed subject matter expertise and competency in a variety of areas such as General and Strategic Management, Financial Management, Marketing & Distribution Management, e-Business, Operations Management, Human Resource Management, Knowledge Management, Enterprise Performance Management, Business Transformation, Quality Management, and Information Technology. Information Technology as a discipline has evolved rapidly in the last three decades with software development paradigms and the advancement in artificial intelligence (AI) and machine learning (ML) technologies. The space of AI & ML technologies is rapidly evolving, impacting the way insights are arrived at, how decisions are taken, organization models, and organization structures. This article explores the challenges, new opportunities and potential changes to the ways of working for management consultants given the developments in AI, particularly with large language models.

Study of Learning Techniques for Effort Estimation in Object-Oriented Software Development

Software effort estimation (SEE) is helpful for project managers to decide the cost and effort needed to complete the project. The techniques used for estimating effort in conventional software development are not very useful for estimating effort in object-oriented projects because of their varying nature. The machine learning (ML) approaches are achieving greater recognition in SEE research because they can demonstrate the complex relationship between software effort and other attributes. So, there is a need for a systematic literature review (SLR) that can discuss the applicability of ML techniques for SEE in object-oriented projects, which is not available in the literature. This research aims to provide a specific review and analysis of various ML-based SEE works in the object-oriented software development (OOSD) paradigm based on different perspectives: type of learning technique used, type of performance measure used, performance level achieved, the dataset used, etc. Purposefully, we have chosen appropriate articles after applying selection and quality evaluation criteria. After investigation, we found that different ML techniques have been applied in these works, and their performance is better than the classical models. Hence, more efforts are needed to encourage the application of ML techniques for SEE in the OOSD paradigm. Also, most of the works have used small-sized datasets for effort estimation in OOSD, due to which their model's performance cannot be generalized. So, the researchers should collect more large-sized datasets working in line with the software organizations.

The vital role of community in open source software development: A framework for assessment and ranking

AbstractOpen source software (OSS) follows a software development paradigm whereby self‐motivated volunteers scattered all around the globe contribute to the development in the form of code, documentation, feedback, feature recommendations, bug reporting, and bug resolution. These volunteers, commonly referred to as OSS project community, serve as the foundation of the OSS project, fostering its creation and sustenance and providing long‐term support. The quality and sustainability of the OSS project is reliant upon the development and structure of the self‐governing community. When a business organization plans to acquire an OSS solution, it not only takes into consideration the factors such as reliability, security, and scalability but also attaches significant importance to the likelihood of the OSS project being maintained and supported in the future so that it can rely on it as a stable and secure technology solution. Modern cloud‐based software hosting platforms, such as GitHub, offer a range of options for automatically and freely accessing the complete development history of millions of OSS projects. This easy availability of detailed development history has enabled researchers to analyze and draw quantitative and scientific inferences about the quality of an OSS project which generally involves assessing three aspects, namely, software product, development process, and project community. With focus on project community part, a Framework for Assessment and Ranking of OSS Community is being presented in the current research work, following a detailed examination of the largest source code hosting and project collaboration platform, GitHub. Technique for Order of Preference by Similarity to Ideal Solution from Multi‐Criteria Decision‐Making toolkit has been utilized for assessing the quality of the project community. The framework has been validated by applying it on nine OSS projects and comparing the results with the outcomes obtained through an existing OSS evaluation methodology. The comparative analysis demonstrated that the proposed framework aligns with the aforementioned evaluation methodology while offering an opportunity for in‐depth analysis on the dynamics of volunteer communities, which is lacking in previous evaluation methods. These insights can prove valuable for both potential adopters and project maintainers, aiding them in making informed strategic decisions.

Why don’t we trace? A study on the barriers to software traceability in practice

Researchers have proposed numerous tools, methods, and techniques for establishing and maintaining software traceability. Despite its acknowledged importance, researchers argue that traceability is still “a sought-after, yet often elusive quality in software-intensive systems”. We have little evidence regarding how creating, managing, and using traceability links vary depending on factors such as organizational contexts, software development practices, and project types. We conduct an empirical study where software development practitioners express their perception regarding the value of software traceability. Via an online survey, 55 participants provided information related to their current traceability practices and needs. Furthermore, we interviewed 14 practitioners to gain a more in-depth understanding. Our study investigates the effect of two independent variables: the software development paradigm and the type of developed software system. Among the several identified findings, our analysis reveals that, although the traceability costs are an inhibitor for adopting more mature traceability practices, the respondents believe that the expected benefits still outweigh envisioned costs. Traceability is mainly performed manually: not only are automated trace retrieval tools scarce, but their offered automation is not expected to replace human involvement.

CodePlex: Software Complexity Measuring Tool based on ECB Measure

The surge in popularity of object-oriented programming as a predominant paradigm in software development has spurred numerous studies to introduce metrics for assessing the complexity of object-oriented programs. These metrics typically fall into two primary categories: those focusing on object-oriented aspects and those centered on cognitive aspects, delineating their principal areas of concern when evaluating program complexity. Within the realm of cognitive aspects, the majority of metrics have historically been confined to the consideration of no more than three complexity variables. However, the ECB (Enhanced Cognitive Based) measure stands as a notable exception, capable of encompassing and addressing four or more intricate facets in the assessment of software program intricacy and difficulty. This research paper undertakes the exploration of the incorporation of these multidimensional metrics as refinements to the existing weighted composite complexity CB measure, originally introduced by Chhillar and Bhasin. In doing so, it endeavors to furnish a more comprehensive and holistic framework for the evaluation of program complexity, accommodating both object-oriented and cognitive dimensions. Furthermore, the study assumes the pivotal role of empirically validating the practical effectiveness of the ECB measure, seeking to bridge the chasm between theoretical metrics and their tangible applicability in real-world settings. Such an endeavor holds profound significance for software developers and researchers, proffering invaluable insights that can advance our understanding and management of intricate object-oriented programs.

Computational category-theoretic rewriting

We demonstrate how category theory provides specifications that can efficiently be implemented via imperative algorithms and apply this to the field of graph transformation. By examples, we show how this paradigm of software development makes it easy to quickly write correct and performant code. We provide a modern implementation of graph rewriting techniques at the level of abstraction of finitely-presented C-sets and clarify the connections between C-sets and the typed graphs supported in existing rewriting software. We emphasize that our open-source library is extensible: by taking new categorical constructions (such as slice categories, structured cospans, and distributed graphs) and relating their limits and colimits to those of their underlying categories, users inherit efficient algorithms for pushout complements and (final) pullback complements. This allows one to perform double-, single-, and sesqui-pushout rewriting over a broad class of data structures. Graph transformation researchers, scientists, and engineers can then use this library to computationally manipulate rewriting systems and apply them to their domains of interest.

DCServCG: A data-centric service code generation using deep learning

Modern software development paradigms, including Service-Oriented Architecture (SOA), tend to make use of available services e.g., web service Application Programming Interfaces (APIs) to generate new software. Thus, for the further advancement of SOA, the development of accurate automatic tasks, such as service discovery and composition, is necessary. Most of these automated tasks rely heavily on web service metadata annotation. The lack of machine-readable documentation and structured metadata reduces the accuracy and volume of automatic data annotation, negatively affecting the performance of automated SOA tasks. This study aims to propose automatic code completion for improving web service-based systems by identifying and capturing service usage collected from public repositories that share Open Source Software (OSS). To this end, a Data-Centric Service Code Generation (DCServCG) model is proposed to improve old-fashioned, general-purpose code generators that neglect essential service-based code characteristics e.g., sequence overlap and bias issues. DCServCG takes advantage of the data-centric concept, i.e., conditional text generation, to overcome the mentioned issues. We have evaluated the approach from the point of view of language modeling metrics. The obtained results indicate that the usage of the data-centric approach reduces perplexity by 1.125. Moreover, the DCServCG model uses de-noising and conditional text generation, which is trained on the transformer by distilling the knowledge, DistilGPT2 (82M parameters) trained faster and its perplexity is 0.363 lower than ServCG (124M parameters) without de-noising and conditional text generation, which lower perplexity value indicates better model generalization performance.

What Petri Nets Oblige us to Say Comparing Approaches for Behavior Composition

We identify and demonstrate a weakness of Petri Nets (PN) in specifying composite behavior of reactive systems. Specifically, we show how, when specifying multiple requirements in one PN model, modelers are obliged to specify mechanisms for combining these requirements. This yields, in many cases, over-specification and incorrect models. We demonstrate how some execution paths are missed, and some are generated unintentionally. To support this claim, we analyze PN models from the literature, identify the combination mechanisms, and demonstrate their effect on the correctness of the model. To address this problem, we propose to model the system behavior using behavioral programming (BP), a software development and modeling paradigm designed for seamless integration of independent requirements. Specifically, we demonstrate how the semantics of BP, which define how to interweave scenarios into a single model, allow for avoiding the over-specification. Additionally, while BP maintains the same mathematical properties as PN, it provides means for changing the model dynamically, thus increasing the agility of the specification. We compare BP and PN in quantitative and qualitative measures by analyzing the models, their generated execution paths, and the specification process. Finally, while BP is supported by tools that allow for applying formal methods and reasoning techniques to the model, it lacks the legacy of PN tools and algorithms. To address this issue, we propose semantics and a tool for translating BP models to PN and vice versa.

Decision Making of Agile Patterns in Offshore Software Development Outsourcing: A Fuzzy Logic-Based Analysis

Computation intelligence techniques are important for making decisions in an agile-based offshore software development paradigm. Offshore development faces additional challenges, such as trust, communication and coordination, and socio-cultural and knowledge transfer. There is a need to determine the rankings of challenges considering their criticality concerning practitioners working in agile-based offshore software development. This paper aims to identify and rank agile challenges in offshore software development by applying computational intelligence techniques. From the systematic literature review, we identified 30 communication and coordination challenges. The distributed agile pattern catalog consists of 15 patterns, from which eight were used to solve communication and collaboration challenges. Many researchers have used fuzzy logic to quantify their results. We further applied the fuzzy analytical technique to determine the priority order concerning the criticality of the identified agile pattern catalog. The results showed that Central Code Repository Pattern ranked the most significant for solving communication and coordination challenges. Global Scrum Board Pattern and Synchronous Communication Pattern ranked second.

A Survey on the Use of Lightweight Virtualization in I4.0 Manufacturing Environments

Over the past decade, in the industrial sector we have witnessed the rise of a revolutionary movement, known as Industry 4.0, that promotes the digital transformation as the key to increase the competitiveness of manufacturing factories. Among the many technologies recognized as “drivers” of such revolutionary transition, microservices stand out as a software development paradigm capable of bringing several benefits to the manufacturing process. Whilst the literature offers many examples of initiatives exploiting microservices in digitally-advanced sectors (e.g., finance, telecommunication, retailing), its potential in the industrial manufacturing is yet to be fully unleashed. We conducted an extensive literature survey in the twofold aim of bringing to the reader’s attention the many benefits that the microservices paradigm may offer in industrial manufacturing settings, and drawing a picture of how light virtualization techniques are actually being exploited to achieve Industry 4.0 digitization goals. In this paper, we propose a structured analysis of the collected literature proposals which combines the benefits sought by authors when approaching to the microservices techniques and the specific scope of application of proposals. We conclude the paper highlighting the research aspects that have not been sufficiently explored in the literature and that would deserve further attention in the near future.

Code generation for large commercial projects: how commercial development will look like in the future

In the rapidly evolving landscape of software development, code generation stands at the forefront as a transformative force, especially within the domain of large-scale commercial projects. This paradigm-shifting technique is fundamental to agile adaptation in response to ever-changing business imperatives, all while upholding stringent code quality standards and reducing error rates. The article initiates a discourse by methodically analyzing the current methodologies and tools of code generation, emphasizing their critical importance for development teams. It delves into the complexities these tools mitigate, such as abstraction of repetitive coding tasks and acceleration of the development lifecycle. The discussion progresses to address the intricacies of scaling code generation processes, including issues of standardization, integration with legacy systems, and ensuring the maintained quality of automatically generated code segments. A particular focus is laid on the prospective role of artificial intelligence in the genesis of business logic, postulating a future where AI extends beyond mere automation, becoming a vital contributor to the creation of self-adapting, precision-targeted business functionalities. I introduce a structured approach to template code generation that underscores the importance of quick development setups and outline a set of principles for the AI-driven derivation of business logic. Moreover, the article offers an insightful prognosis on the potential reformation of software development paradigms by code generation technologies, looking into the crystal ball of this field’s evolutionary path. It concludes with a visionary examination of the implications for the software industry, charting out the roadmap for practitioners to navigate and adapt to these upcoming shifts in commercial development methodologies.

Modular Over‐the‐air Software Updates for Safety‐critical Real‐time Systems

ABSTRACTAutomotive software is undergoing a rapid change toward artificial intelligence and towards more and more connectedness with other systems. For both, an incremental design paradigm is desired, where the car's software is frequently updated after production but still can guarantee the highest automotive safety standards. We present a design flow and tool framework enabling a DevOps paradigm for automotive software development. DevOps means that software is developed in a continuous loop of development, deployment, usage in the field, collection of runtime data and feedback to the developers for the next design iteration. The software developers get support in defining, developing, and verifying new software functions based on the data gathered in the field by the previous software generation. The software developers can define contracts describing the time and resource assumptions on the integration environment and guarantees for other dependent software components in the system. These contracts allow a composition of software components and proof obligations to be discharged at design time through virtual integration testing and runtime through continuous monitoring of assumptions and guarantees on the software component's interfaces. An update package, consisting of the software component and its contracts, is then automatically created, transferred over the air, and deployed in the car. Monitors derived from the contracts allow for supervising the system's behavior, detecting failures at runtime, and annotating the situation to be included in a data collection, fueling the next design iteration.

Aspect Oriented Programming: Trends and Applications

The competitive advantage of aspect oriented programming (AOP) is that it improves the maintainability and understandability of software systems by modularizing crosscutting concerns. However, some concerns, such as logging or debugging, may be overlooked and should be entangled and distributed across the code base. AOP is a software development paradigm that enables developers to capture crosscutting concerns in split-aspect modes. Additionally, it is a novel notion that has the potential to improve the quality of software programs by removing the complexity involved with the production of code tangles via the usage of separation of concerns. As a result, it provides more modularity. Throughout its early development, some believed that AOP was easier to build and maintain than other implementations since it was based on an existing one. The statements are predicated on the premise that local improvements are easier to implement. Additionally, without appropriate visualization tools for both static and dynamic structures, cross-cutting challenges may be difficult for developers and researchers to appreciate. In recent years, AspectJ has begun to enable the depiction of crosscutting concerns via the release of IDE plugins. This article explains aspect oriented programming and how it may be used to improve the readability and maintainability of software projects. Additionally, it will evaluate the challenges it presents to application developers and academics.

Success factors analysis for requirement elicitation in global software development paradigm: An empirical study

AbstractRequirement's elicitation is the process of gathering requirements from users, customers, and stakeholders using traditional or collaborative elicitation techniques. Software requirement gathering is a challenging task particularly in a Global Software Development (GSD) paradigm due to geographical distance, limited face to face meetings, time zone differences, and language and cultural barriers. As more companies begin to adopt GSD in order to save costs, the success factors need to be identified and evaluated in order to ensure a successful elicitation process. This paper offers an in‐depth analysis on success factors for requirement elicitation within GSD environment. First, all possible success factors are identified from the literature via a Systematic Literature Review (SLR). Next, these factors are evaluated by software industries via a questionnaire survey across different types and levels of experts, size of organizations, and from the client–vendor perspective. The relationships between the success factors and the survey results were evaluated using the Spearman's correlation coefficient. The results produced a 0.835 Spearman's correlation coefficient at significance level ρ = 0.000, which showed a strong positive correlation between the outcome of SLR and survey with no significant difference.

Software development process evolution and paradigm shift - a case study of Malaysian companies

Due to the consequences of global software development (GSD), the traditional approaches of software development evolved into lightweight agile methods. The agile methods got overwhelming response from software development companies due to their obvious support to GSD. In this regard, limited research work has been presented on software process evolution and process paradigm shift in context of GSD. Most of the work presented on GSD mainly focus on the companies in Europe, America, Australia and other western countries. Existing research work highlight the standard benefits and challenges of GSD but do not investigate its effect on software development processes and associated reasons causing the affect particularly in Malaysian software development companies. The research work presented in this paper addresses this issue and investigates the effects of GSD on software processes, software process evolution and paradigm shift and finds the current software processes being used in Malaysian companies. Also, it further determines the GSD factors and reasons behind the change and selection of a software development process. GSD factors affecting the software processes have been termed as challenges. Structured interviews have been conducted to collect qualitative data from industry professionals involved in GSD. General inductive approach has been used for qualitative data analysis and findings. The results show that after GSD, Malaysian companies are mostly following agile methods. The traditional and ad-hoc approaches used before GSD have been replaced by the lightweight agile methodologies. Few of the companies are still following ad-hoc approaches mainly due to size of the project and company as most of the Malaysian companies are small and medium size. The research is significant that it provides clear insight into software process paradigm in Malaysian companies. The outcome of the research provides foundations for the standardization of software processes, process improvement, selection and quality enhancement approaches in Malaysian companies.

A Novel Method for Identifying Microservices by Considering Quality Expectations and Deployment Constraints

Nowadays, microservice architecture has become a dominant software development and deployment paradigm. Decomposing a system into loosely coupled, highly cohesive, and fine-grained microservices while meeting various technical constraints and implementing business capabilities is particularly important for microservice system (MS) designers. When an MS has a large number of functionalities and complex interconnections, it is a big challenge to identify microservices solely based on the experience of MS designers. We propose a structured and automated microservice identification method to decompose a system into appropriate microservices for this challenge. We model a system as unified modeling language (UML) class and sequence diagrams. In the identification phase, we take into account not only the traditional coupling-related criteria but also the quality expectation and deployment constraints, both of which have not yet been fully concerned in previous studies. Based on the criteria, a microservice identification algorithm using the clustering technique is designed. A case study of elderly care services illustrates the identification process. Experiments are conducted to evaluate and compare the proposed method against state-of-the-art methods. Results indicate that the proposed method significantly outperforms those compared from the literature.

Challenges and solutions when adopting DevSecOps: A systematic review

DevOps (Development and Operations) has become one of the fastest-growing software development paradigms in the industry. However, this trend has presented the challenge of ensuring secure software delivery while maintaining the agility of DevOps. The efforts to integrate security in DevOps have resulted in the DevSecOps paradigm, which is gaining significant interest from both industry and academia. However, the adoption of DevSecOps in practice is proving to be a challenge. This study aims to systemize the knowledge about the challenges faced by practitioners when adopting DevSecOps and the proposed solutions reported in the literature. We also aim to identify the areas that need further research in the future. We conducted a Systematic Literature Review of 54 peer-reviewed studies. The thematic analysis method was applied to analyze the extracted data. We identified 21 challenges related to adopting DevSecOps, 31 specific solutions, and the mapping between these findings. We also determined key gap areas in this domain by holistically evaluating the available solutions against the challenges. The results of the study were classified into four themes: People, Practices, Tools, and Infrastructure. Our findings demonstrate that tool-related challenges and solutions were the most frequently reported, driven by the need for automation in this paradigm. Shift-left security and continuous security assessment were two key practices recommended for DevSecOps. People-related factors were considered critical for successful DevSecOps adoption but less studied. We highlight the need for developer-centered application security testing tools that target the continuous practices in DevSecOps. More research is needed on how the traditionally manual security practices can be automated to suit rapid software deployment cycles. Finally, achieving a suitable balance between the speed of delivery and security is a significant issue practitioners face in the DevSecOps paradigm.

Object-Oriented Programming and Software Development Paradigm

Object-Oriented Programming and Software Development Paradigm

Powerful authentication regime applicable to naval OFP integrated development (PARANOID): a vision for non-circumventable code signing and traceability for embedded avionics software

Purpose This paper aims to describe an effort to provide for a robust and secure software development paradigm intended to support DevSecOps in a naval aviation enterprise (NAE) software support activity (SSA), with said paradigm supporting strong traceability and provability concerning the SSA’s output product, known as an operational flight program (OFP). Through a secure development environment (SDE), each critical software development function performed on said OFP during its development has a corresponding record represented on a blockchain. Design/methodology/approach An SDE is implemented as a virtual machine or container incorporating software development tools that are modified to support blockchain transactions. Each critical software development function, e.g. editing, compiling, linking, generates a blockchain transaction message with associated information embedded in the output of a said function that, together, can be used to prove integrity and support traceability. An attestation process is used to provide proof that the toolchain containing SDE is not subject to unauthorized modification at the time said critical function is performed. Findings Blockchain methods are shown to be a viable approach for supporting exhaustive traceability and strong provability of development system integrity for mission-critical software produced by an NAE SSA for NAE embedded systems software. Practical implications A blockchain-based authentication approach that could be implemented at the OFP point-of-load would provide for fine-grain authentication of all OFP software components, with each component or module having its own proof-of-integrity (including the integrity of the used development tools) over its entire development history. Originality/value Many SSAs have established control procedures for development such as check-out/check-in. This does not prove the SSA output software is secure. For one thing, a build system does not necessarily enforce procedures in a way that is determinable from the output. Furthermore, the SSA toolchain itself could be attacked. The approach described in this paper enforces security policy and embeds information into the output of every development function that can be cross-referenced to blockchain transaction records for provability and traceability that only trusted tools, free from unauthorized modifications, are used in software development. A key original concept of this approach is that it treats assigned developer time as a transferable digital currency.