Ideas for improving the new documentation

The upcoming revised documentation is a great improvement. I've already learned a lot and believe I understand Param and the ideas behind it much better. It's great.

The below is a list of ideas that I believe could improve the documentation for both new and experienced users.

## 1. Make it even more visible WHY `Param` would be valuable to "me".

The documentation is text heavy. I think that is great as soon as my attention has been caught and I understand why I should take the time to read and learn. The text is great.

I need something to catch my attention though. And explain it to people with other learning preferences than text.

My suggestion would be to add a 3 min video to the `Introduction` that explains the why with a real world, practical example. It should be a walk through of a very interactive Notebook that can be downloaded by the user right next to the video. And add in a link to Binder where I can try it out as well.

It might also be valuable to add a 30 sec `.gif` video that just plays and immediately explains the Why to me and catches my attention.

## 2. Make Getting Started Example even more friendly for users.

The first example I see looks like this.

```python
import param

class A(param.Parameterized):
title = param.String(default="sum", doc="Title for the result")

class B(A):
a = param.Integer(2, bounds=(0,10), doc="First addend")
b = param.Integer(3, bounds=(0,10), doc="Second addend")

def __call__(self):
return self.title + ": " + str(self.a + self.b)
```

```python
>> o1 = B(b=4, title="Sum")
>> o1.a = 5
>> o1()
'Sum: 9'
```

The main question for me is whether using `__call__` in the example is a good idea. I know about `__call__` but I never see any colleagues or blogs in data, engineering, trading or science use it.

So I believe the big questions for users is: What is `__call__`. Why do you use `__call__`. I did not know I needed `__call__` in my code. What is the use case for `__call__`? Why is `__call__` useful to me?

So unless there is a point (which a have not yet understood) in using `__call__` I would rename the function to `sum`.

You are also using multiple inheritance which might also throw some users off. I just see my new colleagues coming out of engineering and finance education struggling with the concept of Classes.

## 3. Add Pydantic to the Comparison

Pydantic is taking the Python world with storm. Together with FastApi. I would like to know why it's valuable to me to build domain models with Param when

1. I can use Pydantic and not Param with FastAPI.
2. Pydantic works using type annotations which provides a much better development experience in an IDE and with linters than Param.
3. The huge popularity of Pydantic means more colleagues would probably know and understand why I use Pydantic
4. There are (more) tools out there for Pydantic like PyCharm, MyPy, Hypothesis plugins. And more are probably coming.
5. Lots of orgs are building on Pydantic and want to be associated with it. See https://github.com/Kludex/awesome-pydantic

I believe Param and Pydantic could be integrated and that would help a lot of Pydantic users easily create visualizations, tools, apps and dashboards from their models. And Param users create modern Rest Apis via Fast Api. For a Streamlit+Fast API example check out https://testdriven.io/blog/fastapi-streamlit/.

## 4. Add a real world example

Add a section with a real world example. My personal profile would simply need that. You can write just as many *theoretical* arguments about why Param is great (which it is) but without a real, practical example you don't catch my attention. I move on.

I work with traders so in my world the Black Scholes option pricing model is a great example.


I would visualize it using Panel.

There are probably more generally understandable examples out there but this one I use at work to explain why Param is powerful.

FYI. @jbednar