Hello, this is a summary of the lecture where I forgot to hit the record button. Sorry for

that, but I'll give you a summary about the content of this lecture now. It's really just

about a few new types and we're starting with Python in this lecture and about how to do

very basic constructs like basic operations and branching and we'll also talk a little

bit about a very special data type which is strings. Now a program is really a sequence

of definition and command so it's nothing else than a recipe how to execute certain things.

And the difference between definitions and commands is that definitions are evaluated

and commands are executed by the interpreter in a shell or by a compiler that depends on the

on the programming language. But they're always converted into machine language so these are

processor instructions really just binary code zeros and ones that tell the processor what to do,

where to look things up in memory, where to move memory and all of these sort of things.

So commands in contrast to definitions are statements that instruct the interpreter or

compiler or the processor to do something. So and these both of them they can basically be typed

in directly into the shell so especially in Python you can just run Python in your terminal and then

you get a Python shell or what's more common is that they are stored in a file and then you can

run this file with Python file and it will run all the commands and definitions in this file for you.

So this is then evaluated. What we also do in this lecture is we use Python Jupyter Notebooks

so like in Google Colab which is a little bit in between but basically you can imagine it like

a file that is handed over to the interpreter and evaluated.

Now here as I said already we'll focus on Python. It's really one of many programming languages but

it's very popular right now for data science and other applications. We are just to explore the

space. Python became very popular recently because it is very easy to use and for well everyday tasks

and simple things it's really very very powerful and it's of course free and open source and

everybody can use it to whatever they like to use it. It's probably not the language of choice

if you want to implement something that's meant to be highly performant and very very fast

applications that run in the same language. So it's very easy to use and it's very easy to use

that run directly from your desktop like here PowerPoint is probably not written in Python

but technically you can convert Python code into more efficient code. It will just never be as

efficient as if you run it. Nowadays with current computers for most of the tasks it doesn't really

make a difference and you can solve basically everything within reasonable time. So Python is

an interpreter language. It is not compiled in contrast to C or C++. Java is somewhere in

between. It's compiled for a very specific virtual architecture but here in this case we are just

interpreting directly. Other interpreter languages are Matlab you might have seen or Perl or all of

these sort of things. So as I said already it's either through shells or notebooks and we're going

to use this language and really the key takeaway here is whatever you learn in one language in one

imperative programming language like the ones we are looking in this course, these concepts

are transferable to any other language. The only thing you have to learn or rather say look up in

the manual is the specific syntax that's required for that programming language and potentially

other quirks to make things more efficient or to make things more elegant but the basic concepts

we're discussing here are all transferable between imperative programming languages.

There are also functional programming languages something like Haskell or

SML or these sort of languages and they are not part of this course simply because we are more

concerned with imperative languages because it's probably 90 percent of the use cases you use an

imperative language. Nevertheless anything you can do with an imperative language you can also do with

a functional programming language. Functional languages you would probably more use in for

proofing things for symbolic reasoning and things like that. Yeah so programming languages you cannot

absorb the knowledge about programming or even about the individual languages by passively

listening to me. Really what you need to do is practice, practice, practice, sit down and work

with that language. There's nothing better than learning by doing and your best friend is the

internet. There's google, there's stack overflow, there's probably an answer for every question you