Semaphore CI/CD Learning

Continuous Integration

Build and test my software continuously.

Prerequisites 🗒️

An account on a VCS provider such as Github or Bitbucket
An account on a CI/CD platform such as Semaphore

Obtain reproducible builds

Enforce a unified code style and identify potential errors.

Reduce errors in application

Mitigate chances of security issues

Speed up pipeline to obtain faster feedback

Test performance or capacity of the application

Reduce merge conflicts

View:

Select your goals to show the recommended skills here

Version Control SystemColaborate on codeA version control system (VCS) allows developers to store, retrieve, review and collaborate on code.
The most popular VCS system is Git. Check out their tutorial to get started.
Next, you need a place to store your code such as GitHub or Bitbucket. Sign up for free on one of these Git service providers, create a repository and push your code.
Learn more:
Getting started guide
Connecting your GitHub account and Semaphore
Connecting your Bitbucket account and Semaphore
CI ConfigurationSet up your continuous integration jobsLearn how to configure your CI/CD platform of choice, such as Semaphore, to build, test and deploy your project.
For more details:
check our Getting Started Guide.
Build automationBuild aplication in a clean environmentA build script or tool like Maven or Make downloads dependencies and compiles or builds the artifact, which can be started to run the application or install the library.
The benefit of this approach is two-fold:
The application is built in a standardized environment, bypassing the “works in my machine” syndrome.
You get notified the moment a change breaks the build, making it easier to identify and troubleshoot the problem.
The build step must be completely automated without human intervention.
Learn more:
Design an Effective Build Stage for Continuous Integration
Reproducible Node Builds With npm ci
The 6 Principles of Test Automation
Static testingAnalyze quality, find code smellsStatic tests scan the code for potential problems and offer recommendations. Static test tools, called linters, can pick up antipatterns, identify security risks, or enforce style guidelines.
Learn more: 
20 Types of Tests Every Developer Should Know
Sample project: 
  semaphore-demo-javascript
Functional testingAnalyse code for common errorsTests verify that the code does what is expected. There are several types of tests. The most common types are:
Unit tests: a unit is a function, class, or method. Unit test checks that it behaves as expected. This is the most granular type of test there is.
Integration tests: these test check that different components interact correctly. For example, an integration test can check if a Model in an MVC application correctly interfaces with the database.
End-to-end tests: these tests check the application from the user perspective. Usually, it involves clicking buttons, filling out forms, and ensuring the application behaves correctly.
Learn more:
20 Types of Tests Every Developer Should Know
The Testing Pyramid: How to Structure Your Test Suite
Example project: 
semaphore-demo-go
Testing frameworksMaster the testing frameworks for your languagesTesting frameworks, while not mandatory, facilitate and systematize testing. Every language and framework typically includes some testing framework. These tools find the test code, execute it, and collect the results.
Examples of testing frameworks are Jest, Mocha, JUnit, NUnit, Selenium, and Cypress. Every language comes with its own set of frameworks.
Learn more:
Getting Started with Node.js and Mocha
Stubbing and Mocking with Mockito and JUnit
Example project:
semaphore-demo-javascript
Non-functional testingImprove quality and performanceNon-functional tests check for things like code quality, performance, and capacity. Invite testers and QA analysts to design these tests.
Learn more:
20 Types of Tests Every Developer Should Know
Example project:
semaphore-demo-java-spring
Information SecuritySecure the codebaseSecurity testing checks that the code and dependencies don’t have critical vulnerabilities. Invite the InfoSec team early in this process to design the tests and audit the code.
Learn more:
Improving Security in Your CI/CD Pipeline
Automatic Security Testing of Rails Applications Using Brakeman
Elixir Code Security: Prioritize Security in Your CI With 4 Tools
Continuous Container Vulnerability Testing with Trivy
3 Pillars to Maximizing Security Potential in Complex Cloud Environments
Example project: 
semaphore-demo-php-laravel
Reduce merge conflictsStreamline developmentMerge conflicts tend to happen when developers use long-lived branches to work on features or fixes. The problem with this approach is that the longer a branch lives, the higher the chance of creating a conflict when trying to merge it to the main trunk.
The best way of reducing the chance of merge conflicts is to adopt trunk based development, a technique in which developers use short-lived branches (or no branches at all). An engineer using trunk-based development will merge to the main trunk multiple times per day — this makes it very unlikely that a merge conflict will take place.
Note that the State of DevOps Report 2022 warns that trunk-based development works best on experienced (+16 years) teams. Evidence shows that it can increase errors and decrease delivery performance on less-experienced teams.
Other essential practices that will improve productivity once mastered are:
Test-Driven Development
Behavior-Driven Development
Pair or mob programming
ParallelizationSpeed up CI timeIn order to take full advantage of continuous integration, you can parallelize long-running tasks. Parallelization let us distribute the load among various servers, reducing the overall time of the workflow.
Read more: 
Revving up Continuous Integration with Parallel Testing
Detect slow and flaky testsFind bottlenecks in CI performanceBuild once and test multiple times in order to keep the pipeline fast and maintain a short feedback cycle.
The main causes for slowness are:
Slow tests: test that take long to run can add up. It’s important to periodically identify slow jobs and take correction actions to keep the pipeline in top shape.
Flaky tests: tests that fail intermitently without any apparent reason.
Read more:
5-Step Strategy for Optimizing Slow Tests
9 Ways To Make Slow Tests Faster
How to Find and Eliminate Flaky Tests

Select your goals to view the suggested pipeline here

Semaphore CI/CD Learning

Continuous Integration

🎯 What are your goals?Select your goals to build the pipeline and show the recommended skills to learn

📋 Learning trackLearning track shows you the the skills required to make the most out of your CI/CD platform.

Select your goals to show the recommended skills here

Version Control System

Colaborate on code

CI Configuration

Set up your continuous integration jobs

Build automation

Build aplication in a clean environment

Static testing

Analyze quality, find code smells

Functional testing

Analyse code for common errors

Testing frameworks

Master the testing frameworks for your languages

Non-functional testing

Improve quality and performance

Information Security

Secure the codebase

Reduce merge conflicts

Streamline development

Parallelization

Speed up CI time

Detect slow and flaky tests

Find bottlenecks in CI performance

🏗️ Suggested CI pipelineThis is a continuous integration (CI) pipelines. Pipelines automate tasks like building, testing and deploying your application. A CI/CD platform plugs into your repository and runs tasks on your code every time it changes.