So good, we're making very good progress here.
So now I'm going to talk about the last element of humor that we're using in this course, and that's
packages, as I said, you know, is very large.
And there's loads of stuff that we are talking about in this course.
So it's kind of only the core features that we talk about and use.
So this is packages and actually they are so important, actually.
So I'm going to have a whole section about packaging your model in the end.
But we'll take the ones we have actually tried actually creating some models because they have something
to package.
But just now we're going to talk about this syntax and.
So packages are used to decompose large animal models, so you we talked about that, you think about
concepts in terms of systems of concepts or networks of concepts.
We talk about net networks of intentional states and so on.
So you already have kind of a notion about which concepts relate to each other more or less.
And if you have loads of concepts in your model classes in your model, then you might need to start.
Then you might need to start decomposing into smaller chunks and then you use packages.
So here's an example.
So you might have the hammer plank and the activity of hammering and they all relate to maybe the carpentering.
So then you can have a package call that.
And they are then used to handle the complexity and modify ability of the model by decomposing it into
smaller chunks and thereby handling relations and dependencies between packages instead of between simple
classes so the packages don't depend on each other.
So you will have what is called dependencies was actually a third type of relation.
So there are basically three types of relations that we talked about now are associations which are
instantiated links, generalizations and dependencies.
So dependencies you have dependencies between packages and dependencies is a dotted line with an open
arrow UML.
The direction under dependency is derived directly from the ingoing elements, relationships and what
I mean with that.
So take an example.
So we have the three packages here.
The dependencies are are a function of the ingoing elements.
So here we have a class that is in association with another class, but they're in the same package
and hence you don't need an associate dependency here.
But then that class have a relation which is in this case, a generalization with yet another class,
and that is going in the downward direction.
And hence the dependency will have that direction as well.
And then we have a fourth class which have an association from the first another class from the upper
package, and that is have a navigability in that direction as well.
And hence they would also have a dependency going that direction.
And then lastly, we have an association from yet another class to a fourth class on an association
having an navigability in that direction.
And hence the dependency between the packages will go in that direction.
So we see the dependencies as a function of the ingoing elements, relationships, which could be both
generalisations, associations or actually even links.
So that's the derived dependencies of the packages of the packages.
So some packaging is so important, as I said.
So I'll spend the whole last section of this course talking about this and showing you how you package
and decompose a large model.
But it's a key feature to achieve, modify ability and the sound architecture in any type of system,
no matter if it's a business system or an IT system or any type of system, needs to be decomposed in
probably a logical way.
Very good.
So that was actually all.
I'm going to talk about packages now.
I just showed you where it is and how and how they depend on each other.
And that dependency is derived from the ingoing elements relations.
Very good.
So now we actually going to rush off into the section where we talk about how you practically do this.
So now we're going into method and practice.