One of the interesting things of going from the pseudocode, to the,

to the actual code, to the actual implementation, is that that step,

presents us with opportunities, but also presents some dangers there.

The opportunities, in, in the,

in the form that you can actually use your implementation or coding skills to take

pseudocode and make, actually, a more efficient implementation of it.

Because when we present through the code it's basically we

are describing what the algorithm does.

Not how it does every step in detail.

When we want to present how things are done in detail that's when we

go to the actual implementation.

And you have seen I hope, throughout the course,

is that when we present pseudo code in the homework or wherever.

And you are writing the implementation of that pseudo code.

In many, many situations, you even made the, the pseudo code more, more efficient.

Okay?

But the second thing also as I said, there is the danger of

going from a correct pseudo code, to an incorrect implementation.

And again, you have noticed that in this course that sometimes when

you implemented the, the piece of code.

Even though the pseudo code is correct, you notice that you had to go through many

iterations, of that implementation phase until you got it right, okay?

So, the first, the fourth step is, is that implementation of the pseudo code, but

it's not a trivial step by any means right?

Because, you have to make the implementation efficient.

You have to make sure it is correct.

And there are, there is a lot of room for efficiency, and there's a lot of room for

in-correctness, as well that you have to avoid.

After we are done with that, the fifth step in our algorithmic thinking is to

take that code, run it on the data and reason about it.

And I would say, this is really what distinguishes our course,

from a traditional algorithms course, where we had that application part.

Where we try to emphasize this notion that,

an algorithm is not just a mathematical object that we implement, for fun.

Some people do have fun, with coming up with algorithms or implementing them.

But usually they are part of a larger application that we are trying to solve or

to develop.

And the application component in, in the algorithmic thinking.

Was designed, to illustrate this notion.

So, we wanted you to take that implementation,

apply it to actual data set, get an output, and reason about it.

And every now and then even make connection to the symptotic analysis and

so on that you have done in the theoretical part.

Okay?

So, again, this is the five step process of algorithmic thinking.

Where, we basically understand the problem, formulate the problem,

come up with an algorithm, implement the algorithm, and then analyze the,

the original data that we were presented with, so that we give solutions.

Okay.

Algorithmic thinking is a very powerful technique, especially these days when,

when computer science is spreading,

in terms of applications way beyond traditional computer science.

So now we, the community talks about X plus CS, or

X plus computer science where X can be any domain.

Biology plus computer science,

physics plus computer science, social sciences plus computer science.

So, algorithmic thinking, is actually everywhere in this fields.

Okay?

And we highly recommend that, this is just the beginning, that you start if you

enjoy it or you like algorithmic thinking, that you start, honing more skills, that

will allow you to practice this kind of pro process in practice, which basically

means, you need to take more mathematic courses, more algorithm courses and so on.