Skip to content
Advent of Open Source

Day 9: The Flow of Unbroken Progress

The Engine of Endurance

The Keeper of the Repos leads you deep into the heart of the village, where the towering Clocktower of Continuity casts its long shadow over a vast cavern. Here, at the center of the cavern, hums the powerful Engine of Endurance, a great machine that has fueled the village’s progress for generations. Its gears turn without pause, ensuring that every step forward is a step toward harmony and success.

But the Disruptors of Dissonance are always lurking in the dark, waiting for a moment of weakness to slip in and bring chaos. They seek to unravel your work by sowing confusion and mistakes in the very foundations of your progress.

The Keeper speaks with resolve:

With every piece you add to the puzzle, it is vital that each one fits perfectly with the others. The Engine will guide your way, ensuring that no change is lost or misaligned, so that your project remains in steady motion, never faltering.

The cavern echoes with the sound of the Engine’s steady roar, inviting you to join its rhythm and become a part of its seamless flow.

Choose the rune that best suits your skills and experience:

If you’re joining the village today, you can always catch up on the instructions from Day 1 to get up to speed.

Beginner: Add Your First Automation Action

Snowflake rune
Beginner level for folks starting a new artifact

The path ahead is clear but full of potential missteps. You find yourself standing before the great Engine of Endurance, its vast, rhythmic motions a reminder of the importance of every small effort. The Keeper of the Repos stands by, watching with calm confidence.

Every journey requires a steady rhythm, and every effort must be in sync with the others,

they say.

The Engine will help you keep the flow unbroken, guiding you to success with each step.

As you look closer, you see that the Engine isn’t just about motion; it is about precision and unity, working together to create something greater than the sum of its parts.

Your task is to begin setting the Engine into motion. Your first step is to ensure that every action contributes to the harmony of the whole.

The Keeper gestures to the machinery before you, inviting you to make your mark.

Automation has become an essential practice in modern software development. It helps reduce repetitive tasks, minimizes human errors, and ensures a consistent workflow across projects. Tools like GitHub Actions, GitLab CI/CD Pipelines, and Bitbucket Pipelines enable teams to integrate automation into their development processes effortlessly. Whether you’re automating code testing, deployment, or routine checks, these tools provide a foundation for Continuous Integration (CI) and Continuous Deployment (CD).

Today’s challenge introduces you to GitHub Actions, a powerful feature for automating workflows directly within GitHub repositories. By setting up a simple spell-checking workflow for your README file, you’ll gain hands-on experience with automation, understand how workflows operate, and prepare your repository for more advanced tasks.

Let’s get started!

  1. Create a workflow file.

    To begin, you’ll need a configuration file to define your workflow.

    Navigate to your repository on GitHub and create a new file named .github/workflows/ci.yml from the GitHub interface.

  2. Add a pre-built action.

    For this challenge, we’ll use the cspell-action from the GitHub Marketplace.

    1. Visit the cspell-action marketplace page to learn more about its capabilities.

    2. Click on the Use latest version button. This provides the configuration snippet for the action.

    3. Paste this snippet into a basic workflow structure in your ci.yml file:

      .github/workflows/ci.yml
      name: 'Check spelling'
      on:
        push:
      

      jobs:
        spellcheck:
          runs-on: ubuntu-latest
          steps:
            - uses: actions/checkout@v4
            - uses: streetsidesoftware/cspell-action@v6

      What does this do?

      • The on: push trigger ensures the workflow runs every time you push changes to your repository.
      • The steps section defines actions to perform, starting with checking out your repository’s code, and then cspell-action to check for spelling errors.

  3. Commit and push the changes.

    Save the .github/workflows/ci.yml file and commit/push it to your repository with a chore: add GitHub Action for spell-checking. commit message.

  4. Monitor your workflow.

    1. After pushing your changes, navigate to the main page of your repository.

    2. Next to your latest commit, your should see an orange dot, indicating that the workflow is running.

    3. Click on the dot or navigate to the Actions tab in your repository to view workflow details.

      You can examine the logs for each step by clicking on the workflow’s details.

    4. Once the workflow completes successfully, a green checkmark will appear next to your commit.

      Congratulations! Your spell-check automation is live.

    5. If the workflow fails (you’ll see a red cross next to your commit), click to view the error logs.

      Address the issues mentioned in the logs and push the changes again to re-trigger the workflow.

By completing this challenge, you’ve taken the first step toward automating your development process. Here’s why this is a big win:

  • Consistency: Automation ensures that processes like spell-checking are consistently applied across all changes.
  • Efficiency: Spend less time on repetitive tasks and more on meaningful development.
  • Scalability: As your project grows, automation scales with it, helping maintain quality and stability.

Great job setting up your first GitHub Action! You’re now equipped to explore more advanced automation possibilities, such as running tests, deploying code, or generating reports. Keep experimenting and integrating workflows into your development process—you’re building skills that will save time and elevate your project’s quality.

Success Criteria

  • ✓ You’ve set up your first GitHub Action to check the spelling of your project’s files.
  • ✓ For each push to your repository, the spell-checking workflow runs, and a green checkmark confirms success.

With the hum of the Engine filling the air, you take a step back and watch as the machine begins to move with newfound purpose. The pieces fall into place, and you can feel the steady rhythm that will carry your project forward, no longer vulnerable to chaos or uncertainty.

Well done,

the Keeper says, their voice filled with quiet approval.

You have laid the first stone in what will be a path of constant, unyielding progress. The Engine now works alongside you, ensuring that your journey remains on course, no matter the obstacles ahead.

The Disruptors of Dissonance are now less of a threat, their power diminished by the steady march of the Engine as it turns relentlessly, ensuring every effort is counted and aligned. The flow is strong. The way forward is clear.

The Keeper’s Counsel

The flow of progress must never be interrupted. By embracing a continuous process, you ensure that every piece of your artifact fits perfectly into the greater whole, and the Engine of Endurance runs unbroken.

Step forward, traveller, and empower your artifact with the strength of seamless action. Return tomorrow to face new challenges as the Advent of Open Source continues to unfold.

Intermediate: Customize a Github Action for Your Project

Snowball rune
Intermediate level for folks wanting to enhance an existing artifact

The sound of the Engine of Endurance fills the air as the Keeper of the Repos steps forward, a knowing smile on their face. You are standing at the edge of a new frontier, where the gears of progress are within your reach, ready to be fine-tuned to match the needs of your journey.

To harness the true power of the Engine,

the Keeper says, their voice steady and inviting,

you must learn to shape it to your will. The Engine can move with precision, but it must follow the path you lay before it.

They gesture to a set of intricate controls nearby, each one connected to the Engine with glowing threads. You realize that, though the Engine has started, there is room for you to guide its rhythm even more effectively, to customize it for the unique path your artifact must follow.

Today, you’ll shape the flow of your work, ensuring it matches the heartbeat of your artifact and ensures smooth progress.

The Keeper nods toward the controls.

Adjust the controls and make the Engine work for you.

Automation in software development is all about making processes faster, more reliable, and tailored to your project’s needs. GitHub Actions is a versatile platform for creating workflows that can automate almost any part of your development lifecycle. However, the true power of GitHub Actions emerges when you go beyond using pre-built solutions and begin customizing workflows to meet the unique requirements of your project. By tailoring workflows, you can optimize tasks such as dependency management, cross-platform testing, and artifact management, ensuring your team operates more efficiently.

Today’s challenge focuses on customizing an existing GitHub Action workflow. By reviewing and improving an existing workflow in your repository, you’ll gain deeper insight into workflow configuration and automation. Customization can save time, reduce errors, and even positively impact your team’s productivity. This exercise will guide you to identify optimization opportunities, implement changes, and test their impact on your project’s efficiency.

  1. Review your current workflow.

    Locate a workflow file in your repository under the .github/workflows directory. Examples include CI pipelines for testing code, workflows for deploying your application, or any automation you’ve set up.

    Open the file and analyze its configuration to understand how it works. Look for potential areas of improvement, such as:

    • Are tasks taking too long to complete?
    • Could caching improve performance?
    • Are there opportunities to test across multiple configurations?

    For example, if you have a workflow that installs dependencies every time it runs, this might be a great place to add caching to speed up subsequent runs.

  2. Implement enhancements.

    Once you’ve identified areas for improvement, begin adding new features or optimizations to the workflow. Below are some ideas to inspire your enhancements:

    • Add dependency caching: Save time by caching frequently used resources like npm modules, Python packages, or compiled assets.
    • Enable matrix builds: Test across multiple operating systems or language versions by adding a matrix configuration.
    • Save build artifacts: Use actions like actions/upload-artifact to store binaries, logs, or other files for future steps or debugging.
    • Optimize steps: Combine or reorder steps to eliminate redundancies and improve workflow efficiency.
    • Eco-friendly practices: Limit unnecessary builds by refining triggers to only run workflows on relevant changes.

    You can explore the GitHub Actions documentation for more advanced features and customization options.

    Here’s an optimized workflow that caches npm modules, reducing execution time for subsequent runs:

    .github/workflows/ci.yml
    name: CI Pipeline
    on: push
    jobs:
      build:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v4
    

          - name: Cache node modules
            id: cache-npm
            uses: actions/cache@v3
            env:
              cache-name: cache-node-modules
            with:
              path: ~/.npm
              key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
              restore-keys: |
                ${{ runner.os }}-build-${{ env.cache-name }}-
                ${{ runner.os }}-build-
                ${{ runner.os }}-
    

          - if: ${{ steps.cache-npm.outputs.cache-hit != 'true' }}
            name: List the state of node modules
            continue-on-error: true
            run: npm list
    

          - name: Install dependencies
            run: npm install
    

          - name: Build
            run: npm run build
    

          - name: Test
            run: npm run test

  3. Test your workflow.

    After committing and pushing your updated workflow file, monitor its execution in the Actions tab of your repository. Verify that:

    • The workflow runs successfully.
    • Your enhancements (e.g., reduced runtime, new features) work as expected.
    • Any debugging tools or artifacts you’ve added are functioning properly.

    For example, if you’ve added dependency caching, observe the logs to confirm that the cache was restored and dependencies were not downloaded again.

By customizing a GitHub Action workflow, you have taken a significant step toward optimizing your project’s automation. These improvements not only save time but also enhance the efficiency and reliability of your development pipeline. Beyond the immediate benefits, this exercise builds your understanding of GitHub Actions, enabling you to create increasingly sophisticated workflows in the future.

Congratulations on enhancing your workflow! You’ve demonstrated the ability to identify inefficiencies, implement impactful changes, and test your solutions effectively. Keep experimenting with GitHub Actions to unlock even more possibilities for automation in your projects!

Success Criteria

  • ✓ Identified areas for improvement in an existing GitHub Action.
  • ✓ Enhanced the workflow with at least one optimization or feature.
  • ✓ Successfully ran the enhanced workflow on your repository.
  • ✓ (Optional) Explored tools like act or the GitHub Actions for VS Code extension to streamline development.

With a few careful adjustments, you watch as the Engine of Endurance responds to your changes, its motions becoming even more fluid and attuned to the rhythm of your artifact. The power that once felt distant is now in your hands, tailored to guide your work with ease and efficiency.

You have done well,

the Keeper of the Repos says, their tone rich with satisfaction.

You have personalized the Engine to your artifact’s needs, ensuring that every movement is as purposeful as it is precise. With this customization, you are ready to take on greater challenges, knowing that the flow of progress is always under your control.

The Disruptors of Dissonance have been pushed back even further, their influence waning in the face of your newfound control. The Engine now works with you, aligned to the unique path you’ve set, ensuring that your artifact advances with unwavering harmony. The way forward feels clearer, the rhythm more dependable.

The Keeper’s Counsel

The flow of progress must never be interrupted. By embracing a continuous process, you ensure that every piece of your artifact fits perfectly into the greater whole, and the Engine of Endurance runs unbroken.

Step forward, traveller, and empower your artifact with the strength of seamless action. Return tomorrow to face new challenges as the Advent of Open Source continues to unfold.

Advanced: Orchestrate Complex GitHub Workflows with Synchronization

Ice rune
Advanced level for folks wanting to enhance an existing large artifact or several org/personal artifacts

The air within the cavern hums with the vibrant energy of the Engine of Endurance, its great gears spinning in an intricate, mesmerizing dance. The Keeper of the Repos steps aside, and another figure emerges—a solitary traveller cloaked in robes woven with patterns of stars and streams.

Ah, a creator, I see,

the traveller muses, their voice like the echo of a distant waterfall.

The Engine is a wondrous tool, but true mastery lies in forging your own pieces to make it sing in harmony with your vision.

They open their hand, revealing a glimmering fragment of raw energy, pulsating and unformed.

This fragment is yours to shape. A new mechanism awaits—crafted not by tradition, but by your ingenuity. To wield the Engine’s full potential, you must build something uniquely yours.

With a sweep of their arm, they beckon you closer to a workstation shimmering with possibilities.

Seize this chance to leave your mark. Let your creation carry your project forward with strength and precision.

Automation in Open Source projects often involves not just individual workflows but the coordination of multiple interconnected pipelines. Large projects and organizations frequently require workflows to communicate across repositories or trigger external services, enabling a seamless flow of tasks. Synchronizing workflows through GitHub Actions and webhooks creates a dynamic system that enhances productivity, ensures efficiency, and opens the door to more complex automation possibilities.

Today’s challenge focuses on designing and implementing a multi-workflow pipeline that leverages GitHub Actions and webhooks. You’ll explore how to synchronize workflows, trigger external services, and build robust pipelines that handle complex dependencies. By completing this challenge, you’ll gain the skills to automate project management tasks, reduce manual errors, and optimize resource usage, all while expanding your expertise with GitHub’s powerful ecosystem.

  1. Analyze your workflow needs.

    Start by identifying areas in your repositories where workflow orchestration can provide significant benefits. Consider the following scenarios:

    • Do you have workflows across repositories that need to trigger each other? For example, a deployment workflow in Repository B that depends on a build workflow in Repository A.
    • Are there external services that can complement your workflows? For instance, notifying a Slack channel when a workflow succeeds or updating a database with deployment details.

    For example, imagine Repository A contains a build workflow for a shared library, and Repository B handles the deployment of an application using that library. Repository B’s deployment workflow should only begin when the build in Repository A completes successfully.

  2. Plan your workflow orchestration.

    Define the structure of your orchestration. Depending on your use case, you can:

  3. Implement and test your workflow orchestration.

    Use the following examples to guide your implementation:

    • Repostitory-to-repository trigger: Trigger Repository B’s workflow from Repository A using a repository_dispatch event.

      name: Trigger Another Repository's Workflow
      on: push
      jobs:
        trigger:
          runs-on: ubuntu-latest
          steps:
            - name: Trigger Repository B Workflow
              run: |
                curl -X POST \
                -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
                -H "Accept: application/vnd.github.v3+json" \
                https://api.github.com/repos/org/repo-b/dispatches \
                -d '{"event_type":"workflow-trigger"}'

    • Synchronizing internal workflows: Ensure Workflow B starts only after Workflow A completes using workflow_run.

      name: Dependent Workflow
      on:
        workflow_run:
          workflows: ["Workflow A"]
          types:
            - completed
      jobs:
        dependent-job:
          runs-on: ubuntu-latest
          steps:
            - name: Execute Dependent Task
              run: echo "Workflow A completed; now running Workflow B tasks."

    • External service integration: Send a webhook notification when a workflow finishes.

      name: Notify External System
      on: push
      jobs:
        notify:
          runs-on: ubuntu-latest
          steps:
            - name: Trigger Webhook
              run: |
                curl -X POST \
                -H "Content-Type: application/json" \
                -d '{"event":"deployment","status":"success"}' \
                https://your-service.com/webhook

  4. Expand and refine.

    Once your workflows are operational, consider enhancing their robustness and flexibility:

    • Error handling and retries: Add retry logic for tasks that may fail intermittently.
    • Data passing: Use outputs from one workflow to provide input to another, enabling more sophisticated interactions.
    • Security and flexibility: Utilize GitHub’s secrets for API keys, tokens, or other sensitive data, and environment variables for configurability.

    For example, to pass data between workflows, you could define outputs in Workflow A:

    Workflow A
    jobs:
      build:
        runs-on: ubuntu-latest
        outputs:
          artifact-version: ${{ steps.build-step.outputs.version }}
        steps:
          - id: build-step
            run: echo "::set-output name=version::1.0.0"

    Then, use it in Workflow B:

    Workflow B
    on:
      workflow_run:
        workflows: ["Workflow A"]
        types:
          - completed
    jobs:
      dependent-job:
        runs-on: ubuntu-latest
        steps:
          - name: Use Workflow A Output
            run: echo "Using artifact version: ${{ github.event.workflow_run.outputs.artifact-version }}"

By completing this challenge, you’ve explored how to orchestrate workflows using GitHub Actions and webhooks. You’ve learned to coordinate tasks across repositories, integrate external services, and refine your workflows for efficiency and robustness. These skills are invaluable for managing complex projects and optimizing your automation pipelines.

Congratulations! You’ve taken a big step towards mastering workflow orchestration. With your workflows now seamlessly interacting, you’re poised to unlock even greater productivity and scalability in your projects. Keep experimenting, and don’t forget to document your workflows to share your knowledge with others!

Success Criteria

  • ✓ Identified scenarios where synchronization or integration could benefit your projects.
  • ✓ Designed and implemented orchestration strategies using GitHub Actions and webhooks.
  • ✓ Successfully tested and verified the functionality of interconnected workflows.
  • ✓ Explored advanced techniques like error handling, data passing, and secure configurations.

The fragment you shaped now gleams with purpose, its edges smooth and polished, its inner energy alive with the rhythm of your design. You carefully place it within the Engine of Endurance, watching as it seamlessly integrates into the great machine. The entire cavern seems to shift, the Engine now pulsing with newfound energy, its movements imbued with your unique touch.

The cloaked traveller observes in silence, their expression unreadable. Then, with a nod of approval, they speak.

You have done what many fear to attempt—you have created something new, something singular. The Engine now moves to a cadence that you have set.

The traveller turns, their voice fading like the retreating tide.

With this act, you’ve not only enhanced the Engine but ensured that your work will carry the mark of your creativity. The Disruptors of Dissonance will find no weakness here, only strength born of innovation.

As they vanish into the shadows of the cavern, the Keeper of the Repos steps forward, pride gleaming in their eyes.

Your creation will stand as a testament to your skill and vision. Let it guide your artifact forward, ever steadfast.

The Keeper’s Counsel

The flow of progress must never be interrupted. By embracing a continuous process, you ensure that every piece of your artifact fits perfectly into the greater whole, and the Engine of Endurance runs unbroken.

Step forward, traveller, and empower your artifact with the strength of seamless action. Return tomorrow to face new challenges as the Advent of Open Source continues to unfold.