Hello, welcome to this third section about
computer science and its foundations.
This section will be about programming.
We studied algorithmics with
pseudocode describing an algorithm,
now we'll talk about the software
implementation of these algorithms.
This section is divided into three
parts, the first one is machine code.
So what the CPU is able to understand exactly.
Then, we'll talk about compilation and higher
level languages, so the programmer's side.
Then we'll talk about bugs and we'll
classify programming languages.
We'll start with the closest to
the GPU of the machine,
of the architecture,
machine code.
Gérard Berry said that the
computer is completely stupid.
So it's not able
to do anything intelligent.
The only intelligence is in
the brain of the programmer.
Computers, smartphones,
tablet computers,
all these things
are not magical objects.
They are really stupid things.
And we need to tell
them what they have to do
and to help them, to
prepare the things to do.
So the algorithm has to be
thoroughly prepared.
Its electronic system
is very advanced,
very complex, but still,
it's only an electronic system.
So a computer is stupid,
it can just obey simple orders,
and these simple orders are machine
code, also known as assembly language,
which depends on your CPU.
So these instructions
are very limited.
There's only a finite number
of them, a small number,
and so the kind of things
a computer can do,
is transferring things from
the global to the local memory.
It can compare two values.
It can add, multiply,
divide two values.
It can also jump to another label of
a program to do loops or run tests.
So, many very simple, unit things.
I'll give you an example.
Here a piece of x86 assembly language.
I'll analyze it for you.
So movl is used to put
values in registries.
There, we'll put 0 in a registry,
then 7$ in another registry.
Then we have a comparison, cmpl,
that will compare the value 0
with what's in the registry number 4.
Then, from the result of this
comparison, there's a test.
And depending on the result of this test,
we'll jump to another label
of the program, which is label .L2.
And then we do something else.
What we see immediately is
that this is not attractive,
it's incomprehensible and it'll be
really hard to understand what's in there.
So the only conclusion
is that we really don't
want to write assembly language,
that's why we'll use higher level
languages and compilation.