WEBVTT 00:00.000 --> 00:07.000 All right, we'll get started. 00:07.000 --> 00:12.000 The next speaker was supposed to be at the aim, but he couldn't make it. 00:12.000 --> 00:14.000 So Mark is filling in for him. 00:14.000 --> 00:17.000 And he's going to get a talk from the environment of this boy. 00:17.000 --> 00:18.000 So, hi, everybody. 00:18.000 --> 00:19.000 I'm Mark. 00:19.000 --> 00:20.000 I'm working at CES. 00:20.000 --> 00:23.000 So, as Kenneth said, let me change. 00:23.000 --> 00:26.000 So, please be lenient with me. 00:26.000 --> 00:28.000 Xavier and I are working at CES. 00:28.000 --> 00:32.000 We are a French government institution, a research institution. 00:32.000 --> 00:37.000 And we are operating the HPC systems and a language. 00:37.000 --> 00:40.000 Alice Rokok, that would be the second, 00:40.000 --> 00:45.000 a European-exescal system that would be installed in two years or so. 00:45.000 --> 00:49.000 So, today I'll talk about environmental modules. 00:49.000 --> 00:53.000 And we discuss why it is all ID, is still useful today, 00:53.000 --> 00:55.000 and what's next for the project. 00:55.000 --> 00:58.000 So, for those who are not familiar with module, 00:58.000 --> 01:05.000 module or environmental module is a tool that allows you to manage your environments within 01:05.000 --> 01:08.000 shell session or shell scripts. 01:08.000 --> 01:14.000 The building blocks of module are script files that are called module files, 01:14.000 --> 01:17.000 in which you will define your environments. 01:17.000 --> 01:20.000 So, here is a very simple example of a module file. 01:20.000 --> 01:24.000 And then, if you need a software or library or something like that, 01:24.000 --> 01:29.000 if it's not available in your environments, you can load it with the module load command, 01:29.000 --> 01:32.000 and then it will be available in your environments. 01:32.000 --> 01:37.000 And you can undo this seamlessly, so you can unload the module, 01:37.000 --> 01:43.000 and you go back to a clean slate without this software on your environments. 01:43.000 --> 01:45.000 So, how does it work? 01:45.000 --> 01:47.000 There are three main components behind the hood. 01:47.000 --> 01:51.000 The first one is module cmd.cl, so it's a TCL script 01:51.000 --> 01:56.000 that will evaluate the module file I showed you earlier, so the first one. 01:56.000 --> 02:03.000 It will evaluate it, and it will scale out the environment 02:03.000 --> 02:06.000 and change that are described in the module file. 02:06.000 --> 02:08.000 So, here is an example. 02:08.000 --> 02:14.000 We will evaluate the content of a module file for bash scripts. 02:14.000 --> 02:19.000 We will use the subcommand load, and we will do it for the module file full. 02:19.000 --> 02:24.000 And you see that we will update paths, and we will define some variables that will be useful internally for module, 02:24.000 --> 02:27.000 to know what modules are actually loaded. 02:27.000 --> 02:32.000 Then, there is a second component that is a script function named module. 02:32.000 --> 02:42.000 It's where the magic happens, and basically here we are just doing an evaluation on what was spelled out by the module cmd.cl. 02:42.000 --> 02:47.000 So, we are just calling this the first script I showed you, 02:47.000 --> 02:51.000 and we will evaluate it, and it will update our environment. 02:51.000 --> 02:54.000 So, where module is used for? 02:54.000 --> 03:00.000 The first usage main usage probably is to access software catalogs on HPCC systems. 03:00.000 --> 03:05.000 It's very handy when you have different versions of the software version 1, 2, 3, and so on. 03:05.000 --> 03:11.000 Our different versions of the software in terms of compiling tool chain. 03:11.000 --> 03:15.000 So, it's on most super computers today. 03:15.000 --> 03:19.000 It's also interesting because it's a shell-agnistic environment. 03:19.000 --> 03:27.000 So, whatever the shell you're using, being bash, TCSH, fish, it will work. 03:27.000 --> 03:34.000 And you have a common interface to access your software's libraries. 03:34.000 --> 03:40.000 And one thing that is interesting, it's mostly used to handle software, but actually it's an environment tool. 03:40.000 --> 03:44.000 So, you can manage your environment, and since you can interact with your environment, 03:44.000 --> 03:50.000 there are lots of libraries or software that are configured by environment variables. 03:50.000 --> 03:54.000 So, you can actually manage your configuration thanks to module. 03:54.000 --> 03:57.000 And that's what we do for example, it's here with MPI. 03:57.000 --> 03:59.000 So, module is an old story. 03:59.000 --> 04:01.000 It's starting in 1991. 04:01.000 --> 04:05.000 It actually predates both Linux and MPI, so it's really old. 04:06.000 --> 04:13.000 It went through lots of hands across the 30-plus years of its life cycle. 04:13.000 --> 04:20.000 And in 2012, unfortunately, the project was an halt for a few years. 04:20.000 --> 04:25.000 And then it was taken over by Xavier. 04:25.000 --> 04:32.000 And in 2017, you released module 4, and since then, it's in another active development. 04:32.000 --> 04:35.000 So, you can find it at GitHub, or of course. 04:35.000 --> 04:39.000 Module 3, the TCL is about 15,000 line of codes. 04:39.000 --> 04:41.000 It's in our GPL 2 license. 04:41.000 --> 04:45.000 There are two new feature releases per year. 04:45.000 --> 04:51.000 And within those releases, you will have five significant new features. 04:51.000 --> 04:55.000 So, those features are impactful for the users. 04:55.000 --> 04:57.000 They are really interesting at new things. 04:57.000 --> 05:01.000 And about 50, minor changes every time. 05:02.000 --> 05:05.000 Module development is based on a test-driven development approach. 05:05.000 --> 05:12.000 So, there is a huge non-regression test base with more than 22K tests, 05:12.000 --> 05:17.000 with a 99.5 coverage, which is pretty good. 05:17.000 --> 05:25.000 And the test suite is six times the module CMV.tcL, so huge test suite once again. 05:25.000 --> 05:30.000 And an important point is that the module project is really listening to the community, 05:30.000 --> 05:36.000 to the users, to the C-fnmns, and to the nearby communities like SPAC, EasyBuild, 05:36.000 --> 05:41.000 Almod, we are really integrated within the communities. 05:41.000 --> 05:46.000 Here is a non-complete list of new features in 2017. 05:46.000 --> 05:50.000 If you want to have all the details, you can flash code this. 05:50.000 --> 05:55.000 And I will just go through two features that might be interesting for you. 05:55.000 --> 05:58.000 The first one I want to mention are Viens. 05:58.000 --> 06:04.000 So, the basic idea behind Viens is that the module files are scripts, 06:04.000 --> 06:08.000 and since they are scripts, you can pass arguments to your scripts. 06:08.000 --> 06:14.000 And with the arguments, you can interact with the way you will set up your environments, 06:14.000 --> 06:18.000 or the tool chain you will use, and so you can do everything in a single module file. 06:18.000 --> 06:22.000 So, it's much more handy that what we are doing previously, which lots of module files. 06:22.000 --> 06:24.000 And we are using the SPAC terminology. 06:24.000 --> 06:28.000 So, those who are familiar with SPAC variants, it's very similar. 06:28.000 --> 06:30.000 We have Boolean variants and valued variants. 06:30.000 --> 06:33.000 And here is an example. 06:33.000 --> 06:36.000 So, imagine that food is actually HGF5. 06:36.000 --> 06:39.000 If we use the M.C. variant that is Boolean variants, 06:39.000 --> 06:44.000 it would mean that we would use the parallel version of HGF5 instead of the second one, 06:44.000 --> 06:48.000 and we can specify the tool chain so the way HGF5 is compiled. 06:48.000 --> 06:53.000 In terms of a module file, the implementation is pretty easy. 06:53.000 --> 06:58.000 You define a module, then you can evaluate and you can change your environment accurately 06:58.000 --> 07:00.000 to the variants you are using. 07:00.000 --> 07:05.000 You can use shortcuts, so it can ease again the use of variants, 07:05.000 --> 07:09.000 and you can have a syntax that is really close to SPAC. 07:09.000 --> 07:12.000 We also introduced activity logging. 07:12.000 --> 07:17.000 So, previously, it was possible to have some logging with hooks, 07:17.000 --> 07:19.000 but no, it's really out of the box. 07:19.000 --> 07:28.000 The interesting thing is that since we can push logs within the log system of the system, 07:28.000 --> 07:36.000 then we can rely on a traditional stack like ELK to have statistics on the module usage. 07:36.000 --> 07:41.000 And here is a very simple example, so you can define the logger, 07:41.000 --> 07:45.000 which command you will use to log, and you can log different kind of events. 07:45.000 --> 07:49.000 So, the command you launch, the evaluation, if you have auto evaluation, 07:49.000 --> 07:52.000 and here are examples, we launch a few commands. 07:52.000 --> 07:57.000 So, you see that we trace the command available, the command load, 07:57.000 --> 08:03.000 and then there is an evaluation for loading the app that we see also here. 08:04.000 --> 08:10.000 I have to mention that an environment module is not the only module implementation in the wide. 08:10.000 --> 08:12.000 There is also ALMOD. 08:12.000 --> 08:17.000 ALMOD is written in LUA, it was the development started in 2008. 08:17.000 --> 08:20.000 It is developed by Rob McCliff from Attack. 08:20.000 --> 08:29.000 And the main difference between an environment module and ALMOD is that ALMOD can evaluate TCL and LUA module files. 08:30.000 --> 08:34.000 ALMOD is actually very popular across HPC sites. 08:34.000 --> 08:39.000 And there were many features, very interesting features that were introduced when module was not. 08:39.000 --> 08:43.000 So, at some point, it was really in advance to compare to module. 08:43.000 --> 08:47.000 Among those features, you have module hierarchy, module cache, and so on. 08:47.000 --> 08:54.000 And as of today, it is probably the most used and the most deployed module tool in the HPC world. 08:55.000 --> 08:59.000 I have also to mention that the both project are recolaborating. 08:59.000 --> 09:07.000 The idea is that the user experience will be the same, where you are using ALMOD module. 09:07.000 --> 09:12.000 One interesting feature I mentioned from ALMOD is the module hierarchy. 09:12.000 --> 09:18.000 So, the idea of module hierarchy is that you can hierarchically organize your module files. 09:18.000 --> 09:21.000 So, you have a kind of first layer of module files. 09:21.000 --> 09:28.000 So, in your module pass, you will have just one pass with core modules, and you will see only that. 09:28.000 --> 09:38.000 And once you are loading one of the modules, then you will update your module pass with a new module pass that will expose other module files. 09:38.000 --> 09:46.000 And if you have a change in your environment, if you change one of the core modules, it will automatically reload the module. 09:46.000 --> 09:51.000 So, here is an example, imagine that you loaded boost, compile with GCC. 09:51.000 --> 09:56.000 If you change the compiler, it will change automatically GCC. 09:56.000 --> 10:00.000 So, we are implementing module hierarchy in module. 10:00.000 --> 10:03.000 It should be available this year. 10:03.000 --> 10:06.000 And actually, we implemented it with the twist. 10:06.000 --> 10:10.000 So, we have an automated handling mechanism. 10:10.000 --> 10:16.000 So, it is a bit for a step forward compared to the module hierarchy. 10:16.000 --> 10:22.000 We are trying to reuse IDs that comes from CISN mean and system package management. 10:22.000 --> 10:26.000 And to be able to deal with requirements and conflicts efficiently. 10:26.000 --> 10:31.000 So, the idea is for the user to have something that is really consistent. 10:31.000 --> 10:35.000 So, imagine you load a first version of a module. 10:35.000 --> 10:38.000 It will load the requirements. 10:38.000 --> 10:47.000 Then, if you load another version of this module, it will handle automatically the unloading of the conflicting module. 10:47.000 --> 10:49.000 And it will load the right module. 10:49.000 --> 10:54.000 So, it is much more easy to use, much more seamless for the users. 10:54.000 --> 10:57.000 So, module is a very well known interface in the HPC world. 10:57.000 --> 11:00.000 It was used for more than 30 years. 11:00.000 --> 11:03.000 So, it has some useful for sure. 11:03.000 --> 11:09.000 But since the 90s, lots of tools to install a scientific software appeared, 11:09.000 --> 11:12.000 along with easy-built SPAC geeks. 11:12.000 --> 11:15.000 You probably know all those tools. 11:15.000 --> 11:25.000 And if we take SPAC or geeks, for example, they actually do not need a module tool to provide their software. 11:25.000 --> 11:29.000 So, they have built-in functionalities to access the software. 11:29.000 --> 11:33.000 So, it is module still useful. 11:33.000 --> 11:36.000 We think that, yes, module is still useful. 11:36.000 --> 11:42.000 Because it is a common interface, whatever the tool you are using under the hood. 11:42.000 --> 11:47.000 It is also interesting for sites that are working in a federation. 11:47.000 --> 11:50.000 So, that is typically the case for your HPC. 11:50.000 --> 11:53.000 We have users moving all across European sites. 11:53.000 --> 11:57.000 And to have a single interface, it is easier for our users. 11:57.000 --> 12:02.000 And it is also useful when you have different tools used simultaneously. 12:02.000 --> 12:04.000 And that is what we do at C actually. 12:04.000 --> 12:07.000 We are using both easy-built and SPAC. 12:07.000 --> 12:13.000 We built our software stack with the tools and we access them with module with a common interface. 12:13.000 --> 12:18.000 And I already mentioned it that module is not only a tool to access software, 12:18.000 --> 12:21.000 but it is an environment management tool. 12:21.000 --> 12:24.000 So, it means that you can manage the configuration of your software. 12:24.000 --> 12:27.000 That is what we do with MPI at CE. 12:27.000 --> 12:29.000 And you can also manage data endpoint. 12:29.000 --> 12:32.000 So, for example, on our clusters, we have users that have different projects. 12:32.000 --> 12:38.000 They have different data on the file systems linked to those projects. 12:38.000 --> 12:41.000 And we can manage that with module directly. 12:41.000 --> 12:47.000 So, glimpse in the future, there are two functionalities I want to mention. 12:47.000 --> 12:55.000 The first one is the idea is to have an adaptable view of the module that you will see. 12:55.000 --> 13:00.000 So, right now, if you launch the module that I recommend that we list the module that are available to you, 13:00.000 --> 13:01.000 you'll see everything. 13:01.000 --> 13:08.000 And if you try to load the module that is not compatible with the module you already loaded, you will have a conflict. 13:08.000 --> 13:14.000 And note the idea is that we want to implement something that if you launch this module that I recommend, 13:14.000 --> 13:21.000 you will see only modules that are compatible with your current states of the current state of your environment. 13:21.000 --> 13:33.000 Another feature that is in the development is to hook, to use, sorry, hooks that are available in modern shell, bash, the usage fish. 13:33.000 --> 13:42.000 If you launch a common that is not fine, it can actually trigger a prompting offering to install the software. 13:42.000 --> 13:50.000 And we could use this hook, so instead of offering to install the software, it could offer to use a module that is installed. 13:50.000 --> 13:55.000 The idea comes from the me project, but the me project is not an adult. 13:55.000 --> 14:04.000 And also, if it's integrated directly to module, we could benefit from the module cache that is already implemented. 14:05.000 --> 14:10.000 And sky is the limit, so we are really open to any suggestion for the community. 14:10.000 --> 14:14.000 For example, if you want a lower support, we could do it. 14:14.000 --> 14:22.000 At some point, module CMD, the TCL, might be a written in another language, like Python or Rust, because TCL is not very popular. 14:22.000 --> 14:31.000 And it can be interesting to use another language, more mainstream language, to help you contribute to the project. 14:31.000 --> 14:36.000 Our long-term vision is that module should be the glue between the different package managers. 14:36.000 --> 14:41.000 As I already mentioned, you can use different package manager and have module on top of that. 14:41.000 --> 14:54.000 And actually, we could even use the building functionality, the query tools you have on those tools to access the software catalog. 14:54.000 --> 15:03.000 And if you want any specific development or expertise, you can also ask that, that is the new Xavier self-company. 15:03.000 --> 15:09.000 So it's offering development and expertise on module and ecosystem. 15:09.000 --> 15:22.000 So it's for very specific development, don't hesitate to ask him, if you need to move from one version to another or something like that. 15:23.000 --> 15:26.000 So Greg mentioned HPSF. 15:26.000 --> 15:34.000 So the module is actually in the process of joining the hyperform software foundation. 15:34.000 --> 15:40.000 We are at the stage of drafting the governance and the technical charter of the module projects. 15:40.000 --> 15:48.000 The project has been moved from the CE, the CE GitHub to an independent GitHub. 15:49.000 --> 15:52.000 Independent GitHub projects. 15:52.000 --> 16:02.000 And the idea is to be able to transfer seamlessly the IP to the Linux Foundation and to facilitate future and over. 16:02.000 --> 16:07.000 And so in this process, we're looking for additional maintenance to join the project. 16:07.000 --> 16:09.000 So don't hesitate to join us. 16:09.000 --> 16:25.000 We're going to start to develop within module but also to be part of the project to be part of the to define the roadmap to make the community lively community with the mailing list, the chat and so on. 16:25.000 --> 16:31.000 So key takeaways module is an active project, it's an ongoing development. 16:31.000 --> 16:35.000 We are trying to constantly add new features. 16:35.000 --> 16:38.000 If you have any ideas, please come to us. 16:38.000 --> 16:41.000 We're very happy to collaborate with the ecosystem. 16:41.000 --> 16:47.000 There are still many new things that could be integrated to ease the life of users and of CCN means. 16:47.000 --> 16:52.000 Once again, we are happy to collaborate with the community and with other projects. 16:52.000 --> 16:58.000 And actually the idea is actively contributing to to easy to expect to help model. 16:58.000 --> 17:01.000 And we're an open community. 17:02.000 --> 17:14.000 And so here are where you can find us on social media on GitHub and we're very happy to have no chat and metrics. 17:14.000 --> 17:16.000 So come talk to us. 17:16.000 --> 17:17.000 Thank you. 17:17.000 --> 17:27.000 All right, we have time for a couple of questions. 17:28.000 --> 17:37.000 Questions that this review will recommend to use the cloud model for activating item values. 17:37.000 --> 17:39.000 There are different things. 17:39.000 --> 17:42.000 Do you think we have the question? 17:42.000 --> 17:46.000 Do we recommend to use a different way? 17:46.000 --> 17:52.000 Can we actually invite us? 17:52.000 --> 17:54.000 So the question is. 17:55.000 --> 17:59.000 Do we recommend to use module for Python environments? 17:59.000 --> 18:04.000 That's a very good question and it's actually a kind of a mess. 18:04.000 --> 18:07.000 And there are very different ways of doing it. 18:07.000 --> 18:10.000 What I can say is what we are doing at C8 to deal with this question. 18:10.000 --> 18:13.000 So as I mentioned, we're using both EVB and Spark. 18:13.000 --> 18:16.000 But for Python, we are building our Python distribution with Spark. 18:16.000 --> 18:19.000 Because we're building everything from scratch. 18:19.000 --> 18:22.000 We want to to compile everything ourselves. 18:22.000 --> 18:25.000 We're not relying on condo our people. 18:25.000 --> 18:27.000 And so we build everything with Spark. 18:27.000 --> 18:30.000 And then we can do a view that is accessible with modules. 18:30.000 --> 18:34.000 So we can module load this Python distribution. 18:34.000 --> 18:37.000 It's not as flexible as virtual environments. 18:37.000 --> 18:42.000 But we have something that is a bit monolithic that we can guarantee that is working. 18:42.000 --> 18:49.000 So I think that's a good way of doing it to guarantee a good stack. 18:49.000 --> 18:53.000 It's guaranteed by the HPC team. 18:53.000 --> 18:59.000 And then you can build your virtual environments on top of that. 18:59.000 --> 19:04.000 More questions? 19:04.000 --> 19:09.000 I have one. 19:09.000 --> 19:12.000 Correct. 19:12.000 --> 19:17.000 If I'm wrong, but I think Elmo the security is more popular. 19:17.000 --> 19:20.000 If you have a patient of the environment, what was concept? 19:20.000 --> 19:22.000 Part of that is because of the history. 19:22.000 --> 19:24.000 There was this was not activated. 19:24.000 --> 19:26.000 Made in for the second. 19:26.000 --> 19:28.000 That's a way to pick it up. 19:28.000 --> 19:31.000 And then made it a very lighty project together. 19:31.000 --> 19:35.000 Do you see that flipping back to this becoming more popular than Elmo? 19:35.000 --> 19:38.000 And if so, why would that happen? 19:38.000 --> 19:43.000 So the question is, Elmo is more popular at the moment. 19:43.000 --> 19:51.000 And do we see an environment module being the most popular modular environments in the future? 19:51.000 --> 19:59.000 So for sure, Elmo is the most popular module implementation at the moment. 19:59.000 --> 20:04.000 And as you said, the history is, can explain that. 20:04.000 --> 20:09.000 And there were lots of new features that were really interesting in implemented in module. 20:09.000 --> 20:11.000 And we are still catching up. 20:11.000 --> 20:17.000 So actually, the very last break for us, the very last feature that is in Elmo that was not in module, 20:17.000 --> 20:20.000 will be implemented this year with the hierarchy. 20:20.000 --> 20:26.000 So finally we catching up, but it took us almost a decade to catch up with Elmo. 20:26.000 --> 20:35.000 So then, which implementation would be the most popular. 20:35.000 --> 20:40.000 I don't really know, but we are trying to make module sexy again. 20:40.000 --> 20:43.000 With interesting features, new features. 20:43.000 --> 20:47.000 We are trying to go a bit further than some things that were in Elmo. 20:47.000 --> 20:53.000 And we, so Xavier is a real, is a system in that core. 20:53.000 --> 20:58.000 So he tried to push a system in ideas within module, 20:58.000 --> 21:03.000 especially in the way of managing requirements, dependencies and so on. 21:03.000 --> 21:10.000 So there might be features that are well adapted to our systems, things to that. 21:10.000 --> 21:16.000 And it might be interesting, at least to try again module if you are using Elmo to see if it can answer. 21:16.000 --> 21:23.000 If you can answer your questions, your problems. 21:23.000 --> 21:25.000 Any more questions, yes? 21:25.000 --> 21:28.000 Yeah, maybe a question regarding support for our screen development. 21:28.000 --> 21:34.000 So if you look at the spec for pipeline, it's very easy to make your own application available. 21:34.000 --> 21:37.000 There's something that you envision for modules. 21:37.000 --> 21:43.000 Or would it then be via the spec route that provides a spec upping package or something like that? 21:43.000 --> 21:49.000 Then I can tell someone if you want to install my application on an HPC system. 21:49.000 --> 21:56.000 It's easy because I did the work regarding modules for you already as an software development. 21:56.000 --> 22:04.000 So the question is, can module kind of replace spec or other tools like that to for installation? 22:04.000 --> 22:09.000 Actually, we are not exactly in the same field, because we are not providing a way of installing software. 22:09.000 --> 22:16.000 So you still need easy build or spark or easy or geeks or whatever. 22:16.000 --> 22:20.000 We are just providing a way to access the software. 22:20.000 --> 22:25.000 And so we are not providing kind of recipe. 22:25.000 --> 22:28.000 If you need your module phase, you have to write them. 22:28.000 --> 22:32.000 But the thing is we are collaborating with the other projects. 22:32.000 --> 22:36.000 So the module can be automatically generated. 22:36.000 --> 22:43.000 So right now, spec you can really use only spark internals and spec commands. 22:43.000 --> 22:49.000 But you can also generate modules, module files with spec and then directly use module. 22:49.000 --> 22:50.000 So that's the idea. 22:50.000 --> 22:55.000 We want to, the idea is that you can have the freedom you want. 22:55.000 --> 22:59.000 You want to stay with spec, good for you, continue using spec. 22:59.000 --> 23:05.000 You want to use module, you should be able to use it seamlessly because we should be able to generate automatically the module you need. 23:05.000 --> 23:09.000 Okay, thank you. 23:09.000 --> 23:12.000 Maybe one more? 23:12.000 --> 23:13.000 Yeah. 23:13.000 --> 23:33.000 Can we, can we deal with different environments depending on the nodes? 23:34.000 --> 23:37.000 And yes, that's actually what we do. 23:37.000 --> 23:44.000 Because we have systems with different architectures and we have to deal with that. 23:44.000 --> 23:49.000 And that's something that can be done easily. 23:49.000 --> 23:53.000 More or less easily, and it will be much easier with variance. 23:53.000 --> 24:02.000 So at the moment, we are doing it at CE using some specific modules and some ways of loading. 24:03.000 --> 24:05.000 Requirements. 24:05.000 --> 24:13.000 And with variance, it could be very easy to do because you could just add a variance and then it corresponds to your target architecture. 24:13.000 --> 24:20.000 And you could have automatic detection of the architecture and load the right modules. 24:20.000 --> 24:26.000 So that's something that is totally doable, yes. 24:26.000 --> 24:27.000 Thank you. 24:27.000 --> 24:30.000 Thank you.