Development
tools
Development tools
Continuous integration (CI)
Code coverage
Code formatter
Static code analysis tools
Git hooks
What is CI?
Continuous Integration is a software development practice where members of a team integrate
their work frequently, usually each person integrates at least daily - leading to multiple
integrations per day. Each integration is verified by an automated build (including test) to detect
integration errors as quickly as possible.
- Martin Fowler
Good practices of CI
- Maintain a single source repository.
- Automate the Build
- Make the Build self-testing
- Everyone commits to the mainline every day
- Every commit should build the mainline on an integration machine
- Fix broken Builds immediately
- Keep the Build fast
- Test in a clone of the production environment
- Make it Easy for Anyone to Get the Latest Executable
- Everyone can see what's happening
- Automate Deployment (CD)
CI tools
Jenkins Travis CI TeamCity
Circle CI GitLab CI/CD Github Actions
What is code coverage?
Code coverage is a metric used to understand how much of the source code is tested.
How is code coverage
calculated?
- Function coverage
- Statement coverage
- Branches coverage
- Condition coverage
- Line coverage
Code format
All the code should have the same format:
- Indentation
- Spaces
- Lines breaks
- Comments style
- Etc.
Why?
It should be automatic.
Some code formatting tools
Java
- Google java format
https://github.com/google/google-java-format
JavaScript
- Prettier https://prettier.io
Scala
- Scalafmt https://scalameta.org/scalafmt/
Kotlin
- Klint https://ktlint.github.io
What is static code analysis ?
Static code analysis is a method of debugging by
examining source code before a program is run. It’s done
by analyzing a set of code against a set (or multiple sets) of
coding rules.
Static code analysis
tools
Multi language
- Sonarqube https://www.sonarqube.org
JavaScript
- ESlint https://eslint.org
Java
- Checkstyle https://checkstyle.org/checks.html
Kotlin
- Detekt https://detekt.dev
- Klint https://ktlint.github.io
Git hooks
Git hooks are scripts that run automatically every time a particular event occurs in a Git
repository. They let you customize Git’s internal behavior and trigger customizable actions at
key points in the development life cycle.
Some uses:
- Enforce the organization’s standard git conventions
- Check if commit messages fulfill a standard
- Check commit author’s
- Branch protection
- Run tests before committing
- Preprocess code before committing
- Run Build
References
- Continuous integration:
- https://www.martinfowler.com/articles/continuousIntegration.html
- Code coverage:
- https://www.atlassian.com/continuous-delivery/software-testing/code-coverage
- Static code analysis:
- https://www.perforce.com/blog/sca/what-static-analysis
- https://en.wikipedia.org/wiki/List_of_tools_for_static_code_analysis
- Git hooks:
- https://www.atlassian.com/git/tutorials/git-hooks
- https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks
