Effective Workflow Automation in GitHub: Leveraging Bash and YAML

---

Author(s): Abhiram Reddy Peddireddy

Abstract

Automation plays a role, in todays software development landscape within continuous integration and continuous delivery (CI/CD) setups. GitHub Actions, a tool for automating tasks in GitHub repositories heavily relies on scripting languages to define and execute operations. This paper delves into the merging of Bash and YAML scripting languages to enhance automation, on GitHub. By utilizing Bash for command execution and YAML for configuration developers can build resilient, effective and secure workflows. This method simplifies the automation of development processes enhances error handling and boosts workflow maintainability. Case studies showcase how the combination of Bash and YAML can tackle IT hurdles like step deployments, automated testing and ongoing monitoring - making software development and operational tasks more streamlined. 

Introduction

Workflow automation is an essential aspect of modern software development, significantly enhancing productivity and efficiency by automating repetitive and complex tasks within CI/CD pipelines. Automation helps in managing the growing complexity of software projects, ensuring consistency, and reducing manual errors. Workflow automation tools and methodologies have evolved to support diverse activities, from code integration and deployment to issue tracking and testing.

Key components of workflow automation include:

• Business Process Modeling: Captures business processes as workflow specifications, enabling organizations to visualize and optimize their processes.
• Workflow Management Systems (WMS): Facilitate the definition, execution, and management of workflows, integrating various applications and systems to streamline
• Integration with Development Tools: Modern workflow automation often integrates with tools like version control systems, issue trackers, and CI/CD platforms, enabling seamless transitions between different stages of the soft- ware development lifecycle.

Workflow automation technologies help in achieving faster development cycles, better resource management, and enhanced collaboration among development teams. The use of scripting languages like Bash and configuration languages like YAML plays a critical role in defining and executing automated workflows, especially in environments like GitHub

Importance of CI/CD Pipelines

In software development the use of Continuous Integration and Continuous Delivery (CI/CD) pipelines is essential. These pipelines automate the process of combining code changes from contributors and deploying them to production environments efficiently and reliably. Automating these tasks ensures that new code additions are consistently tested and validated, reducing the risk of introducing errors or bugs into the software.

CI/CD pipelines play a role, in speeding up development cycles by enabling developers to merge code changes into a shared repository. This approach not accelerates development. Also enhances code quality by detecting issues early on in the process. Testing and deployment processes contribute to maintaining a software product meeting users high expectations.

Moreover CI/CD pipelines promote collaboration among development teams. By providing feedback on code modifications developers can address issues promptly. Enhance their contributions. This collaborative atmosphere encourages innovation. Enables frequent software releases to stay competitive and responsive, to user demands.

Incorporating CI/CD pipelines into software development workflows is crucial, for driving enhancements and sustaining productivity. This practice simplifies the development cycle boosts code quality and empowers teams to roll out features and updates to keep up with the rapid pace of the modern software sector.

Background

GitHub Actions is an integrated feature of GitHub that lets you automate tasks for software development right in your repositories. Launched in 2019 GitHub Actions allows developers to create customized workflows triggered by events like push notifications pull requests or issue creation. These workflows are set up using YAML configuration files that detail the steps for automation.With GitHub Actions you can perform a variety of tasks such as code building, testing, application deployment and project workflow management. The platform offers a range of built actions in the GitHub Marketplace that developers can use to speed up their workflow creation process. These actions can be mixed. Matched to suit the requirements of a project providing flexibility and efficiency in automation.

Integrating GitHub Actions into your development pipeline has benefits. It makes integration and continuous delivery (CI/ CD) processes more efficient by automating code testing and deployment. This automation reduces the need for intervention lowers the risk of errors and speeds up development cycles. Additionally its seamless integration with GitHub features like repositories. Issue tracking enhances collaboration and boosts productivity, for developers.

In conclusion GitHub Actions is a tool, for streamlining software development workflows providing flexibility, scalability and integration features that greatly enhance the effectiveness and dependability of development procedures.

Introduction to Bash Scripting

Bash scripting is an essential skill for developers and system administrators, providing a powerful tool for automating tasks, managing systems, and enhancing productivity in Unix-like operating systems. This overview summarizes literature on the topic delving into principles, practical uses and advanced methods of Bash scripting.

Bash, which stands for “Bourne Again Shell” serves as a command interpreter typically running in a text window where users enter commands to trigger actions. A Bash script essentially consists of a text document with a series of commands that the Bash shell can carry out. These scripts prove handy for automating actions, like handling files monitoring systems and processing tasks in batches.

Introduction to YAML Scripting

YAML, which stands for “YAML Ain’t Markup Language,” is a data serialization standard that’s easy for humans to read and write. It is commonly used for configuration files and sharing data between programming languages with varying structures. This overview discusses YAMLs features, uses and its importance across different fields.

YAML aims to be user friendly with a syntax that’s more concise than XML and easier to understand than JSON. Its key features include:

• Simplicity: YAML has a structure that helps new users get up to speed
• Human-Readability: The format of YAML makes it effortless for people to interpret which is advantageous for working with configuration files and data records.
• Flexibility: YAML can handle data types like lists, dictionaries and individual values making it adaptable for various

Advanced applications of YAML include:

• Complex Data Structures: YAML can represent configurations with nested lists and dictionaries.
• YAML often pairs well with scripting languages such as Python, SHELL (Bash, Zsh) and JavaScript, for tasks involving data manipulation and automation.

Purpose of the Paper

The purpose of this paper,”Effective Workflow Automation in GitHub: Leveraging Bash and YAML,” is to delve into the benefits of merging YAML and Bash scripting to automate workflows within GitHub. The intention is to present an examination of how these scripting languages can be utilized to boost the effectiveness, adaptability and security of CI/CD pipelines. By analyzing real world examples, best practices and potential obstacles this paper aims to provide insights and practical advice for developers and IT experts seeking to optimize their GitHub processes. Through this investigation the paper aims to emphasize the following objectives:

• Demonstrate the Synergy between YAML and Bash: Demonstrate how combining YAMLs configuration capabilities with Bashs scripting prowess can create sustainable automation workflows, in
• Highlight Efficiency Improvements: Illustrate how utilizing these scripting languages can simplify workflow procedures decrease interference and raise development
• Enhance Workflow Security: Discuss best practices for securing workflows, managing secrets, and ensuring compliance with security standards using YAML and
• Provide Practical Examples and Case Studies: Present real-world scenarios and case studies to demonstrate the practical application and benefits of integrating YAML and Bash in GitHub
• Offer Best Practices and Recommendations: Provide actionable guidelines and best practices for effectively using YAML and Bash to automate complex workflows, including tips for writing maintainable code and managing workflow

This paper aims to enhance the understanding of workflow automation in software development by addressing these goals. It provides insights that can assist developers and organizations in optimizing their utilization of GitHub Actions, for enhanced software delivery efficiency.

Literature Review

Workflow automation in GitHub, especially using Bash and YAML, significantly enhances software development efficiency by automating various processes. GitHub Actions, which allow developers to define custom workflows, utilize YAML (YAML Ain’t Markup Language) for its human- readable format. YAML provides a structured way to define and automate tasks triggered by repository events. Integrating Bash scripts within these YAML- defined workflows further augments their functionality. Bash, a powerful scripting language, enables complex command-line tasks to be executed seamlessly within the workflow. This combination of YAML for defining workflows and Bash for executing tasks offers several benefits:

Flexibility and Efficiency

The integration of Bash scripting and YAML, within GitHub Actions provides a deal of flexibility and efficiency when automating tasks. Bash scripts allow for the execution of command sequences while YAML offers an approach to defining and managing workflows. This combination reduces the need for intervention accelerates development processes and enables developers to concentrate on crucial responsibilities.

A research study on GitHub Actions revealed that developers lean towards using verified Actions and often switch to ones when encountering bugs or insufficient documentation. The study shed light on the difficulties developers encounter with YAML files, such, as composition issues and error proneness [1]. Moreover, an empirical study on GitHub projects revealed that the adoption of GitHub Actions significantly enhances project efficiency by improving commit frequency, pull request handling, and issue resolution [2].

Consistency and Reliability

Automated workflows ensure that processes are repeatable and reliable, minimizing errors and inconsistencies. By leveraging the strengths of both Bash and YAML, developers can create robust workflows that enhance the maintainability and security of CI/CD pipelines. This structured approach not only streamlines automation but also improves error handling and overall workflow reliability.

Research indicates that a significant portion of GitHub repositories have adopted GitHub Actions, with reuse of Actions being a common practice despite challenges in their documentation and debugging [3]. Additionally, the use of GitHub Actions has been shown to positively affect the pull request process, leading to more thorough code reviews and increased communication among developers [4].

Enhanced Collaboration and Productivity

CI/CD pipelines facilitate better collaboration among development teams by providing immediate feedback on code changes. This collaborative environment fosters innovation and allows for more frequent releases, ensuring that software products remain competitive and responsive to user needs. The integration of GitHub Actions with Bash and YAML significantly enhances the productivity and efficiency of development processes.

A study on the evolution of GitHub Action workflows found that modifications to these workflows are common, and there is a need for better tooling to support refactoring, debugging, and editing [5]. Furthermore, the adoption of automation tools like GitHub Actions has been linked to improved workflow efficiency and better resource management [2].

Methodology

Bash scripting and YAML configuration work together to improve the automation of CI/CD workflows, on GitHub. Bash scripting plays a role in automating tasks because of its adaptability and wide range of command line tools that simplify activities like managing files, processing text monitoring systems and communicating over networks. These features ensure consistency. Minimize mistakes, making scripts reusable across different projects and setups. Bash scripts easily blend with tools and languages creating a framework for diverse automation requirements while offering precise control over building and deploying procedures. The strong community support for Bash further enhances its usefulness for developers.

On the contrary YAML is widely favored for its structure and ease of use making it an excellent option for configuration files. Its spacing based syntax helps to highlight connections between data elements reducing errors. YAMLs capability to represent data makes it well suited for configurations. By being declarative in nature YAML simplifies defining workflows by letting users specify desired states of step, by step procedures; its flexibility supports data types enabling extensive and adaptable configurations

YAML files text format is great, for version control making it easy to track changes and keep things consistent across stages like development, testing and production. When you combine Bash scripting with YAML configuration in GitHub it really boosts automation. Bash scripts are handy for running tasks from the command line like managing files, monitoring systems and deploying processes. YAMLs structured syntax makes it perfect for defining these workflows. By using both you get scripting abilities through Bash while YAML helps organize and sequence these scripts into manageable workflows. This collaboration ensures CI/CD processes that’re efficient, reliable and easy to maintain by leveraging the strengths of both tools to automate tasks and minimize manual work.

In the example below of a GitHub Actions workflow step, YAML and Bash scripting work together to set up environment variables dynamically based on user inputs-showcasing a strategy, for managing CI/CD environments.

YAML

Used for defining the workflow structure, YAML organizes the sequence of steps and the execution of scripts. It specifies each operation clearly, enhancing the workflow’s readability and maintenance.

Figure 1: An Example of a Step in a YAML Configuration

Bash Scripting

Within the YAML configuration, Bash commands are executed to manage environment variables:

• Variable Export: Using echo, user inputs for browser and alm build version are appended to GITHUB ENV, ensuring their availability across the
• Data Extraction: The cut command processes property file input to extract a key segment, which is then exported as an environment variable.

Final Step

Steps Involved in Designing and Implementing Workflows Name (Blue Section) Description: Specifies the name of the workflow, “Simple Workflow”. This is a human-readable identifier used primarily for display and logging purposes within GitHub Actions.Trigger Events (Yellow Section) Description: Defines when the workflow will be triggered to run.

• Workflow dispatch: Allows the workflow to be manually triggered via the GitHub UI or API and includes ¡ i n p u t parameters¿ which are placeholders for future custom
• Push: Specifies that the workflow should execute automatically on any push events to the main branch, ensuring that changes to this branch are automatically processed.

Jobs (Orange Section) Description: Contains definitions of jobs to be performed.

• build: A job named “Build”, which includes the tasks needed to compile or test the code.
• runs-on: Designates the virtual environment (ubuntu- latest) where this job will be executed, selecting the latest version of Ubuntu available in GitHub’s virtual         

Figure 2: A Series of BASH Commands within a YAML Configuration

Figure 3: An integration of YAML and BASH Scripting

Steps (Green Section) Description: Enumerates the steps that will be executed as part of the ”Build” job. Each step consists of tasks performed using YAML configuration and potentially Bash commands.

YAML Usage: Step Configuration: YAML is used to define each step with structured commands. For example:

• Name: Checkout code: Defines a step named ”Checkout code”.
• Uses: actions/checkout@v2: Specifies using the checkout action to clone the repository’s This line is purely YAML configuring the use of a predefined GitHub Action.

Figure 4: Structure of a YAML Workflow

• Action Configuration: Each step can use third-party actions or custom scripts defined inline, all configured using YAML

Bash Usage: Command Execution

• name: Print Hello: Defines a step named ”Print Hello”.
• run: echo ”Hello, world!”: Executes a Bash command. Here, run: specifies that the following string is a shell command to be The echo ”Hello, world!” is a simple Bash command that prints ”Hello, world!” to the console. This demonstrates the use of Bash within a YAML-defined workflow structure, leveraging the simplicity of Bash scripting to perform tasks.

Figure 5: Example of a GitHub Actions workflow script, illustrating code checkout and a basic ”Hello, World!” command

This structured approach demonstrates the seamless integration of YAML and Bash in configuring and executing GitHub Actions workflows. YAML serves as the backbone, defining workflow components and orchestrating the sequence of operations, while Bash scripts are embedded within this framework to perform specific tasks. This combination harnesses the clarity and organizational power of YAML with the operational flexibility of Bash scripting. Together, they enable developers to automate complex software development processes effectively, from code checkout to custom script execution, all within a controlled, containerized environment. This highlights not only the versatility but also the efficiency of GitHub Actions in managing sophisticated workflows.

Case Studies or Examples of Workflow Implementations Example 1: Integrating YAML and Bash for Automated Software Testing Workflows in GitHub Actions.

In this GitHub Actions workflow, the interplay between YAML and Bash scripting creates a sophisticated automation sequence, designed to streamline software testing and deployment processes. The following summary provides a detailed explanation for each section, highlighting the utilization of YAML and Bash:

Workflow Definition (YAML Usage):

• Name and Trigger: The workflow is named ”Run @ RegressionSuiteESD” and triggers on manual dispatch with input parameters (browser and property file), allowing users to specify the environment and browser for test executions. YAML’s role here is to configure the triggers and input parameters precisely, setting the conditions under which the workflow will
• Jobs and Environment Setup: The build job runs on a self- hosted AWS Lambda environment, defined in YAML with a specific ARN, showing YAML’s capability to finely tune the execution environment. The job also defines permissions for various GitHub resources, under-scoring YAML’s utility in managing security and access control within the

Task Execution (Bash and YAML Integration)

• Environment Variable Management: Bash is heavily utilized to dynamically manage environment variables. For example, extracting parts of the property file input to set as an environment variable demonstrates Bash’s strength in text manipulation and environment configuration within the YAML-defined workflow
• Dependency Installation and Setup: The steps to install JDK, Maven, and setup other tools like Docker showcase Bash’s role in performing system-level operations such as package management and system YAML schedules these Bash commands in a sequence, ensuring that each tool is ready before proceeding to the next steps.
• Build and Test Execution: Bash commands are used to execute build processes with Maven and Gradle, and to manage Docker operations for running Selenium This illustrates Bash’s capability to handle complex YAML’s ability to integrate with GitHub’s ecosystem to manage artifacts.
• Cleanup: Final steps involve teardown commands in Bash to stop and remove Docker containers and clean up the environment, ensuring no residual data impacts subsequent YAML organizes these cleanup commands efficiently, maintaining the workflow’s integrity and resource management.

Listing 1: A Sample Github Actions Workflow

Example 2: Advanced Bash Scripting and YAML Integration for Automated Software Testing. In this example, we demonstrate the use of advanced Bash scripting integrated within a YAML- defined GitHub Actions workflow. This example highlights how more complex logic, and conditional operations can be managed using Bash scripts to enhance the automation of software testing processes.

Workflow Step Overview

This step is designed to set a version as an environment variable in the test repository. It includes conditional logic to determine the appropriate image tag based on the stage and input parameters. The use of both YAML and Bash scripting enables a flexible and powerful approach to managing environment configurations and ensuring accurate versioning for automated tests.

YAML Configuration

• Step Definition: This step is defined in YAML, specifying the task’s name and including a condition (if: stop workflow!= ’true’) that determines whether the step should run based on the environment variable stop workflow.
• Run Command: The run: key indicates that the following block contains a series of Bash commands to be executed.

Bash Scripting

Conditional Logic: The Bash script begins with a conditional statement that checks if the stage input is staging and the image tag input is latest. If both conditions are met, it retrieves the latest image tag from AWS ECR using the AWS CLI and jq for JSON parsing.

• Version Extraction: The aws ecr describe-images command fetches image details, and jq filters and extracts the relevant image The sed command is used to ensure the tag matches a version pattern (X.Y.Z).
• Fallback Logic: If the conditions are not met, it uses the provided image tag input
• Environment Variable Setting: The resulting im- age tag is echoed into the $GITHUB_ENV file, setting ALM BUILD VERSION as an environment variable for use in subsequent steps.
• Logging: The script logs the input tag value and the determined build version for transparency and debugging

This example illustrates the combined use of YAML for workflow orchestration and Bash for executing complex, conditional logic within GitHub Actions. By leveraging these tools together, developers can create highly flexible and powerful workflows that adapt to different testing environments and input parameters, ensuring accurate and efficient automated software testing processes. This approach not only enhances the automation capabilities but also improves the reliability and maintainability of CI/CD pipelines.

Figure 6: An Example PNG Image

Results and Discussions

Presentation of Findings from the Case Studies or Examples Example 1: Basic Integration of YAML and Bash for Automated Software Testing In this case study, we implemented a GitHub Actions workflow to automate tasks such as code checkout, environment setup, and test execution [2]. The integration of YAML and Bash highlighted the following:

• Efficiency: YAML structured the workflow, while Bash executed specific commands, leading to a streamlined setup and execution process.
• Clarity and Maintainability: The separation of YAML for configuration and Bash for execution ensured a clear and maintainable
• Flexibility: The workflow was adaptable to different environments and requirements through simple modifications to YAML and Bash components.

This example demonstrated that even basic integration of YAML and Bash is effective for automating routine tasks in software testing.

Example 2: Advanced Bash Scripting and YAML Integration for Automated Software Testing

The second case study explored a more complex GitHub Actions workflow, featuring advanced Bash scripting within a YAML framework [1]. Key findings include:

• Conditional Logic Handling: Advanced Bash scripting enabled sophisticated conditional logic, dynamically adjusting the workflow based on input parameters.
• Enhanced Automation Capabilities: The combination facilitated the automation of complex tasks, such as retrieving and setting environment variables from AWS ECR.
• Robust and Adaptable Workflows: The workflow was highly adaptable and robust, capable of handling varying conditions and requirements effectively.

This example showed that advanced integration of YAML and Bash scripting provides powerful tools for managing and automating complex software testing processes

Overall Findings Across both examples, the integration of YAML for workflow definitions and Bash for command execution proved to be a versatile and powerful approach. Key takeaways are:

• YAML: Offers a clear and organized method for defining workflow structures and sequences.
• Bash: Enables detailed, condition-based command execution, enhancing flexibility and
• Combination: Facilitates the creation of efficient, maintainable, and adaptable automation workflows, crucial for modern software development and testing.

These case studies underscore the effectiveness of using YAML and Bash together in GitHub Actions workflows to achieve robust and efficient automation in software testing environments.

Quantitative Impact of Bash and YAML Integration on CI/ CD Pipeline Efficiency

• Efficiency Improvements: A study found that implementing a pipeline approach in CI/CD improved project efficiency by streamlining delivery timelines, reducing test load steps, and enhancing benchmarking tasks. This led to faster and more reliable software delivery [6].
• Error Reduction: Introducing CI/CD pipelines significantly reduced failed deployments, improved stability, and increased the number of executed deployments in database application projects, thus demonstrating error reduction and improved reliability [7].
• Development Speed: Research on CI/CD in open-source repositories showed that CI/CD adoption enhanced commit velocity by 141.19%, though it also increased the number of issues by 21%, suggesting a trade-off between speed and issue frequency [8].

The integration of Bash and YAML in workflow automation for CI/CD pipelines enhances efficiency by streamlining processes and improving delivery timelines. It significantly reduces errors, leading to more reliable deployments and improved stability [9]. Furthermore, it accelerates development speed, though it may require careful management to avoid an increase in issues [10].

Best Practices

Recommendations for Modular Scripting in GitHub Workflow File

• Job Segmentation: Divide workflows into tasks like building, testing and deploying with each task relying on specific Bash scripts for related activities.
• Step Modularity: Split tasks into steps where individual Bash commands or scripts are executed, allowing for control and management.
• Reusable Workflows: Develop workflows or steps that use Bash scripts to encourage code sharing and ensure uniformity across multiple workflows.
• Parameterization: Use inputs and environment variables to tailor the execution of Bash scripts enabling workflows to adapt to scenarios without altering the script itself [1].

By following these practices you can make sure that the Bash scripts used in GitHub Actions are modular easy to maintain and flexible ultimately improving the efficiency of the CI/CD processes [11].

Guidelines for Writing Maintainable YAML Files

Writing maintainable YAML files for GitHub Actions involves clarity and organization:

• Descriptive Naming: Opt for names when defining jobs, steps and other components so their purpose is evident, without delving into specifics.
• Use Comments: Add comments generously to explain the purpose of less obvious configurations, which can help future maintainers understand the code
• Consistent Formatting: Maintain formatting practices, such, as indentation and spacing to prevent errors and make the code more readable.
• Anchors and Aliases: Make use of YAML features like anchors and aliases to avoid repetition and keep configurations

Security Best Practices for GitHub Workflows

Ensuring security within GitHub Actions workflows is crucial for protecting code integrity and sensitive data:

• Least Privilege Access: Set up jobs and steps with the necessary permissions to minimize security
• Use Secrets: Keep sensitive data like API keys and credentials secure by storing them in GitHub Secrets and referencing them in workflows.
• Secure Actions: Use actions from sources to prevent vulnerabilities, in your CI/CD pipeline.
• Regular Audits: Review and update your workflows periodically to align with current security standards and address any potential weaknesses.

These practices ensure that Bash scripts integrated into GitHub Actions are modular, maintainable, and adaptable, enhancing the overall effectiveness and efficiency of the CI/CD processes.

Conclusion

Summary of Findings

Our analysis revealed that, By implementing these measures one can ensure that Bash scripts seamlessly integrated into GitHub Actions remain modular easy to maintain and adaptable. This enhances the efficiency of your CI/CD processes. In conclusion our analysis uncovered insights, about using scripting in GitHub workflows highlighting the significance of organization, reusability and adaptability. We found that dividing tasks into segments and creating steps can greatly enhance the manageability of workflows. Moreover utilizing workflows and parameterizing Bash scripts within GitHub Actions showed enhancements in workflow efficiency and flexibility.

Implications for Practice

The identified practices have implications for improving the development and management of CI/CD pipelines in software engineering. Embracing scripting with Bash in GitHub Actions can result in resilient and error tolerant workflows, simplify updates and maintenance procedures and reduce the time and resources invested in managing pipelines. Organizations can adopt these strategies to enhance the scalability of their automation processes and respond effectively to evolving needs.

Suggestions for Future Research

Future research could explore the integration of advanced artificial intelligence and machine learning algorithms to further automate and optimize the selection and configuration of modular scripts in GitHub workflows. Additionally conducting studies to evaluate the impact of modular versus scripting approaches across different software development environments could offer deeper insights, into effective practices for configuring CI/CD pipeline setups.

Exploring the security implications of using scripting, in GitHub workflows may offer insights, for improving security protocols in automated processes.

References

1. Saroar SG, Nayebi M (2023) Developers’ Perception of GitHub Actions: A Survey Analysis. Proceedings of the 27th International Conference on Evaluation and Assessment in Software Engineering https://api.semanticscholar.org/ CorpusID:257378378
2. Chen T, Zhang Y, Chen S, Wang T, Wu Y (2021) Let’s Supercharge the Workflows: An Empirical Study of GitHub IEEE 21st International Conference on Software Quality, Reliability and Security Companion (QRS-C) 1-10.
3. Decan A, Mens T, Mazrae PR, Golzadeh M (2022) On the Use of GitHub Actions in Software Development Repositories. IEEE International Conference on Software Maintenance and Evolution (ICSME) 235-245.
4. Wessel MS, Vargovich J, Gerosa MA, Treude C (2022) GitHub Actions: The Impact on the Pull Request Process. Empirical Software Engineering 28: 1-35, 2022.
5. Valenzuela-Toledo P, Bergel A (2022) Evolution of GitHub Action IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER) 123-127.
6. Donca IC,Stan OP, Misaros M, Gota DI, Miclea LB (2022) Method for Continuous Integration and Deployment Using a Pipeline Generator for Agile Software Projects. Sensors (Basel, Switzerland)
7. Fluri J, Fornari F, Pustulka E (2023) Measuring the Bene- fits of CI/CD Practices for Database Application IEEE/ACM International Conference on Software and System Processes (ICSSP) 46-57.
8. Fairbanks J, Tharigonda A, Eisty NU (2023) Analyzing the Effects of CI/CD on Open Source Repositories in GitHub and IEEE/ACIS 21st International Conference on Software Engineering Research Management and Applications (SERA) 176-181.
9. Kinsman T, Wessel MS, Gerosa MA, Treude C (2021) How Do Software Developers Use GitHub Actions to Automate Their Work- flows? IEEE/ACM 18th International Conference on Mining Software Repositories (MSR) 420-431.
10. Benedetti G, Verderame L, Merlo A (2022) Automatic Security Assessment of GitHub Actions Workflows. Proceedings of the 2022 ACM Workshop on Software Supply Chain Offensive Research and Ecosystem Defenses https://api. org/CorpusID:251402382.
11. Golzadeh M, Decan A, Mens T (2022) On the rise and fall of CI services in IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER) 662-672.

View PDF

Our Pubmed Indexed Articles

---

---

---