Coverity Reviews

We use this solution to scan our products. We've integrated with our build system and it automatically completes the scanning.

The ability to scan code gives us details of existing and potential vulnerabilities. What really matters for us is to ensure that we are able to catch vulnerabilities ahead of time.

When I put my code into Coverity for scanning, the code information of the product is in the system. The solution could be improved by providing a SBOM, a software bill of material. They could also integrate a software composition analysis scan. This would make my job a bit easier.

There is scope for Coverity to look beyond static analysis. Most of people that I have spoken to use Coverity from a pure static analysis perspective. However, we also need to be able to view dynamic pages and APIs using dynamic scanning and SES scans. Currently we would need to use another solution to be able to do this. 

I have been using this solution for 10 years.

This is a stable solution.

This is a scalable solution.

From a support perspective, they are pretty responsive. I would rate them a five out of five. 

The the last ten years, our company has derived value from using this solution. We continuously evaluate our tech stack and if a better solution came along, we would consider it if it provided more value. 

This is a pretty expensive solution. The overall value of the solution could be improved if the price was reduced. Licensing is done on an annual basis. 

There are other new tools like Veracode, Java Icon and Javascript which are better than Coverity when it comes to visualization. Their cost is significantly lower compared to Synopsys. 

Coverity is really good with CC+ and legacy technologies. However, there are other products that are probably as good or even better than Coverity when it comes to Java or cloud applications. 

If someone were to ask me what tool I would recommend, my answer would depend on what technology they're using and what their use case is. My advice would be based on how they're going to use the product and what they're expecting from the tool.

I would rate this solution an eight out of ten. 

We are using GK and the latest version for port deployment.

I have been using Coverity for three and a half years.

Coverity is not stable but it is sufficient for our organization's requirements.

Coverity is scalable.

We contacted technical support to help us clean up an issue we had.

If they have a cluster structure, then definitely they should use Coverity. I would rate Coverity a nine out of ten.

We use it in our company during product development.

It provides reports about a lot of potential defects.

Its price can be improved. Price is always an issue with Synopsys.

I have been using Coverity for about three or four years.

It has good stability.

Its scalability is good. 

They are professional and very responsible. They have a local FAE.

It is not straightforward, but it is also not too complex. The learning curve needed for installing Coverity is okay.

It is expensive.

I would recommend this solution if you can afford it. If you have enough budget, it is one of the best solutions right now. There may be other cheaper solutions, but you get what you pay for.

We have been using Coverity for several years. We would not have continued using it if it was not a good solution. We always have some minor questions or improvements for them, and they always give us a relatively fast response.

I would rate Coverity a nine out of ten. Only its price should be improved.

We have a development team and we are using this product for static code analysis.

This product has definitely helped our organization. Based on what I have heard from the development team, they have found a lot of issues before code goes into production.

The most valuable feature is the integration with Jenkins. Jenkins can be used to automatically run it to perform the code analysis.

Integration with GitLab is helpful.

Coverity is too costly, which is why we are trying other tools. Ideally, it would have a user-based license that does not have a restriction in the number of lines of code.

We have been using Coverity for between five and six years.

Coverity is used across our entire organization.

The initial setup in the Windows environment was straightforward. However, for Linux, it has some complexity.

We have a separate team in the company that takes care of deployment. One person is enough for the task

The licensing fees are based on the number of lines of code. We may not need more than five user licenses but with a restriction on the number of lines of code, for a small company the cost will shoot up.

Our license for Coverity has expired and we are in the process of exploring new static code analysis tools. Ideally, we would like to have one that is low-cost.

One of the products that I have downloaded a trial version for is SonarQube. At this point, I have only installed the Windows version but I plan on testing the Linux version, as well.

In summary, this is a helpful product and the feedback that I have heard from the development team is good.

I would rate this solution an eight out of ten.

We use Coverity during the software integration phase. We have a lot of components so we use Coverity to build the components, analyze and publish the data into sonar server and that's our work.

Depending on our product's needs, we defined the rule set to check and improve the source code.

The features I find most valuable is that our entire company can publish the analysis results into our central space. That allows us to see the latest quality of all components on the sonar web page.

My personal opinion is that the webpage of the last version of Coverity is not very easy to use. They've made some unnecessary changes and now I can't see all the analysis results or my status from when we started using the solution up to now. Because we have many components on the integration field, it is sometimes hard to find files of one specific component because we use relative path. When I look at the components, they all look very similar. But that is just my personal opinion.

I would also like to see a more user-friendly user interface and configuration. I can see the menu on the left but it's a little different from the other tools that I use, but this is perhaps only a personal thing. 

Coverity is a very stable solution.

I believe the solution is scalable. Sometimes I want to put one component in a certain project, and I need to find what's the best way for us. We have a lot of users using Coverity and we will adapt it into our program. 

Most of the time I just do some research myself and Google their webpage to see how I can find a solution for my problem. The program has a tools team to help find the solutions. 

My personal business used other tools that offered sonar language tracking. We used a mix of programs with specific options and some standard gcc options. But last year our team preferred to use more visual tools to follow the whole company's policy. That is why we chose Coverity.

We have an administrator for the deployment, so I am only a user. I just added a few projects and streams, and use the data extracted from the compilation, and run the analysis. The setup did take a long time, however.

We implement through an in-house tools team.

I don't care it so much.

For the setup, it's better to adapt the solution from the mature projects.

Don't care so much the pricing and licensing being the end user.

Before choosing, we tried to use gcc compiler options, i.e. 

EXT_GCOV_FLAGS='-fprofile-arcs -ftest-coverage'
EXT_GCOV_LDFLAGS=-fprofile-arcs
EXT_CC_FLAGS=-fdiagnostics-show-option
GCOV_LIB=-lgcov

I will suggest that when they use the program for a new project, they should just copy the data from a mature solution to the new project because the setup really takes a long time. We spent a lot of time to set Coverity up because I thought of creating the project in the Coverity server and use Coverity for the sonar part properly. But it took a long time. I will give the solution a 7.5 rating out of ten. When we officially use all the data, it will accumulate more experiences and then we will have different opinions.

We use the on-premise deployment model of this solution. Our primary use case of this solution is for auditing. 

The security analysis features are the most valuable features of this solution. 

The quality of the code needs improvement. They should develop a better code. 

The interface, efficiency, and the performance also need improvement as well as the languages that it offers. It should have more language options.

The user interface is not user-friendly.

It is stable. 

We have 30 users licensed for this solution. We use it when we need it. 

Their technical support isn't so good. That needs improvement. They don't address the problems I bring up. It's not a priority for them. 

We previously used an open-source solution before Coverity. 

The initial setup was easy. The solution is complex to use but not complex to deploy. 

We deployed the solution ourselves. 

Licensing is on a yearly basis. 

I would recommend this solution depending on the language you're using, Java and C++.

I would rate it a five out of ten. Not a ten because it's not efficient for the language we use. 

• Raising the level of code quality, security, and robustness in the codebase
• Tracking and addressing code quality issues.
  

Coverity provides developers with a good, best practice, coding advice, and tracks risks of poor coding quality. Coverity reports have urged developers to improve the quality of their code.

• I like that it gives advice and training on how to resolve the most common quality issues. 
• Links to more details on each issue and the background and risks.
  

• Ability to follow source file s-links into the target location for issuing assignments through GIT.  Our current build environment uses symbolic links into the git repo and Coverity does not follow the link into the actual location of the source file to determine the git author.
• Single API for all interactions. I am not a fan of using both SOAP and REST APIs and Coverity offers a mix of functionality depending on the interface used. I would greatly prefer a full REST API with improved documentation for all actions including issuing assignments, streaming, and project creation. 

I am using the latest version for my business. I personally do product evaluations, and this product has improved the efficiency of my work.

The product improves the way that we do product evaluations.

It improves the quality of my work. 

They could improve the usability. For example, how you set things up, even though it's straightforward, it could be still be easier.

The stability works quite well.

The scalability is good enough.

We haven't had any problems with the product so far.

We did not have another solution before. We decided to purchase Coverity because the way we were working previously wasn't efficient. So, we were trying to improve our efficiency.

The initial setup was straightforward.

We have seen ROI.

The solution has helped to increase staff productivity and improved our work significantly by approximately 20 percent.

This solution seemed to fit our purposes.

Try it out for yourself, and decide whether it's useful for you.