 So, I had a student working on refactoring God objects, and this is not directly a user-visible feature or anything like that, it's mainly about the internals. So, the problem was that we have a few classes, especially the classes that represent the documents in the applications that are just very, very large. They have lots of methods and members. And, for example, the SWDoc, which is a writer document, has a declaration that is 1,800 lines long, just with the members and methods. And no implementation yet. So, there is a lot of tight coupling of various different parts of the application. It's a model going on there. And the header file also includes lots of other headers that are needed for the members and so on. And the result of that is that if you change any of those headers, you basically rebuild all of writer and that takes a long time. So, another problem was that the implementation of the SWDoc class, all the methods, distributed widely across many, many files. So, it was also difficult to find the implementation methods. So, but there was a bit of hope for it because we already had some predefined, some previously existing interfaces. They all started iDocument. So, for example, iDocument field access contains some methods for text fields and so on. And these interfaces did already exist, but the problem was that SWDoc implemented all the interfaces directly itself. So, what Valentin did during the desoc is that he created a new class for every interface. And that new class then has the implementation of these methods and the members that belong to this bit of functionality. And so, all of this code is moved out of the SWDoc class. So, what has Valentin achieved during the summer? As I said, there are now these separate classes and the SWDoc class is much smaller and has all these get iDocument methods that basically just retrieve an instance of the class that then has the implementations of it. So, also, we have coupled things a bit in that the user interface code, no longer the actual implementing classes are not visible to the user interface code. The user interface code only sees the defined interfaces. And so, we have achieved a bit of decoupling in that way. And so, as a result, the SWDoc declaration is much shorter now. It is now only, I think, 1,300 lines or something like that. And it's over 400 lines shorter. And for every single one of these new classes, we have one CXX file that contains all of its implementation. And so, it is also easier for developers to find implementation of something. And all of this is already integrated in master. And so, we have basically achieved the goals of the SWDoc project. But there is still, the situation is still not optimal. SWDoc is still a bit too big, which is mainly because there are lots of additional methods that did not belong to any of these existing interfaces. We have also moved a bunch of the methods into the implementation classes, but there are still a lot left. And so, there is still work to do in that area. And of course, also, I imagine that the other implementations like Impress and Kalk have perhaps similar problems. So, they are probably not as severe as in Writer. And so, similar things could probably be done in the other applications. And, yeah, that's it.