 Hey, yeah, as you can all read on those wonderful slides. I'm here to teach you how you too can make things go fast Making things look fast is easy. There's like a hundred box posts about on the internet everywhere. You just do less Doing less work means doing faster work. You catch things you reduce the number of resources you use. It's all easy It's no problem. But the problem is what is actually slow? Where do we need to make things go faster? And that's what I'm here to teach you The obvious solution is to measure things measuring helps us decide what to do. So we measure We find out it's something fast something slow. I mean, sorry an upload takes so long. I click on a button It doesn't respond for five seconds. We measure them We measure what code is being used. We measure how long it takes to run the code We make a change. We see if it fixes shit. And if not, we keep trying There's tools for that like black fire Also Xtberg has some building tools for it. There's plenty of things out there, but that has a limitation It doesn't tell us what the code is actually doing. It only tells us what is taking slow under specific request Instead we want to look at what the code is actually doing what resources do we use? Do we make a lot of file system operations? Do we make a lot of database calls? but in tools like This that measure just the time something takes that doesn't always tell us the problems So we have I just made this wonderful tool called xray But it let's you let you look inside of your next cloud instance and tells you exactly what each request is doing It tells you all the resources that are being used in real time what file system calls are being made the locking operations Caching operations database queries so you can have proper all with full stack traces You can have proper ID as a developer about what the fuck your code is actually doing and why things might be slow But the main problem with that is that if code is not slow, you're not going to fix it If you really want to make sure that every that you fix something you have to be frustrated by it It's called I call it frustrated frustration driven development If you if you use your if you use your next cloud instance at home Or is your developer instance your own production instance and things are slow you get frustrated you want to fix that shit So you improve them That's the main problem though Your computer is way too fast Like you just recently bought a nice new wonderful laptop that has like a lot of gigabytes of RAM You put all the sliders in the configuration up all the way to maximum because you want to show off with your fancy hardware And it means that everything goes nice and fast. It's great except when you don't want things to go fast On your local in your developer incident you're working on it your Database from locally all your storage runs locally on SSD It's all way too fast that you don't actually see the problems that real large setups are running into because they have remote resources So to solve that problem I wrote the two only apps that objectively make your next cloud experience worse They add artificial delays to common things that might be that are slow on a lot of larger incidents But are probably really fast in your instance If you ever every file system operation or every database query we can make it slow So you can really feel the suffering that real users run into while you're developing your app So you immediately see that your app is doing something wrong without even having to look at it If everything is false, it's really easy to accidentally write some code that uses a lot of database queries And you never figure out that's a problem because you have an amazing PC So with these two apps that you can find on GitHub you can make your PC less amazing