Initial commit

At the first meeting, we have discussed with the client about the software we
are going to make, and we have come up with the requirements described in
`0001_requirements.txt`.

Please read this text file first of all.

From this text file, we have tried to identify different entities like actors,
classes and events. Please note that, since we are in the analysis phase,
"class" does not necessarily imply that there will be those classes in the
code. Classes during this stage merely refer to concepts or ideas.

These entities are all documented and grouped in
`0002_entities_from_requirements_document.png`. I have put the `company` class
at the top because it is at the top from a logistic point of view, from the
perspective of our client. At the next organizational level are the packages
`backend` and `frontend`. The `backend` "contains" the `warehouse` and the
`server`, and the `server` contains the `shop`, so I've added it right beneath
the `server`.

To the right of the `backend` package you can see the `frontend`, and right
beneath it a green group and a brown group. The green one merely concerns
itself with customer-related concepts, while the brown one contains concepts
related to products. Please note the existence of events like `expire`, which
are also concepts.

Under the `backend` package, in the violet group, are the `employee`-related
concepts, and in the red group are the concepts related to `business partners`.

Now, look at the distribution of the colors across the page in
`0001_textual_requirements_with_annotated_entities.png`. Make abstraction of
the text, look just at the colors. What do you notice and how do you interpret
what you've noticed?

In the file `0003_textual_requirements_with_annotated_requirements.png`, you
can additionally see some functional requirements highlighted in yellow. What
do you notice, and what semnification do you think it has? Compare with the
other image which has no yellow.

However, the requirements as you see them, are not defined that well. Yes, we
are going to program in an agile way, which means we will try to keep our eyes
open to changing requirements. But not well-enough defined requirements are not
changing, they are fixed AS WE SPEAK, and, since they are not well-defined,
they represent risk.

Ask the customer as many questions as you wish to make him clarify the existing
requirements.

Now look on the branch feedback and send a pull request with your answers
filled in.