 Hello, everyone. This is a bit of a detour now of completely technical talk on optimization of Next Cloud apps. These are lessons learned from building the Memories app, which is a community-maintained app. I'll talk about it. So just before I get started, it's a bit short time. And this may not necessarily reflect what's the best way to optimize your app. And of course, don't optimize unless you know you need to, because that's not going to help. So what is Memories? It's a community-supported, community-maintained photo manager for Next Cloud. It's got stuff like exit support, a timeline editing of exit data, transcoding live photo support, and so on. And there's a demo there. But if you think that's not very fast, it's because the server is in San Francisco. But Memories is fast. It's really fast. It's got on a reasonably cheap server, $100. It can render a timeline of 15,000 photos in just less than a second. So what makes Memories really fast? So the first lesson learned is that if you want to optimize an app, you have to do it across the spectrum. Optimizing any one of these four is not going to work out. And so I'm going to try to talk about each of them very shortly. So I'm assuming that this is about building a PHP app. But now, of course, you can't build them in any language, thankfully. Starting with memory caching and background jobs. So these are very simple. The reason I put them here is because they're so easy, but also easy to overlook. You literally have a beautiful interface for memory caching in NextCloud. You can just create a cache, put data in the cache, get data from the cache. And that's going to help your performance a lot, which Memories uses. And you can do background jobs. For long-running tasks, you can set a background job, not do it on every request, but do it as a cron job. Again, a beautiful interface that NextCloud provides. More advanced, when you're building a PHP app, each request is going to cause a lot of bootstrapping. Every app that you have installed in your NextCloud instance is going to get initialized. It's going to register hooks. And this PHP architecture really makes it very easy to scale. But at the same time, it makes each request a bit more expensive. And so what you can do to optimize is do more in one request rather than making many smaller requests. For example, what Memories does is instead of loading one thumbnail with one extra request, it uses one request to load multiple thumbnails. And this simple optimization actually cut down CPU utilization by almost like 50% to 60%. The second is database optimizations. And here, the important lesson for me, at least, was that databases are really fast. And so assuming that something will be slow is not always the right thing. As long as you do basic stuff like create an index, use joints as very possible. And your queries should be really fast, even if they look very complicated. And of course, if they are not fast and explained, we'll tell you what you can improve on. A bit more advanced example on how you can actually leverage a database in the way Memories does to speed up your application. This is a commentable expression which goes over the NextCloud file cache and walks recursively inside a directory to find all the folders inside the directory and then treats that as a table. And this is extremely powerful. That means you can scan a directory inside your NextCloud file system and do something like a join on your application's table and filter results out of it. So you can leverage the database to do really powerful things like this. And this query is really, really fast because it's indexed very well by NextCloud itself. Of course, this might not be the best practice because it's not super maintainable. The third thing was front-end optimizations. Here, obviously, the big one is lazy loading, not only data, but also your components themselves. So JS parsing is still slow in 2023. And so that means if you try to lazy load your components, you will get a significant boost in your performance. And one more overlooked API is the cache API of the browser, which likes to explicitly put things in your cache. And this can help a lot because you make your cache much more explicit in your front-end. And finally, this one was a hard-end lesson, is that deployment is just as important as all of the first three. And that involves warning the admins when they're doing something or when the configuration is not right, when something is missing that keeps your application from being fast. And that's because NextCloud deployments are very heterogeneous. You will find things on Linux, PHP, Linux, FreeBSD, and in Docker, without Docker, all different kinds of versions, and so on. And finally, keep measuring performance if you're trying to build a high-performance app. Don't guess. Use a profiler. And that was, again, a hard-end lesson because performance bottlenecks tend to be in places where you least expect them. And handing off to Simon. Thank you.