In this chapter, you looked at some techniques you can use to ensure that the code you write is as robust and maintainable as possible.
You started by looking at the MVVM architectural pattern and saw how it can give your applications a great separation of form and function. This enables you to work on user interfaces independently of other code, which is great for teams of developers and designers. There are a few challenges to overcome when writing in MVVM, such as mapping events to commands, but none of them are terribly difficult. This is where third-party frameworks come in, as they generally include a lot of boilerplate code so that you don't have to write it yourself.
In this chapter, you also looked at unit tests and saw how you can write code that can test the functionality of other code without requiring you to manually work through your application's user interface. This can save you a lot of time and effort, especially in cases where later changes can break existing code logic.
Combining patterns such as MVVM with third-party frameworks and unit testing takes a little bit more effort than simply hammering out code, but the end result is worth it. Rather than having flimsy code that hangs together as much by luck as technique and that is impossible for other developers to understand, you end up with proper, production-ready code that you can be proud of.