 Okay. Looks like everything's set. Go ahead. Have fun. Yeah. Thanks. And welcome to this talk about sustainable computing. My name is Cornelius. I've been around for a while, and this is a topic which actually is dear to my heart, because it covers a combination of different things. It covers why I'm in KDE for a good part because of idealistic reasons, but also because of technical challenges, solving interesting technical problems, and also covering this idea that we can do more with the community than we can do alone. Sustainability is something which I'm using the term here in a pretty broad sense. How do we use resources we have? How do we satisfy our needs in a way that future generations can still fulfill their needs as well? And how can we get there in the context of computing and how KDE can help to get there? That's what I want to talk about in the next 30 or 40 minutes. We have talked about that last year at the Academy in a more informal way. We had a rough session about this topic, and I will now give you an update what has happened so far, where we are today, and what we are going to do in the future. So, sustainable computing. Why are we talking about that? What is that? If we look at what computers do to our environment, how they impact our life, and also how they impact our future ability to have the same life, we have to look at different aspects. One is energy consumption. Obviously, computers use a lot of electricity, and these are two graphs from a scientific study about electricity usage of communication technology. In the study, communication technology is this broad range of computers, speed servers, speed desktop systems, speed phones. This is a prediction of how much the impact will be of electricity usage in the future. This goes towards the year 2030. They call it worst-case scenario that electricity usage of computing technology could go up to something like 50% of the global electricity usage, which is an enormous amount of energy. There are different scenarios, of course. This is about predicting the future. That's not always easy. There are different scenarios. In the best-case scenario, if we do the right things, then we might end up with a situation where we don't use much more electricity as a fraction of total electricity usage in the future. But there's clearly a broad range. In the expected-case scenario, that's something on the right graph, you see that in absolute terms. That's a huge growth expected. This is something which will affect, of course, the amount of electricity we use, the amount of energy we use, and what computers have in effect. What that means is not that easy to say. We can say that a huge usage of electricity, of energy in general, that's something which will affect our environment in some way. Of course, depending on from which sources this electricity comes, it has a different kind of impact. If it comes from sustainable renewable energy sources, then the impact on our climate is probably lower than when it comes from other resources. It's not easy to tell what exact effect this has unless we have real numbers. But what we can say is that it will have an effect, that there will be an increase of usage because computers are everywhere. We know that. We're using them every day. Everybody's using them. We need to do something to keep that under control. This is the energy aspect. There's another aspect. If we look at electronics we use, this is a picture. It's a nice sculpture, actually, an artist project, the We-Man. The waste which comes from electronic and electrical equipment. This We-Man is a 7 meter high sculpture built from 3.3 tons of electronic waste. That's about the waste one person produces in this case in the UK. These are the numbers. You see that that's a lot of waste which is produced there. This obviously has an impact on the environment. The question there also is, what can we do? What does it mean to produce so much waste? The third aspect I want to look at is, it's more focused on software. That's the question, how much control do we actually have when we use software? What impact does software have on how we live our life? One of the typical examples there is if you look at printers, if you want to print a piece of paper that supposedly is a pretty simple thing, you just do it and you have a driver which converts your data into ink on paper. But if you use software for that, you might end up with something which is quite complicated and you get a lot of functionality you might not even need and you might not care about the fax functionality. You might not want the integrated shop to buy a new ink. This is also an example where software is really controlling the use of the hardware. Even if you have a good printer, the software controls if you can use it with the ink you bought for it and also when it will stop you working with the ink you have bought. This is an example for control about software and how you can control your usage of computers in a way that you can do it in a sustainable way. The question is, can we do something about this? How can we fix some of the problems maybe? If we are looking at this from a very high level and a very global point of view so there are the sustainable development goals of the United Nations they have defined these 17 goals which cover all kind of areas and there are a couple of areas which are interesting also in our context if we are looking at computing and software and hardware and so on so this obviously has something to do with consumption, with energy also with other aspects of society. So this is the very high level but we can go a little bit further down and look at it in a more concrete way. The question is, what is the role of software there? We are talking here in the KDE community, obviously we are a software community so how can we approach this question? One thing which has to be said is that hardware and software can't really be separated I mean computers don't work without software, software can't work without hardware so these affect each other and the architecture and the design of our software has an influence it determines how the hardware is used and also how much resources are used and it determines at least indirectly the energy consumption it's not the only influence obviously I mean also the efficiency of the hardware itself plays a role but the way how software is written has an influence there and if we look at the question of electronic waste then we also have this big effect of software that you might need new hardware not because your hardware is broken or outdated or not good enough anymore but because your software requires new hardware because it might use more resources than before or it might use new features which weren't there before so we have this effect that hardware often becomes obsolete because of the software that runs on it and then also the question a lot of restrictions are actually not hardware restrictions anymore but software restrictions so the way how you use hardware and also how long you can use hardware is not defined by really the life of the hardware itself so you rarely use a computer until it's really broken often you replace it for other reasons because of software restrictions or software requirements so if we look at that we can say software matters a lot in terms of the effect on sustainability in general and concrete questions like resource and energy usage and it also matters how software is done so it's not only about what software to use but also how the software is applied and how the software is developed and in which direction software is developed so then obviously in KDE it's not enough to just recognize the problem we ask the question what can we actually do about this is there a way how we can have an effect here and contribute something to better solutions and if we look at KDE's vision which says we strive for a world in which everyone has control over their digital life and joy's freedom and privacy this control over our digital life that's something which I think resonates quite well with the idea of sustainability so there's a lot in there and I will unfold that a little bit and show you in the next couple of slides as well how this has an even more concrete application in this area also one thing we can say that KDE technology actually is quite efficient in the domain we are we are writing mostly desktop applications at least that's our origin we write them as native applications the technology we use with C++ and QT that's technology which usually is quite efficient so there are some studies for example about resource efficiency of programming languages and C++ as you can see here comes up at the top with a pretty good factor and there are other languages like if you look at more modern languages which are also now often used on the desktop for example JavaScript for example other languages, Python, Perlis one of the last places here they use inherently more energy just because of the way how they are that doesn't mean that this is really an exact measure and there are certainly also ways how to write efficient code in many languages so here we can say that in KDE or technology the tendencies that we actually can be quite efficient and that it's not that difficult to write efficient software and we have Linux as an open and efficient platform I mean we know that Linux has been around for a long time and one really also of the good and also prominent use cases often is and was in the past if you think of install fests and stuff like that to get Linux running on old hardware to make it available for example for people who can't afford new hardware or just to make use of computers you already have so you don't have to buy a new one because other software would require you to upgrade to bigger hardware faster with more memory and everything so KDE is in a good position there and the other aspect where I think KDE can have quite an effect there is because it provides leverage we have many applications we have many different use cases we have many users if we look at for example what Alessia presented this morning about it's all about the applications all about the apps so we have a lot of users and even the users we know that that's already quite a number and there are certainly a lot of users and if we think of the role we have there if we improve our applications in a way that they save a little bit of energy or make usage of resources in a more efficient way this might have a small effect if you look at just one application but if you look at many applications and multiply this by the number of users they have this can have a huge effect and that doesn't mean that it's sufficient to solve all the energy problems on one of the things which can contribute here so given that we assume we can do something about this how do we do it how can we actually make a difference here and I want to present you three projects in this area which we have been working on for quite some while already in the concept stage also in a little bit of implementation and the last project is something which will be prepared and will start in the future and these are two areas the first one is the first energy efficiency project with a nice acronym this is about measuring actually energy efficiency so we have data, we can quantify what we use there and where we can change things to improve the situation the second one is the blue angel label you might also have heard about that and the last one is the blue angel which demonstrates that your software actually is done in a sustainable way and I will tell you more about what it is and how it works the last one is the blue angel for free and open source software that's a new project more about the community part about spreading the word about engaging others about helping others to also be more sustainable in the way how they do their computing so let's dive in the first project is FEAP what's the goal there what we want to achieve there is that we want to quantify energy efficiency so it's easy to say this application appears to consume a lot of energy I mean sometimes it's obvious if the fan of your laptop starts to make noise that's an indication that energy is used what actually uses the energy and also how you can maybe affect it and change it which is not so easy to answer if you don't have numbers you can rely on so for that we need to measure this and we also need to measure it in a way which is repeatable so that we can actually do comparison that we can also watch that over time or with different implementations different versions if it is transparent then it can actually become a criteria we can use for other purposes to tell what is sustainable what is energy efficient maybe features what is energy efficient architecture what is energy efficient design and there still is a lot to do in this area so it's not clear what the answer is there but we have to start somewhere and one important part of that also is that we need to develop tools or use the tools which are already there so that we can do that automatically and it's something which can become a part of our normal development environment and we can use it as criteria for how good our software is in the end I want to present one method how this can be done so this is a procedure which was developed as a research project from the Uni Trier in Germany it's about sustainable software design and they designed a measurement framework which can be used to measure the energy consumption of software it's not that easy actually because there are a lot of different parts involved so this is the first step towards that which is aimed at desktop software desktop software because there you have one computer and you can actually measure the energy consumption of this computer and if you don't have dependencies on for example servers or other components then this is a good measure of what specific software is using and the way how this is done is they define a scenario where you measure software in different scenarios so you create a baseline measurement over time so this is the line which basically the computer uses when it's simply on without any software running or not the specific software which we are looking at and then there's a second measurement that's the second line here that's the idle management so when you start a piece of software and it does nothing it will consume some resources it will consume some energy but if there's no activity this will be pretty constant and then the interesting part is using a standard scenario what you typically do with a piece of software and then measure how the energy consumption develops over time and you see this in this curve where according to different activities then different amount of energy is used and you can actually measure that by observing how much power the computer actually is consuming. If you put a device basically at the power adapter of the computer you can get pretty hard numbers about the consumption and you do that over time you do that a couple of times to create averages and collect some other system statistics like memory usage, processor utilization, hardest activity, network activity, stuff like that so that you can also put that in context to then tell what actually is happening there and if you collect all this data you can create reports which summarize this also here that there is something like an average energy consumption or total energy consumption if you integrate over this curve you get numbers you can then use for comparison and also for transparency so this is a procedure which was defined in this research project and we actually have some measurements of KDE software using this method. These were done by students at the Umweld Campus Birkenfeld so that's the institute at the University Trier where also this measurement method was developed and I think fully these students have done some measurements on KDE software so I will show some graphs how this can look like and this is only one graph of actual energy consumption so how much power the application is consuming in the standard usage scenario and this example is ocular so you can see over time there's a standard scenario where you open a file you put this file into presentation mode you go forward a couple of pages you invert the view you zoom out change some pages again invert the view again and you can tell in the graph what is happening here so these bigger spikes these are the view inversions the smaller spikes when you go over different pages so you can tell what is happening there and you get an overall number about how much energy is such a usage scenario then consumed a similar measurement for another application K-Mail also done by another student at Umber campus this is another usage scenario in the context of K-Mail so opening some mail folders composing sending mails replying to three mails so these are the bigger peaks here so opening these mails, typing something and then sending it out over the network that actually consumes apparently quite a bit of energy the absolute numbers are still quite low of course because this is one mail but by repeating this measurement a couple of times you get this average where you can actually tell these actions consume this amount of energy and of course there are more graphs which collect the different also resource resource utilization scenarios and you will see here that for example the energy consumption correlates quite well with the processor utilization and you can see that if a mail is sent then there is a spike in network traffic so Krita is another example also a use case where you look at different operations in Krita editing pictures and you can see for example there is a big peak at the beginning where you open the picture operations done drawing operations which don't consume as much energy and then there are some group operations which consume more energy so if you look in detail at these scenarios and the measurements you can actually tell which actions have which effect and again you get this number you can use for comparison so and then another measurement I'm sorry the attribution is not correct so this also was done by Francisco who did the ocular measurements a little bit newer measurement where she compares not a single application but different operating systems and has a more global usage scenario with downloading applications installing them, copying files around and so on and this is a comparison between Linux and Windows so it's interesting to see it's quite similar but there are some differences in some cases Linux is better in some cases Windows is better so this would be interesting to look more into it and I also have to say that this is Ubuntu system so it's not a KDE desktop so that also would be a nice research project to look into that and see if there's a difference if maybe Plasma is more effective than the GNOME desktop on Ubuntu so these are a couple of examples how you can do these measurements and one question I want to ask in the context of this what's energy efficiency project is what if these measurements could be part of our usual operation so what if we could integrate them in how we do software development and we could create another metric we use we have metrics like we make sure that our tests pass, we look at bug counts, we look at translation statistics and so on so why not also look at energy consumption statistics and make sure that our energy efficient doesn't degrade and new versions consume too much energy compared to older versions so we could maybe make this quality gate and I think it would be a nice motivation also for optimization so getting some of the peaks smaller maybe getting the absolute number smaller if you measure them then you have a good way how to also optimize them and making the state transparent to users would make it very easy for us to also talk about that and give users a choice what software to use and have good arguments to use the software which is efficient so this is the technical part about really looking into the data and making sure that we have the ways how to measure and decide about that now I want to talk a little bit about the blue angel which comes from a different direction the German people will know the blue angel it's actually something an echo label from the federal government of Germany it's really old it's more than 40 years old and it was created to indicate products which are designed in a way which is friendly for the environment and in Germany you see that label on a lot of different products obviously 40 years ago computers were not such a hot topic as they are today so this is about stuff like paint but also completely different things like ships so a very broad range of products and the label there are criteria for each product category what it means to be environmentally friendly and then according to these criteria you can get the label to indicate that your product is done in a way which fosters sustainable consumption so you can read about that it's a German label but all the documentation it's also there in English and the criteria I think are quite general valid so it just makes a lot of sense to look at that not only from a German point of view and last year they introduced a category for resource and energy efficient software so this is a new category there's a great presentation actually given by Marina Köhne and Eva Köhne they were instrumental to establishing this category for software and under the blue label and I recommend to watch this presentation it really gives a good background and details about that and while it's in German there's an English translation available so it should be accessible to everybody the focus of this criteria is desktop applications server and mobile will be added in the future but for now there has to be a start somewhere it's about desktop applications and the criteria are categorized in three areas the first is resource and energy efficiency the second is potential hardware operating life that one is user autonomy and I will tell you a little bit more about what that actually means so if we look into resource and energy efficiency they use for these blue angel criteria for the blue angel certification actually this methodology I presented before about the sustainable software design and so part of the application for the blue angel label is to provide measurements according to this procedure and the data which is related to that you have to document that put it into standard format so it can actually be made transparent and this is the energy efficiency part the other part is about the potential hardware operating life so making sure that you don't have to buy new hardware because your software requires that so part of the criteria is that the energy consumption of new versions of your software shouldn't increase over time so a new version that limits so it can increase a little bit but it's not supposed to increase a lot so this makes sure that on our hardware you can actually run your software for a long time and part of that is the definition of reference system so they have specs for systems from 2015 to 2019 so these are reference systems you can use to do measurements to make sure that you have this that you have it available on old systems as well so one of these systems could look like this this is one of the reference systems from 2015 and we can do measurements of this and our software runs very very fine on it user autonomy is an interesting part because that's not so much about the technical specifications but more about making sure that users have control that the data formats allow interoperation that the software is transparent that it's available for for a longer time that you are in control of what you install and whatnot that it's free from advertising and stuff like that so this is something I think which is very familiar to us this is basically a lot of the ideas of free and open source software reflected in this user autonomy criteria so if you look very close you can see that actually these criteria there's a hole shaped in the form of KDE KDE fits in very well we have desktop software we have this software autonomy user autonomy as something which is in the core of what we are doing so this is something which fits very well to us KDE software qualifies for that in a direct way and there is demand for this so this is a block about decision by the city of Dortmund which they recently did but they said for new software they will actually require that it fulfills the criteria of the Blue Angel for software so if they buy new software they look for that if there is software there which has this label and that's one of the problems we have at the moment nothing is there yet but KDE software could be there I said this is really a good match so where are we with this this is something I've worked on for the last couple of weeks and months to get our applications in shape there so the application looks like this they're different you have to fill some forms you have to put in the documentation you have to do the energy management so based on the energy measurements done by the students in Trier I created the first set of applications here the one for Oculus almost ready Chimeille and Krita are next we have the data for that and we are looking into measuring KDevelop, other KDE software I mean there are many applications and we have a little bit of tooling and infrastructure we are able to help with that we have an organization which can actually officially do the applications for that so we are almost there with that here's a work board and a repository you can look at the link what's happening there so can we do something about this and we make more sustainable computing possible with KDE we can with KDE if we can shape of a bit of energy multiplied by our users or if we can spread it amongst our applications if we can make the idea stick we can actually make a difference there and this brings me to another project that's the last of the three the Blue Angel for FOSS can we do something about this if we look at KDE yes I think I've shown we can but the good thing is we are not alone there are others who are also supporting this course and we are actually starting with a project supported by a grant of the German environment agency to support sustainable development software development by promotion and application of the criteria of the Blue Angel in the free and open software community so this is about spreading the word and helping others to also do that and getting a community going to work towards these criteria to work towards more sustainable computing and we are in contact there with other organizations the FSFE, the Round Table Repair or the Document Foundation they all have interest in there more communities which would fit in there there are more desktop applications which could benefit from actually the qualification of energy consumption but also these other criteria about user autonomy and similar things so let's do something about this I think we have the means we have a very good situation we have the right projects we have the right people to do something about this so let's work towards sustainable computing and let's carry the flag for sustainable computing I think KDE, EV and KDE in general we have a lot of very good resources there and we have I think the opportunity to make a difference there and to do to go into this in more concrete terms like what I describe measuring energy efficiency making this part of what we consider the quality of our software we also have areas where I think we don't have to do a lot in terms of changing our software or introducing new things but we can just demonstrate how our software extends hardware life we can demonstrate how our software preserves user autonomy it does that I mean we know that if we could prove that by putting a blue angel on our software that would be even better so this is one of the things I think which can help us there and then of course spread the word helping others that's something where we can have this bigger effect so I would like to do that I work on that for I think a little bit more than a year now and I love to continue on that and I would love some more help on with that so I would be really happy if people join me and we create more momentum there and there are a couple of things which I think these are also smaller things that are not all huge projects for example definition of standard user scenarios for your application that can be quite simple and then finding a way how to automate that that might also be related to other testing tasks you do then also the measurement itself that's also interesting how to do that how to execute that how to create reports about that so this goes a little bit more in scientific areas but also then other things like just documenting autonomy so making sure that in our documentation it's clear what our privacy statement is so linking that in the documentation making sure that users know that they are in control if they are using our software what is happening there so we could do a lot there and these can be small tasks these can be bigger tasks so I would like to invite you to join this effort and do something about sustainable computing where do we get together we have a mailing list energy efficiency at KDE.org so there's not a lot of traffic there yet but this is an obvious place where we can meet there are also two repositories one for the energy measurements that's the fee price repository that's meant as a pretty open project so across applications maybe even across communities and there's another repository where we make the work transparent for creating these applications and for more discussions about that and answering questions and everything I've scheduled for Tuesday so I would like to invite you to join this as well and then talk more in depth about what we are doing there and what we can help there in the end we are filling this hole in the form of KDE I think we can do a lot there so let's do something about it let's go towards sustainable computing and that's what I wanted to tell you and so I think we have a few minutes left for questions so I haven't followed the matrix channel but so Adam you have to help me out and repeat if there was something there we should answer now thank you indeed we do have a couple of minutes left and we do have some questions here in the widget so coming from the top of the most scored ones Kevin has looked at the repositories and he has found the documentation but not really something actionable or easy to run to measure the apps how far are we from actual off the shelf tooling for these tasks for example would be needed for CI yeah so the tool which was used for the measurements which were done by the students at the Umber campus that was or you would pronounce it so the configuration for that is in the feedback repository so this automates basically clicking buttons moving mouse typing in so you can use that to repeat the usage scenario and you can use that back so it's a little bit fragile so there are certainly better ways how to do that I think especially for our applications probably the people who are familiar with the applications can find better ways how to automate that in a more reliable way so at the moment we have these axonal scenarios configuration there also is a little bit of experimentation so I try to do that with X2 tool which is just as fragile but in a different way and there are certainly other ways how we could do that so this is one of the topics of research also help with that, automating that is very welcome but also looking at these existing scenarios and the configuration which is there okay thank you very much and I guess one more won't hurt this is coming from Nate efforts to reduce consumption via improved efficiency encounters the Jevons products which is the increased efficiency simply incentivize more usage how do you think we can address this yeah I mean that's a very good point and as I said I think it's a very complicated topic also not all usage is the same so if you use for example green energy then maybe consuming this energy is not as harmful as if you don't and this paradox of course also is true and I mean you see that with software software hasn't become much faster it just has become more powerful and we do things in maybe different ways than before although the hardware has become much much powerful over the past couple of years so I think we have to look at it from a holistic perspective the important is measuring things so we have data so we can actually tell what is happening there so we can tell our software is becoming less efficient or more efficient but then also this other the more social or more idealistic approach to also look at these software factors look at what is reflected as user autonomy in the blue angel but I think we can also make this the bigger ideas or maybe consuming less something which can't really be justified from a technical point of view but you can find other ways how you can look at that so I think if we put together all these different factors the different views the values we also have I think in the KDE community we have strong values which go into this direction of working in a way that we can work in a sustainable way I think we can put this together it's not a guarantee that we will solve it and that we magically and energy consumption which is not necessary but I think putting a focus on the topic following the idea doing something about it will help us at least have a little bit of improvement and that's what counts right small improvements put on top of each other they give the big improvements yeah thanks one more sure we are coming from Niklas regarding that certification how does resource intensive software like 3D graphics or video rendering fit into this scheme I would assume they are inherently more demanding yeah we have to say that for the a big part of the certification in the current state is about making things transparent so measuring putting data and publishing that it's not so much about absolute numbers so it actually says in the criteria that they are not judging if an application is consuming an absolute maximum number of energy or something but that there is made an effort to make this transparent to measure it and so on and of course depending on the use case I mean if you do complex calculations you need more energy than if you just show something and nothing happens with this so I think that we are not there yet with really doing these comparisons across maybe different software categories even but it's more about creating awareness and being conscious about how much energy you consume and what effect your software actually have that software is a major factor in your energy consumption is something which is not obvious for some people also in some ways of thinking if you think about it I mean you see it you have a nice computer and you use it and you're happy that your battery life is becoming longer with a new device but then looking at what actually the data says and if the way how someone has an effect on it it's not easy to tell at the moment because we just don't have looked at that yet so from this point of view I think making data making measurements making data transparent and then looking at it and then you can judge in different categories what is necessary and if you can see you have this the game which is just as good as the other game but only consumes 10% of energy maybe that's an indication for people at least to prefer this game which uses less energy yeah makes sense okay we are out of time thank you very much Cornelius for the presentation and for answering the questions thank you great event really I'm really happy and proud to be part of it and join me for the both if you're interested in deeper discussions about the topic