Teamscale analyses every commit and provides results within seconds after each commit. This fast feedback loop enables efficient development workflows, which are not possible using typical batch analysis tools.
Custom dashboards provide a quick overview of the current quality status. Every developer can configure private dashboards or share them with the team. Teamscale provides a wide range of visualizations, including metric values, trends, tables, charts, and tree maps.
Compare the actual dependencies in your source code with your intended architecture. Provide guidance to your developers by tracking architecture violations in real-time.
Validate that your coding conventions are followed. Teamscale comes with common rules preconfigured, but lets you configure them to suit your individual requirements.
Automatically find duplicated code created by copy & paste. View existing clones to prevent bugs from inconsistent modification of duplicate source code.
Check if your code is fully documented. Documentation requirements are easily configurable; for example only require documentation of public methods that are not a simple getter/setter. You can also detect empty or trivial interface comments.
Find hotspots of badly structured code. All thresholds can be configured to fit your project's individual guidelines.
Code changes are a reliable predictor for error proneness. Test Gap analysis makes changes and testing activities transparent. This allows you to avoid getting untested changes in production.
Teamscale provides a REST API for uploading findings and metrics from external sources. These are treated just like the results from Teamscale's own analyses.
Teamscale comes with a flexible language for implementing custom project-specific checks.
Compare any two points of development to see how your system's quality has changed. Define iteration and release dates for easy visualization and comparison.
Visualize how metrics changed during the entire development phase. Zoom into areas of interest and easily discover the root-cause for unexpected changes in a metric's trend.
Teamscale is not only able to analyze your system's entire history. It also knows about branches in your version control system and respects them during analysis.
Teamscale's analyses work on a wide variety of programming languages used today. Detecting clones, deep nesting, long methods and files is included for all languages. Additionally many specialized checks are included, tailored to detect quality problems in specific languages. We support:
Contact us! New languages are added frequently and your language might already be supported.
Teamscale reads the code directly from your source code repository and lets you know about quality defects right away.
To link commits to change requests, Teamscale can integrate with your issue tracker.
To manage permissions in Teamscale, you can use your existing authentication infrastructure.
Be notified of quality issues, perform baselining and blacklisting, and review clones side-by-side right in your IDE.
You don’t have to leave your IDE anymore to stay informed about guideline violations and code clones.
Teamscale integrates with the entire IntelliJ family of IDEs, PhpStorm, PyCharm and WebStorm.
Contact us! Teamscale is easily extendable to new programming languages, new version control systems, new issue trackers or external analysis tools.
Many tools measure, what is easy to measure and try to offer as many metrics as possible. For many of these metrics, including the infamous cyclomatic complexity, their interpretation in terms of software quality is vague at best. We feel that in most cases a finding pointing the developer to the problem in the code is more effective. We only measure few basic metrics about code structure, clone and findings density, and commenting, that help to get an overview of the entire code base.
Teamscale provides a well-documented REST API, which allows access to all of the data in Teamscale. This API is also used by the Web UI and the IDE plugins.
Teamscale does not directly execute your tests and calculate your coverage. However, we can import test coverage results from the most common coverage tools during your continuous integration builds. Coverage data can then be displayed both as overall metrics and overlaid over your code to see where quality issues and untested code meet each other.
Cyclic dependencies themselves are not necessarily a quality problem. What we are interested in instead, is whether the code follows the design as intended by its architects. For this, Teamscale allows you to model the intended architecture of your system and compare the actual dependencies in the code against it. Teamscale is also a great tool for visualizing existing dependencies in your code.
Yes. Teamscale provides a simple mechanism to describe custom checks that are executed incrementally during the analysis. If you don't want to do the coding yourself, we are happy to assist you in implementing checks for your custom rules.