Software decides how much hardware runs on RETIT

RETIT presents „How accurate are current tools and models for estimating software energy consumption?“ at the EcoCompute Conference 2025

Thu, 06 Nov 2025 00:00:00 +0100

On November 14th, 2025 Prof. Dr. Andreas Brunnert will be presenting at the second EcoCompute Conference in Berlin. The topic of his presentation is „How accurate are current tools and models for estimating software energy consumption?“ – here is a short summary of the talk:

How accurate are current tools and models for estimating software energy consumption?

Evaluating the energy consumption of software is inherently complex, as software itself does not consume energy directly; rather, it is the hardware on which it runs that does. Over the past few years, numerous tools and models have emerged to estimate energy consumption at various levels, such as servers, processes, components, and transactions. When assessing the energy consumption of software, it is crucial to understand the accuracy of these tools and models. This session presents the findings of experimental evaluations that assess the precision of various tools and models for this purpose. We particularly focus on those that estimate energy consumption at the process, component, and transaction levels.

RETIT presents „How to measure CO2 emissions for every API call of your microservices“ at CloudLand 2025

Mon, 19 May 2025 00:00:00 +0200

On July 3rd, 2025 Prof. Dr. Andreas Brunnert will be presenting at the CloudLand Conference in Soltau (Germany). The topic of his presentation is „How to measure CO2 emissions for every API call of your microservices“ – here is a short summary of the talk:

How to measure CO2 emissions for every API call of your microservices

Have you ever wondered how much CO2 is emitted by a particular API call of your microservices? Then this talk is for you!

RETIT presents „Evaluating the Accuracy of Software Energy Consumption Models for Java Applications at Process and Transaction Levels“ at the International Workshop on DevOps for Sustainability (DevOpsSustain) 2025

Mon, 12 May 2025 00:00:00 +0200

On June, 27th, 2025 Prof. Dr. Andreas Brunnert will present his latest paper on „Evaluating the Accuracy of Software Energy Consumption Models for Java Applications at Process and Transaction Levels“ at the First International Workshop on DevOps for Sustainability (DevOpsSustain) 2025, a pre-print of the paper is available on our website (here) and short summary of the content can be found here:

Evaluating the Accuracy of Software Energy Consumption Models for Java Applications at Process and Transaction Levels

The energy consumption of software systems is hard to quantify because software does not consume energy itself but rather the hardware that it runs on. To address this challenge, technologies such as the Intel Running Average Power Limit (RAPL) interface have been developed to measure the energy consumed by various hardware resources at runtime. Additionally, specialized tools like JoularJX have been created to attribute RAPL measurements to individual software systems and their components. However, these tools are typically limited to software running directly on a server, without virtualization or containerization. In virtualized or containerized environments, direct energy measurements are only possible if the hypervisor or container runtime forwards this information to the guests—a practice not widely adopted, particularly in cloud environments. In such cases, energy consumption models are used to estimate software energy usage based on other metrics, such as CPU, memory, storage, or network utilization. One recently released tool following this approach is the OpenTelemetry Java-Agent extension (OTJAE), making it suitable for environments where direct measurements are not feasible. This study aims to evaluate the accuracy of JoularJX and OTJAE, along with their underlying models, in calculating energy consumption at both the process and transaction levels of Java applications. Both models under examination are based on CPU demand measurements. We are able to show that the model predictions match actual measurements obtained from a hardware server with high accuracy in medium and high load scenarios (50% to 100% CPU utilization) but vary significantly for lower load levels.

RETIT @ IT Sustainability User Group

Mon, 05 May 2025 00:00:00 +0200

On May, 7th 2025 Prof. Dr. Andreas Brunnert will give a presentation on „How to measure the Software Carbon Intensity (SCI) of your cloud software with OpenTelemetry and Cloud Carbon Footprint“ at the Quarterly Meeting of the IT Sustainability User Group . In this presentation he will talk about how you can use our new RETIT OpenTelemetry Extension (https://github.com/RETIT/opentelemetry-javaagent-extension) to measure the Software Carbon Intensity (SCI) of your software.

The event will take place on May, 7th 2025 at Amazon Web Services (AWS) in Munich.

RETIT @ Green Software Foundation Meetup 01/2025

Thu, 16 Jan 2025 00:00:00 +0100

On 01.10.24 Prof. Dr. Andreas Brunnert will give a presentation on „How to measure the Software Carbon Intensity (SCI) of your cloud software with OpenTelemetry and Cloud Carbon Footprint“ at the Green Software Foundation Meetup 2025. In this presentation he will talk about how you can use our new RETIT OpenTelemetry Extension (https://github.com/RETIT/opentelemetry-javaagent-extension) to measure the Software Carbon Intensity (SCI) of your software.

The event will take place on January 15th, 2025 at the Liquid Reply offices in Munich and registration is now open here: http://meetup.com/de-DE/green-software-development-munich/events/305079798

RETIT @ Green Software Foundation Global Summit 2024

Tue, 24 Sep 2024 00:00:00 +0200

On 01.10.24 Prof. Dr. Andreas Brunnert will give a presentation on “Automatically measure the Software Carbon Intensity (SCI) of your cloud software with OpenTelemetry and Cloud Carbon Footprint” at the Green Software Foundation Global Summit 2024. In this presentation he will talk about how you can use our new RETIT OpenTelemetry Extension (https://github.com/RETIT/opentelemetry-javaagent-extension) to measure the Software Carbon Intensity (SCI) of your software.

The event will take place on 01.10.2024 at the Siemens Technology Center STC in Garching and registration is now open here: https://eveeno.com/140350708

RETIT presents „Green Software Metrics“ at the Workshop on Challenges in Performance Methods for Software Development 2024

Tue, 02 Apr 2024 00:00:00 +0200

On 07.05.24 Prof. Dr. Andreas Brunnert will present his latest paper on „Green Software Metrics“ at the Workshop on Challenges in Performance Methods for Software Development (WOSP-C) 2024, a short summary of the content can be found here:

Green Software Metrics

Efficiency has always been at the core of software performance engineering research. Many aspects that have been addressed in performance engineering for decades are gaining popularity under the umbrella of Green IT and Green Software Engineering. Engineers and marketers in the industry are looking for ways to measure how green (in terms of carbon dioxide emissions) their software products are. Proxy measures are proposed, such as hosting cost or the power consumption of the hardware environment on which the software is running. In environments where a software system runs on a dedicated server instance, this may make sense, but in virtualised, containerised or serverless environments, it is necessary to find ways of allocating the energy consumption of the entire server to software components that share the same infrastructure. This paper proposes the use of resource demand measurements as a basis for measuring how green a given software actually is.

RETIT presents „How to measure CO2 emissions for every API call of your microservices“ at the EcoCompute Conference 2024

Tue, 26 Mar 2024 00:00:00 +0100

On April 25th, 2024 Prof. Dr. Andreas Brunnert will be presenting at the first EcoCompute Conference in Munich The topic of his presentation is „How to measure CO2 emissions for every API call of your microservices“ – here is a short summary of the talk:

How to measure CO2 emissions for every API call of your microservices

Have you ever wondered how much CO2 is emitted by a particular API call of your microservices? Then this talk is for you!

28th Software Performance Meetup (RETIT Offices)

Tue, 05 Jul 2022 00:00:00 +0200

Dear Performance Engineers,

For the first time in a long while, we’re happy to invite you to a real-world Software Performance Meetup again on July 12th. Also for the first time, we will hold the meetup in our own offices.

Remember to RSVP on the Meetup page (also contains info about the location):

https://www.meetup.com/de-DE/software-performance-meetup-group/events/286282013/

Please note that we mandate wearing a face mask in the offices, due to the circumstances. The get-together after the talks will take place in the courtyard without masks.

Application Observability in Azure with OpenTelemetry and Azure Monitor

Thu, 05 May 2022 00:00:00 +0200

The three pillars of observability are traces, metrics, and logs. OpenTelemetry is an open-source observability framework, which offers APIs and tools to standardize the collection of telemetry data from running, potentially distributed applications. In two previous blog post, we discussed the architecture of OpenTelemetry and showed how AWS integrates OpenTelemetry into their X-Ray and CloudWatch services, as well as how GCP realizes the integration of OpenTelemetry into its Cloud Operation Suite. This post will explore how Microsoft Azure integrates OpenTelemetry into Azure Monitor to collect and inspect traces and metrics from an application deployed on-premises or on arbitrary cloud environments, without the need to deploy additional tools. We will show the necessary configuration to get started and look at the cost of using Azure Monitor.

Application Observability in GCP with OpenTelemetry and the Google Cloud Operations Suite (formerly Stackdriver)

Tue, 29 Mar 2022 00:00:00 +0200

The three pillars of observability are traces, metrics, and logs. OpenTelemetry is an open-source observability framework, that offers APIs and tools to standardize the collection telemetry data from a running application. In a previous post, we discussed the architecture of OpenTelemetry and showed how AWS integrates OpenTelemetry into their X-Ray and CloudWatch services. This post will explore how Google Cloud Platform (GCP) integrates OpenTelemetry into the Google Cloud Operations Suite to collect and inspect traces and metrics from a GCP deployed application, without the need to deploy additional tools. We will show the necessary configuration to get started and look at the cost of using the Google Cloud Operations Suite.

Application Observability in AWS with OpenTelemetry, X-Ray and CloudWatch

Tue, 30 Nov 2021 00:00:00 +0100

When developing and operating an application, observability is an important factor for successfully maintaining the application and evaluating its performance. The three primary aspects of observability are logs, metrics, and traces. In this blog post we’ll present how metrics and traces can be collected for applications deployed on Amazon Web Services (AWS) by using the AWS Distro for OpenTelementry (ADOT) without setting up and maintaining additional APM solutions. ADOT is a fork of the open-source project OpenTelemetry (OTEL), extending it with components, that simplify the integration of the OTEL data into existing AWS tools such as CloudWatch and X-Ray. We’ll look at the architecture of OpenTelemetry and show how AWS integrates OpenTelemetry, as well as the basic configuration necessary to automatically record traces and metrics from a Java application, which can then be viewed in X-Ray and CloudWatch. We’ll also discuss the cost of using this setup.

27th Software Performance Meetup (virtual)

Tue, 23 Nov 2021 00:00:00 +0100

[Update] You may now download the slides of the talk here: 20220201_Meetup_Otel_AWS_GCP_Azure

Dear Performance Engineers,

we are happy to welcome you to the next virtual software performance meetup. The meetup will take place on February 1st and will be held using Workadventure. Please RSV on the meetup page for the access link.

As last time, we’re happy to announce a speaker of our own: Bernhard Lubomski will talk about the integration of OpenTelemetry in AWS, GCP and Azure, which helps to make cloud-native Java applications observable.

RETIT presents „Observing Cloud-Native Java Apps using OpenTelemetry on AWS, GCP and Azure“ and „Investigating the Performance of Reactive Libraries in a Quarkus Microservice“ at JavaLand 2022

Tue, 09 Nov 2021 00:00:00 +0100

We’re happy to announce that RETIT will be presenting two talks at JavaLand 2022: Bernhard Lubomski will give a talk about Observability in AWS, GCP and Azure using OpenTelemetry on 2022/03/15 and Denis Angeletta will hold a talk on Performance of Reactive Libraries in Quarkus Microservices, also on 2022/03/15.

You’ll find summaries of of talks here:

Observing Cloud-Native Java Apps using OpenTelemetry on AWS, GCP and Azure

All major cloud providers (AWS, GCP, Azure) have recently introduced support for OpenTelemetry, a young opensource observability framework, which provides insights into any software during runtime by means of distributed traces, metrics and logs. The OpenTelemetry Java auto-instrumentation capability supports a wide selection of popular Java frameworks (e.g., Java EE, Spring, Quarkus) and makes it very easy to collect telemetry data for your Java applications. In this talk, we will introduce the architectural fundamentals of OpenTelemetry and show how it can be integrated into your Java cloud applications on AWS, GCP and Azure. We will explain how the cloud providers leverage the traces and metrics collected from an application instrumented with OpenTelemetry and which tools they offer, enabling you to explore this information and analyze how your Java software behaves in the cloud.

Investigating the Performance of Reactive Libraries in a Quarkus Microservice

Fri, 22 Oct 2021 00:00:00 +0200

What’s the performance benefit of using reactive libraries in my Java applications? Can I go step-by-step, or do I need to go all-in and refactor the whole code to gain performance benefits of these reactive libraries? If you are dealing with similar questions, this blog is for you! In this blog, we will review different refactoring options for a Quarkus-based Microservice using frameworks such as RESTEasy Reactive, Hibernate reactive and Mutiny from a performance perspective. A typical service architecture of a micro-service is shown in figure 1. In this blog post we will outline which reactive frameworks we have used in this evaluation on the different layers of the architecture. Before going over the details and which combinations of reactive libraries are possible and their performance implications, let us start with the mechanism that is at the core of most reactive libraries.

RETIT is Sponsor of the Symposium on Software Performance 2021

Tue, 12 Oct 2021 00:00:00 +0200

RETIT is official sponsor of the Symposium on Software Performance 2021 in Leipzig! The goal of the Symposium on Software Performance is to exchange experiences in the field of software performance. The official description of the event can be taken from here:

The Symposium on Software Performance (SSP) brings together researchers and practitioners interested in software performance, where „performance“ is understood both in a classical sense as “the amount of useful work accomplished by a software system compared to the time and resources used”, as well as in a broader sense as „the manner in which or the efficiency with which a software system reacts or fulfills its intended purpose“. The scope of SSP spans measurement, modeling, benchmark design, and run-time management. The focus is both on classical performance metrics such as response time, throughput, and resource utilization, as well as on the relationship of such metrics to other software quality attributes including but not limited to scalability, elasticity, (energy) efficiency, dependability (in terms of availability and reliability), resilience, security, and privacy. Topics of interest include the design of metrics, benchmarks, and tools for quantitative system evaluation and analysis, as well as the development of methodologies, techniques and tools for modeling, measurement, load testing, monitoring, profiling, workload characterization, and run-time management of software systems with respect to the mentioned quality attributes.

26th Software Performance Meetup (Virtual)

Wed, 06 Oct 2021 00:00:00 +0200

Dear Performance Engineers,

we are happy to announce our fourth virtual performance meetup. This meetup will take place on October 26th and will be held using Workadventure. In case of technical problems, we will revert back to Microsoft Teams. Please sign up on the meetup page:

https://www.meetup.com/de-DE/Software-Performance-Meetup-Group/events/281225349/

For this meetup, we are happy to announce a speaker of our own. Denis Angeletta aims to make reactive libraries more accessible aswell as share his experience evaluating the impact of those libraries on software performance.

25th Software Performance Meetup (Virtual)

Tue, 22 Jun 2021 00:00:00 +0200

Dear Performance Engineers,

as we need to stay online for the time being, we are happy to announce our third virtual performance meetup! The meetup will take place on July 6th and will be held using Workadventure (if all works well, otherwise we will revert to Teams). Please RSVP on the meetup page:

https://www.meetup.com/de-DE/Software-Performance-Meetup-Group/events/278903266/

This time, we are happy to announce two speakers! First of all, Sascha Brechmann from VHV insurance will share their experience with Open Source APM Tools. This presentation will give you great insights on how the tools that were presented at the last meetup could actually be used in production. Afterwards, Ouamar Nedil (Octoperf) will give an overview on how to modularize your JMeter-based performance test scripts for improved maintenance, reusability, and extensibility.

24th Software Performance Meetup (Virtual)

Wed, 14 Apr 2021 00:00:00 +0200

Dear Performance Engineers,

as we need to stay online for the time being, we are happy to announce our second virtual performance meetup! The meetup will take place on April 27th and will be held using Microsoft Teams. You may RSVP on the Meetup page:

https://www.meetup.com/de-DE/Software-Performance-Meetup-Group/events/277501330/

Three years ago, at our 15th meetup we have already presented an overview of the open source apm tool ecosystem (https://www.meetup.com/de-DE/Software-Performance-Meetup-Group/events/248831491/). As a lot of things have changed since then, we have recently prepared an update of this overview with the latest developments in this area which we will present in this meetup.

Collecting Java Runtime, System- and Process-Metrics using OpenTelemetry Java Auto Instrumentation

Tue, 23 Mar 2021 00:00:00 +0100

With the release of version 1.0.0 the OpenTelemetry Java Auto Instrumentation now supports collecting system- and process metrics. In this blog post we will show you how to enable the collection of those metrics and how to expose them via a Prometheus endpoint.

Introduction

OpenTelemetry is an open-source observability framework that aims to define standards for collecting distributed traces, metrics and logs as well as provide instrumentations with extensive support for common technologies [https://opentelemetry.io/docs/java/automatic_instrumentation/] to automatically do so. Resulting from the merge of OpenTracing and OpenCensus and being part of the Cloud Native Computing Foundation, various Cloud- and APM-providers already offer support and integration of OpenTelemetry [https://www.dynatrace.com/integrations/opentelemetry/, https://www.dynatrace.com/monitoring/integrations/opentelemetry/]. In our virtual 23. Meetup last November we demoed how a Java application can be instrumented using the OpenTelemetry Java Auto Instrumentation with very little effort to collect distributed traces. Based on Willie Wheeler’s article and corresponding demo “Auto-Instrumentation with OpenTelemetry” [https://medium.com/wwblog/auto-instrumentation-with-opentelemetry-3b096fdd068f], we demonstrated how to collect traces, but did not show how to collect system- and process metrics at the time. With recent releases this capability was introduced in the OpenTelemetry Java Auto Instrumentation. Here we will show you how to enable the collection of process- and system-metrics and how to expose them via a Prometheus endpoint. A disclaimer: OpenTelemetry is very much in relatively early active development and there are issues to be resolved – in case of Java process metrics the consumed memory metric and consumed CPU time metric are broken: [https://github.com/open-telemetry/opentelemetry-java-instrumentation/issues/2231]. This article refers to v1.0.0 of the OpenTelemetry Java Auto Instrumentation.

RETIT Presents ‚Towards a Benchmark for Software Resource Efficiency‘ at the International Conference on Performance Engineering (ICPE) 2021

Tue, 02 Mar 2021 00:00:00 +0100

Together with the Universität Würzburg we at RETIT have submitted a vision paper, which has now been accepted to be presented at the 12th International Conference on Performance Engineering (ICPE). In the paper we discuss the need and means for more resource efficient software:

Data centers already account for over 250TWh of energy usage every year and their energy demand will grow above 1PWh until 2030 even in the best-case scenarios of some studies. As this demand cannot be met with renewable sources as of today, this growth will lead to a further increase of CO2 emissions. The data center growth is mainly driven by software resource usage but most of the energy efficiency improvements are nowadays done on hardware level that cannot compensate the demand. To reduce the resource demand of software in data centers one needs to be able to quantify its resource usage. Therefore, we propose a benchmark to assess the resource consumption of data center software (i.e., cloud applications) and make the resource usage of standard application types comparable between vendors. This benchmark aims to support three main goals (i) software vendors should be able to get an understanding of the resource consumption of their software; (ii) software buyers should be able to compare the software of different vendors; and (iii) spark competition between the software vendors to make their software more efficient and thus, in the long term, reduce the data center growth as the software systems require less resources.

23. Software Performance Meetup

Tue, 17 Nov 2020 00:00:00 +0100

A lot of time has passed since our last Software Performance Meetup and in regard to recent developments of the Covid-19 pandemic, it will be quite some time before we can come together for a Meetup at a real world location again. Despite all of this, we would still like to offer the Software Performance Community a platform for exchange. Therefore, we’re happy to announce our first virtual Meetup on 24th November! The Meetup will be held using Microsoft Teams and further details will be announced shortly before the Meetup. In this meetup, we will introduce the OpenTelemetry Java Auto-Instrumentation, which is a free tool that can add tracing to your Java applications.

Tracing Applications on Payara with OpenTracing and Jaeger

Tue, 07 Jul 2020 00:00:00 +0200

Intro

The selection of open source tracing standards and solutions has been growing in recent years and so has support in various tools and application servers. This provides developers the opportunity to increase observability of their applications without having to build solutions from the ground up or having to solely rely on commercial solutions.

Payara is one such application server, which now offers a MicroProfile OpenTracing implementation. In this post, I will demonstrate which steps are necessary to set up a basic tracing for JEE applications deployed on Payara using the Jaeger Tracer, how tracing may be adjusted to be more fine-granular and how database calls of deployed applications may be traced.

Webinar @malt-academy: Performance Fundamentals in the Age of Cloud Computing – What to look for and how to measure it?

Mon, 06 Apr 2020 00:00:00 +0200

Originally, RETIT’s move to our new offices would have been celebrated by the 23. Software Performance Meetup this month. Due to the ongoing Covid-19 pandemic, this will of course not be possible in the foreseeable future. We are however evaluating alternatives and will keep you up to date here and on our meetup-page.

In the meantime, we would like to provide all performance workers with opportunities for exchange. For a start, tomorrow, 07.04.2020, between 14:00 and 15:00 CET we will offer the webinar „Performance Fundamentals in the Age of Cloud Computing – What to look for and how to measure it?“. The event will be held via Zoom as part of the Malt-Academy. The talk was already given during our 20th Software Performance Meetup at Google last year, but will this way become conveniently available for everybody who could not participate and is interested in the foundations of software performance. Even from home office:

Software Performance Fundamentals

Tue, 21 Jan 2020 00:00:00 +0100

Why is the [place software name here] so slow?

Such types of questions may hit a development team surprisingly, since a lot of software is being developed with blissful disregard for its performance and usage of resources. Especially if a software needs to perform a non safety critical function and performance is a lower priority to pure functionality. After all, doesn’t it only need to store and retrieve some data and render it in a UI? However, once the reality of a go-live hits, it usually comes with a growing amount of real-world users or data and software performance may suddenly become the most pressing matter in a project. A software that performs poorly may drive away users and profits, become unreliable or fail outright when it’s supposed to control processes or machines. Just as a poorly performing software wastes resources. Who wants to have their new mobile phone’s app drain the battery twice as fast after an update introduced performance issues? On a larger scale, inefficient software would waste resources of a data centers or server farms. Both in terms of energy and running cost.

RETIT Supports Load Testing and Benchmarking (LTB) – A Workshop at the International Conference on Performance Engineering (ICPE) 2020

Mon, 13 Jan 2020 00:00:00 +0100

The International Workshop on Load Testing and Benchmarking of Software Systems (LTB) will take place in 2020 as part of the International Conference on Performance Engineering (ICPE) in Edmonton (Canada). Dr. Andreas Brunnert was co-chair of the workshop in 2015 and supports the workshop since then as part of the Program Committee. Here is a short summary of the workshop scope:

Load testing and benchmarking software systems are difficult tasks, which requires a great understanding of the system under test and customer behavior. Practitioners face many challenges such as tooling (choosing and implementing the testing tools), environments (software and hardware setup) and time (limited time to design, test, and analyze). This one-day workshop brings together software testing researchers, practitioners and tool developers to discuss the challenges and opportunities of conducting research on load testing and benchmarking software systems.

22nd Software Performance Meetup @ Malt (Velvet Coworking Space)

Tue, 03 Dec 2019 00:00:00 +0100

Another year of Software Performance Meetups has gone by, but we’ll of course meet again next year. As announced during Tuesday’s Meetup, the next Meetup will take place on 11th February 2020 at the Velvet Coworking Space, Amalienstraße 71 and will be sponsored by Malt. We’d like to invite you to join us again in the new year for a presentation on „Methods and Tools to Analyze and Compare Load Test Results“ by Richard Vobl (RETIT). If you would like to present a topic, we’re happy to hear about your suggestions for the second talk.

RETIT is Sponsor of the Symposium on Software Performance 2019

Tue, 01 Oct 2019 00:00:00 +0200

RETIT is official sponsor of the Symposium on Software Performance 2019 in Würzburg! The goal of the Symposium on Software Performance is to exchange experiences in the field of software performance – this is the offical description of the event:

The Symposium on Software Performance (SSP) brings together researchers and practitioners interested in software performance, where „performance“ is understood both in classical sense as “the amount of useful work accomplished by a software system compared to the time and resources used”, as well as in a broader sense as „the manner in which or the efficiency with which a software system reacts or fulfills its intended purpose“. The scope of SSP spans measurement, modeling, benchmark design, and run-time management. The focus is both on classical performance metrics such as response time, throughput and resource utilization, as well as on the relationship of such metrics to other software quality attributes including but not limited to scalability, elasticity, (energy) efficiency, dependability (in terms of availability and reliability), resilience, security and privacy. Topics of interest include the design of metrics, benchmarks and tools for quantitative system evaluation and analysis, as well as the development of methodologies, techniques and tools for modeling, measurement, load testing, monitoring, profiling, workload characterization and run-time management of software systems with respect to the mentioned quality attributes.

21st Software Performance Meetup @ ESG Mobility

Tue, 24 Sep 2019 00:00:00 +0200

We would like to announce our 21st Software Performance Meetup. It will take place on November 26th 2019 and will be hosted by ESG Mobility.

Please join us to learn about about „Instrumenting Legacy Applications with Jaeger and inspect.IT Ocelot“ by Jonas Engeler from Interhyp and about „Performance Testing of OpenShift“ by Elvir Kuric from Red Hat.

Demystifying the Monolith: Instrumenting Legacy Applications with Jaeger and inspect.IT Ocelot (Jonas Engeler, Interhyp)

RETIT @ Software-QS-Tag 2019 – Do we need a resource efficiency label for software?

Tue, 27 Aug 2019 00:00:00 +0200

Dr. Andreas Brunnert will give a talk about „Do we need a resource efficiency label for software?“ at the Software QS Days 2019 in November. Here is a short summary of the presentation:

The energy consumption of the IT sector already accounts for approximately 7% of the global energy consumption according to a study done by Greenpeace in 2017. As this energy consumption is likely to grow due to the ubiquity of software and the development of power-consuming algorithms such as BitCoin miners, it is about time to do something about our footprint on this planet.

20th Software Performance Meetup @ Google

Tue, 20 Aug 2019 00:00:00 +0200

We are happy to announce our 20th Software Performance Meetup. It will take place on September 17th 2019 and will be hosted by Google.

As our group has grown from a handful of people to a community with over 1200 members in the last five years, we decided that the twentieth meetup might be a good time to take a step back and focus again on the foundations of software performance analysis and tools. Therefore, this meetup is especially designed to give new members a chance to join, who have never been to one of our meetups before. It doesn’t matter if you are employed, freelancer or student or what technology you prefer and use. Experts and newcomers are important parts of the group. Join us if you want to meet like-minded people and to improve your skills and knowledge.

19th Software Performance Meetup @ codecentric AG

Tue, 14 May 2019 00:00:00 +0200

We would like to announce our 19th Software Performance Meetup. It will take place on May 21th 2019 and will be hosted by codecentric AG.

Jens Wilke, author of cache2k and contributor to the JCache/JSR107 standard, is our first speaker and will talk about “Java In-Process Caching – Progress, Performance and Pitfalls”. In the second presentation, Fabian Warthenpfuhl und Jonas Kunz of Novatec GmbH will talk about „Improved Observability Using Automated, OpenCensus-based Application Monitoring Solutions“:

Open Source APM Tool Overview – Jaeger

Tue, 30 Apr 2019 00:00:00 +0200

This article continues our series of blog posts about the Open Source APM standards and tools we started with Open Source Application Performance Monitoring (APM) Tools – A Classification and Overview of Tools and Standards, providing an overview of the tools and standard. After looking at the two OpenSource APM standards OpenCensus and OpenTracing, we will now introduce Jaeger, an APM tool supporting OpenTracing. We’ll provide an basic overview of Jaeger’s architecture, introduce UI and show how a Java application can be instrumented to record spans and send them to the Jaeger backend.

18th Software Performance Meetup @ Interhyp AG

Thu, 14 Mar 2019 00:00:00 +0100

18th Software Performance Meetup @ Interhyp AG

We would like to announce our 18th Software Performance Meetup. It will take place on March 19th 2019 and will be hosted by Interhyp AG.

Our first speaker, André van Hoorn of the University of Stuttgart, will talk about „Efficient Resilience Benchmarking of Microservice Architectures“. In the second presentation, Bernhard Lubomski (RETIT GmbH) will provide an introduction to the distributed tracing system Jaeger:

RETIT is Sponsor of the Symposium on Software Performance 2018

Tue, 04 Sep 2018 00:00:00 +0200

RETIT is official sponsor of the Symposium on Software Performance 2018 in Hildesheim! The goal of the Symposium on Software Performance is to exchange experiences in the field of software performance – this is the offical description of the event:

Performance is one of the most relevant quality attributes of any IT system. While good performance leads to high user satisfaction, weak response times lead to loss of users, perceived unavailability of the system, or unnecessarily high costs of network or computing resources. Therefore, various techniques to evaluate, control, and improve the performance of IT systems have been developed, ranging from online monitoring and benchmarking to modeling and prediction. Experience shows, that for system design or later optimization, such techniques should be applied in smart combination.

16th Software Performance Meetup @ Google

Tue, 07 Aug 2018 00:00:00 +0200

Before you leave for your well-deserved summer vacation we would like to announce our next meetup – it will take place after the holidays on Tuesday, September 18th, 2018 and will be hosted by Google!

The first speaker will be Doug Sillars – an expert in mobile and app performance, who will talk about how to ensure the performance of mobile apps (he already wrote a book about it – http://shop.oreilly.com/product/0636920035053.do). The second speakers will be Reinhard Brandstädter (SAP Hybris) and Torsten Hellwig (360performance) who will talk about performance monitoring in a multi-tenant cloud environment:

Open Application Performance Monitoring (APM) Standards – OpenTracing and OpenCensus

Tue, 03 Jul 2018 00:00:00 +0200

This blog post is part of our series about Open Source Application Monitoring (APM) tools. It describes the scope of the two main „standards" in this area called OpenTracing and OpenCensus. If you want to get a broader overview of this topic first, we recommend to read the first part of this blog series: Open Source Application Performance Monitoring (APM) Tools – A Classification and Overview of Tools and Standards

Even though the name „standard" might not be 100% appropriate for the two specifications covered in this blog article, it gives you a sense of what they are trying to do: Their goal is to harmonize the way instrumentation is added to an application using common Application Programming Interfaces (APIs). It is important to note that those two are not the first attempts to harmonize tracing implementations but they seem to be much more successful in terms of adoption than their predecessor Application Response Measurement (ARM) which is a specification with a similar goal hosted by the OpenGroup.

RETIT presents „An Introduction to Open Source Application Performance Monitoring (APM)“ @ CMG cloudXchange

Thu, 14 Jun 2018 00:00:00 +0200

On June 19th 2018 Dr. Andreas Brunnert will be presenting live during Computer Measurement Groups (CMG) first cloudXchange virtual conference. The topic of his presentation is Open Source Application Performance Monitoring (APM) – here is a short summary of the talk:

An Introduction to Open Source Application Performance Monitoring (APM)

This talk provides an overview of the wide variety of open source Application Performance Monitoring (APM) tools available today. It introduces a classification of tools and available standards to give you some guidance on how to choose a proper tool. Afterwards the most popular tools and standards are covered in more detail.

Performance in Detail: Long vs. Double in Java

Tue, 08 May 2018 00:00:00 +0200

A few weeks ago, we stumbled upon an interesting problem during a code refactoring. After changing the data type of an attribute from List<Long> to List<Double>, we noticed some severe performance issues. Our application took minutes to process data it previously handled in seconds. This seemed quite strange, so instead of just reverting the change, we decided to further investigate the reason for this behavior.

After some analysis, we found out that the version using Doubles required more heap space and led to an enormous amount of garbage collections, which of course affected the application’s performance. But when consulting the Java Language Specification, you will find that the primitive types long and double are both represented internally using 64 bits. So why would the version using Doubles lead to a higher memory consumption?

Open Source Application Performance Monitoring (APM) Tools – A Classification and Overview of Tools and Standards

Mon, 07 May 2018 00:00:00 +0200

The amount of open source Application Performance Monitoring (APM) tools has grown dramatically in the last four years. The following eight tools appeared publicly starting from early 2014:

If you miss some Monitoring tools in this overview, please note the following:

With APM tools we refer to tools that allow you to analyze individual transaction traces. With „transaction trace“ we refer to the complete transaction execution flow including a timing breakdown for internal application components and external systems such as databases.
System monitoring tools that just gather and display aggregated data (e.g., response time or resource utilization statistics) such as Grafana, Prometheus, or ZMON are not analyzed.
Open source means not just „free“ but also that the code is publicly available for adaptations.
Hawkular APM is not mentioned as they discontinued their own solution in favor of Jaeger (http://www.hawkular.org/hawkular-apm /)

If we have missed an open source APM tool that fits these criteria and was open-sourced since 2014, please let us know at info@retit.de!

15th Software Performance Meetup @ Loyalty Partner Solutions

Tue, 20 Mar 2018 00:00:00 +0100

We are happy to announce our next meetup which will take place on Tuesday, May 15th 2018 and will be hosted by Loyalty Partner Solutions GmbH (LPS)!

This meetup will be all about application performance monitoring (APM). The first speaker will be Stefan Kuehnel a Software Architect at LPS, who will share his experiences with APM in an AWS Cloud Environment. The second speaker will be Dr. Andreas Brunnert who will give you an overview of open source APM tools and standards.

14th Software Performance Meetup @ Codecentric

Tue, 13 Feb 2018 00:00:00 +0100

We are happy to announce our next meetup which will take place on Monday, March 19th 2018 and will be hosted by codecentric!

For our first meetup in 2018 we will try something new – instead of having two presentations we want to challenge your performance skills with a software performance puzzle (in Java). We will solve this puzzle in this meetup by forming small teams (1-4 persons) that will get exactly 1h time. Afterwards, we will execute the solutions on a reference machine to find the 3 top-performing solutions. In addition to the fame in the community the winners will be awarded with small prices.

Continuous Benchmarking with JMH and JUnit

Sun, 11 Feb 2018 00:00:00 +0100

„Measuring Tape" by Jamiesrabbits is licensed under CC BY 2.0

Why benchmarks?

When writing code, you are confronted with countless small decisions all the time.

“Should I use a HashMap or a ConcurrentHashMap?”
“Maybe using a StringBuilder would be better than concatenating the Strings myself…”
“My colleague told me indexOf() is faster than contains(), is it really though?”

While the performance of an application depends on many factors (hardware, workload, software architecture, etc.), these small programming decisions also have an impact on software performance. Many small mistakes can add up pretty quickly, the more so when the code you are developing is a critical component that is called very often. However, it is hard to intuitively know in advance what impact a specific decision might have on the actual software performance. That’s why measuring software performance is always a good idea.

Company

Tue, 26 Dec 2017 00:00:00 +0100

Resource-efficient software since 2015

RETIT stands for “Resource Efficient Technologies & IT Systems” and was founded in 2015 as a spin-off from the Technical University of Munich. The name was the plan from the start: using computing resources sparingly.

For a long time that mostly meant performance: shorter response times, fewer servers, lower license costs. Today the same measurement counts twice: once you know an application’s resource consumption, you can derive its energy use and its CO₂-eq emissions from it. Performance work and sustainability draw on the same data.

Contact

Tue, 26 Dec 2017 00:00:00 +0100

13th Software Performance Meetup @ Codecentric

Fri, 13 Oct 2017 00:00:00 +0200

We are happy to announce our next meetup which will take place on Tuesday, November 14th 2017 and will be hosted by codecentric!

The first speaker will be Dmitri Melikyan from StackImpact, who will introduce us to the benefits of continuous production profiling and explain how this is different to current performance monitoring systems. The second speaker will be Tsvetan Stoychev from ePetWorld GmbH who will talk about his experiences in writing a custom real user monitoring solution.

“Will we survive Black Friday?” – Seasonal Load Testing & Performance Analysis using Simulations

Tue, 12 Sep 2017 00:00:00 +0200

Standing on top of a mountain peak feels majestic. Just like handling your application’s peak load without any performance issues.

Motivation

Application performance is a subject which is relevant at all times of the year. However, there are often times when performance becomes especially important to developers, operators and support staff alike. That happens when the workload of the application has certain peak times and seasonal variations, i.e., when many employees or customers are using the application at a certain point in time. Travel agencies will usually experience a surge of users in the summertime; opposed to that, video streaming platforms are used more often in the winter months when people are more likely to stay inside, and they usually also experience more load on weekends than on working days. In the retail industry, usage peaks frequently occur on Black Friday in November or during the festive season leading up to Christmas. The retail industry is also particularly affected by performance problems at that time, because Black Friday discounts are usually achieved through supplier discounts, meaning that only a limited number of discounted articles is available. Performance problems in the central goods management system of a retailer may therefore at the worst lead to selling more articles than are actually in stock – this in turn has a real financial impact for the retailer, because they will have to reorder additional articles at a higher price. But performance problems due to seasonal peak times will have negative consequences in many other industrial sectors as well. To avoid such problems, extensive load tests and performance analysis should be performed prior to the peak season.

HTTP/2 – An Overview from the Performance Perspective

Tue, 06 Jun 2017 00:00:00 +0200

In May 2015 HTTP/2 was introduced to replace HTTP/1.1 which at this point was almost 20 years old. This was the attempt to adapt the standard transfer protocol of the document-based web to the present world of modern web applications. But since then there have not been a lot of discussions about HTTP/2 in production environments although it is already in heavy use by the big tech companies like Google. Therefore, it is time to take a closer look at the benefits of HTTP/2.

Imprint

Sun, 12 Mar 2017 00:00:00 +0100

RETIT GmbH
Obere Lagerstr. 25
82178 Puchheim – Germany

Tel.: +49 89 23964406
Fax: +49 89 23964408
info@retit.de

Company registered in Puchheim
Local court Munich: HRB 223476
Director: Prof. Dr. Andreas Brunnert

Sales tax identification number according to § 27 a of the sales tax law: DE 304720643

Disclaimer: Despite carefully checking the contents, RETIT GmbH does not accept any liability for the contents of external links. The operators are exclusively responsible for the content of linked pages.

Privacy Policy

Sun, 12 Mar 2017 00:00:00 +0100

Privacy Policy

This is a purely static website. It sets no cookies, embeds no analytics or tracking services, loads no fonts or other content from third-party servers and runs no JavaScript. A consent banner is therefore not required – there is nothing that consent could be given for.

1. Controller

RETIT GmbH Obere Lagerstr. 25 82178 Puchheim, Germany

Phone: +49 89 23964406 Email: info@retit.de

Managing Director: Prof. Dr. Andreas Brunnert

2. Visiting this website

Each time a page is requested, your browser transmits technically necessary data to the web server, which records it in a log file:

Does your cloud provider really deliver what you pay for?

Tue, 28 Feb 2017 00:00:00 +0100

In recent years, cloud computing has become an integral part of the IT landscape. Many enterprises rely on services from the cloud, for example because they don’t want to buy and maintain hardware by themselves. Furthermore, cloud services allow to easily scale applications depending on the load the system is experiencing, making them very attractive for both small and large businesses. However, while the performance of the application is often monitored with modern APM tools, the performance of the infrastructure itself is rarely scrutinized. We recently had a case at our company which shows that sometimes, it is a good idea to check whether you actually receive the capacity you pay for.

Continuous Performance Evaluation using Open Source Tools

Tue, 21 Feb 2017 00:00:00 +0100

One major trend in IT has been the adoption of DevOps and continuous delivery principles. Many businesses have introduced continuous integration systems, trying to improve software quality and push out features in increasingly shorter release cycles. While functional requirements are rigorously evaluated in these environments to avoid breaking the application, non-functional requirements such as performance are often neglected. Some companies run sporadic load tests every few months, but this is usually not enough – one week after the load test, a major performance bug could be introduced, affecting end users for a long time. This is only made worse by the fact that finding and fixing a performance bug in production is much more expensive than doing the same during development stage. Therefore, it is important to continuously evaluate the performance of all applications.