 Okay, so now that we discussed how this is used in industry, let's look a bit at what we actually mean by doing something with models using them as the primary artifact. So in general, what we have is a source model, that's the model we discussed all the time. We create some model, a UML model for example, and we want to get something out of there. And what we usually call this is a target model. So we also call this a model, but this could just as well be code. So for example, this could be Python code, and this could for example be a UML model. Now we have already discussed that what we have that does this, that transforms source model into target model is a transformation, which basically reads this and creates the target model. And as I discussed, this is some kind of code, this could be general code like CEO Python code, this could be a specific transformation language. Now what does this transformation need in order to work? It needs to understand what the source model is and what kind of notation it is and needs to know how the target model should look like. So what it needs is a source language, a source notation that it understands and that could for example be the UML language. It knows the UML language so it can create. And this transformation basically understands, it knows the source language. And the same goes for the target model. This is in a certain language, so there is some kind of target language. For example in our case it's the Python language, so in order to create Python code it needs to know for example the syntax of Python. So that's essentially our transformation chain, we have a source model that we transform into a target model and in order for that to work, the transformation needs to know what the source language is and what the target language is. And these somehow need to be formally described. This might sound a bit strange to you, but that's exactly pretty much what a compiler does. So if you have for example C code here and you want to run that you have the transformation as the compiler. The transformation needs to understand what the C language is and it needs to know what to compile it into. For example some kind of assembly or machine code that can be run directly. An interpreter would do something very similar in a way. It reads in the target language like Python or Java. It needs to understand that language and it kind of converts it into some running representation that directly runs it. So this is something you are using every day. If you're programming it's just we're talking about UML here for example, but that's pretty much what a compiler does as well. So that's generally how this works. And the reasoning behind this is if we for example talk about code generation is that we very often have a code that is generic. So no matter what you're writing, what kind of application you're writing you'll always have the same code here. This is technically something you could generate. Then we have code that is not generic. It depends on the application, but it's at least repetitive. So it's similar and you just need to change it slightly depending on the application. For example the way a database schema looks like or if you use an object relational mapper for a MySQL database is very repetitive code. Or you have certain framework code if you want to use a front end framework like React for example. The code is at least repetitive. It definitely depends on the application but it's very similar and it feels like you are just writing the same kind of things. Test case code is often the same. And then finally you do have your individual code and that's really the thing that is very application specific where it maybe is not that easy to generate it from somewhere else. So if you take an example, if you have for example a three layer architecture and we would have the UI layer that then talks to the business logic layer that then talks to the persistence or let's say the database layer. Then you have at all levels you have certain generic code for example some kind of initialization for your HTML page or the framework. You have maybe standard authentication here that you are using that is just the same code all the time and you have a standard object relational mapper for example. There is certain repetitive code like UI components. The flow between pages is maybe the same all the time. Again in your schema or in your object relational mapper you might have certain code. It's very repetitive and then finally you have the individual code and that's certainly in this case it's maybe restricted to actually the UI. There are some special things for the user experience or having a certain look and definitely the business logic. What is your software actually about? What is it doing like the rules, the behavior that might be individual but the idea is that a lot of these two boxes here a lot of that you could generate if you had a model that would make this much much simpler. So that's roughly the idea here but as I said before you need to have these models you need to have a source model you need to know what you transform it into and for that you need your transformation that basically understands the two models. So if you want to generate a UI you have to have some kind of source model for example the UML model and you need to know the target language like HTML or JavaScript or anything like that. Okay, let's go into some more details with this example and then we wrap up.