To learn what a process is in Elixir, you must first know what a function is.

For example, IO.puts/1 is a function that writes something to the screen. The function is called puts, it is in the IO module (input I and output O), and it takes one argument:

iex(1)> IO.puts("Adolfo")
Adolfo
:ok

If all goes well, it returns the :ok atom .
One function that lets you spawn a process is Kernel.spawn/1.

Again, the name is spawn. It's part of the Kernel module and takes one argument.

Can I do

Kernel.spawn(IO.puts("Adolfo"))

?
No!

Let's start simple: every function that is part of the Kernel module doesn't need the module name before it.
You just call

elixir spawn(IO.puts("Adolfo"))`

It will still be wrong, but with fewer letters.

What Kernel.spawn/1` gets is an arity 0 function, i.e., one that takes no arguments.
How do we do that?
Like this:

fn -> 1 end

The above function has no name (anonymous) and returns 1.

But see in the image that if you spawn it, nothing interesting happens:

First, see that

fn -> 1 end

returned some sort of "code" that identifies the function:

#Function<43.3316493/0 in :erl_eval.expr/6>

and

spawn(fn -> 1 end)

returned a PID, a Process IDentifier:

#PID<0.120.0>

I can assign this PID to a variable:

iex(1)> pid = spawn(fn -> 1 end)
#PID<0.110.0>

And then ask if the process that was spawned is alive:

iex(2)> Process.alive?(pid)
false

It is not alive because it was a very fast function, which only returned 1.
I can, for example, make the process "sleep" for 10 seconds before returning 1.

iex(3)> pid = spawn(fn -> Process.sleep(10000); 1 end)
#PID<0.113.0>

If I quickly ask if the process, whose identifier is in the pid variable, is alive, the answer is yes.

iex(4)> Process.alive?(pid)
true

But if I ask again after 10 seconds, the answer is no.

iex(5)> Process.alive?(pid)
false

If I do this here

iex(6)> pid = spawn(fn -> Process.sleep(10000); IO.puts("Adolfo") end)
#PID<0.117.0>
Adolfo

it will take 10 seconds for "Adolfo" to be written to the screen.

Whereas if I do the following, it will be immediate for "Adolfo" to appear on the screen.

iex(7)> pid = spawn(fn -> IO.puts("Adolfo") end)
Adolfo
#PID<0.119.0>

Anyway, this is just the basics of the basics. Read more at
https://elixirschool.com/pt/lessons/intermediate/concurrency

Or in the Getting Started of the Elixir language
https://elixir-lang.org/getting-started/processes.html

I did all this without even mentioning send and receive.

Finally: a process in Elixir is a processing unit that performs a function.

What's a process in Elixir?