Do not wait for production to assess performance changes.
Try calcite!
The calcite solution emerged from our customers requirements, as well as obstacles we faced while developing performance oriented applications.
At a big scale, the speed of your application can have a direct impact on your revenue.
For example:
When the needs of your application increase, you have two options:
But sometimes, you do not own or cannot upgrade the machines where the application runs.
Your code MUST fit the performance requirements.
Monitoring comes late in the development cycle of your application and can be expensive.
Even if companies can afford canary deployments to test new features, the iteration time is still a significant cost.
By shifting part of performance investigation and tracking into your automated continuous integration, our solution helps you reduce iteration time and catch performance issues early, before it reaches your users.
People working on your project might be new to the team, come from different backgrounds or simply not sensitive to performance issues and goals. We know that teaching and sharing about performance is not an easy task, and we believe standards are key to solving this issue.
That is why we think tooling is important.
With calcite, you have a common methodology and reference with the rest of your team.
And by being integrated with your CI, all users know about the potential performance impact of their changes.
Unlike unit tests, performance regression testing does not result in a boolean property.
Running the same performance benchmark will yield different results for each run.
By leveraging state of the art statistical analysis, we limit the number of false positives.
We also provide more insight about the performance characteristics of your code than usual tools.
From data to alerts, stay informed.
You can directly connect your favorite CI provider with calcite to store your performance data.
We already support most of them (Github, Gitlab, CircleCI, AppVeyor, Azure DevOps...).
Detecting anomalies in large timeseries, especially with performance tests, is not a easy thing.
With calcite, we adapt well-proven technology with a focus on performance.
Our goal?
You do not have to be an expert in statistics to do a correct performance analyis!
calcite is integrated with your favorite Git Provider (Github, Gitlab, CircleCI, AppVeyor, Azure DevOps...).
Detected anomalies will be reported directly in your pull requests!
Do you prefer a direct message?
Feel free to connect calcite with your Slack, E-Mail or SMS!
More than a tool, calcite is also methodology that keeps performance at the heart of your development cycle.
calcite is a Software as a Service, augmented with a supercharged command-line interface.
To make integration easier, we have a dedicated tool.
With a single configuration file in your project extract data from your performance reports.
To make your life easier, we already have configuration files for a lot of report formats! (JMeter, Gatling, Google benchmark...)
And then?
With only one command, let’s rock and upload data!
Do you want more than a simple table in the console? Give our dynamic web application a try!
With it, feel free to dive deep in your performance data. We provide lot of cool utilities to explore, compare and analyze it.
Finding performance regressions and correlations in your source code has never been easier.
The web application is also the best place to configure your workflows and to share performance reports with your team or client!
We are currently running a closed alpha.
Contact us to talk about your project and give our solution a try!
Today, calcite can already be used in a large panel of performance testing cases.
Embedded systems have hard constraints with regard to performance, up to real-time requirements.
Not only do you need to go fast, you also need to deal with the limited resources available.
By putting performance at the heart of your development cycle, you can ensure that you will not go over budget and that new versions of your application can still run on already deployed hardware.
In the world of AWS Lambda, Azure Functions, Google Cloud Functions,
you pay for the time and memory your program takes.
With calcite, make sure that your server costs stay under the thresholds!
Users usually want a Video game on PC to run at 60 images per second. It means your main loop must be less than 16ms.
If you go overbudget a single time, the user will notice the glitch and it will throw him out of the experience.
calcite can help you detect performance regressions as well as changes in stability of the framerate!
