So, in our course, we're not only going to develop mathematical solutions to finding approximations to our partial differential equations. We also want to turn these algorithms into computer programs and play around with this, and that's actually a lot of fun. The programming language we're going to use is the Python language, that has been very popular in recent years, is openly accessible, and there's a lot of information and training courses online. So, what is the best way of getting into the so-called Python ecosystem? Maybe you have already experienced and you could skip that, but there is a so-called Anaconda environment that I can recommend you to download, and it works on all major operating systems like Mac, like Windows, like Linux, and that opens you basically access to a lot of these functionalities that Python offers you. So, if you want to familiarize yourself with Python, there's a couple of things that are relevant for developing numerical algorithms. For example, of course, dealing with numbers initializing vectors and matrices and operating on these vectors and matrices. Then there is, of course, control flow, for example, loops that are so-called for-loops, that we will use to, for example, calculate derivatives or evolving systems in time. There are if statements, so conditional statements that are very important. There are functions that can be defined that make life a lot easier, that's, for example in Fortran, they are called subroutines. There is also the importing of libraries, which is a characteristic of the Python language that gives you access to a lot of additional functionalities. So, again, if you are not so familiar with Python, I would invite you to play around with some of these concepts, but I would also like to note that to understand the course, it is not necessarily required to be experienced in programming, I think it's relatively straightforward to follow the examples that we give later in the course without prior programming experience. There's one other concept that we are going to use to understand the numerical implementations of our algorithm. These are now called the Jupyter Notebooks that were invented a few years ago as IPython Notebooks and now they're called Jupyter Notebooks. It's really a fantastic tool to make portable documents that are accessible through any web browser, and they are basically alive in the sense that you can combine static aspects of a document, like a text and graphs, with dynamic aspects, meaning for example Python programming parts that can be run and change their output, for example, graphs. So, I would again invite you to spend a little time in investigating the power of these Jupyter Notebooks, and I will give you just a little example if you have never heard this before, and how to operate with these Notebooks. It's actually a very powerful concept to start projects, to develop projects and to exchange information on particular projects with your colleagues that you're cooperating with. So, this is what you see when you type Jupyter Notebook in your environment, a browser opens and we're now in a directory where actually there is no Notebook, so we will start a new Notebook, so this is what you do here. So, we started a new Python 3 Notebook. At the top here, you can give it a name. So, let's call it My first Notebook. Okay. Now, what you see, and this is characteristic of all Notebooks, you see this small windows. So, these windows can either be Python code or they can be markdown, so it's like a very simple word processing system where you can have text, you can have some basic formatting and you can also include some images. Let's start with giving, again there's a title so this is my first Notebook, and now you need to run this. There are several ways. You can either use this button here, but you can also type Shift Return, and you can see now this text. You can add some basic formatting, for example, by adding a hash at the very beginning, this is like now you have a title formatting, Shift Return, and you see this now in a much more bolder kind of font. Another way of structuring is now using two hashes, and we will start showing some Python code. So, we say, let's look at imports. Again, this is now using markdown, and we Shift Return, and we have a subsection. So, what we do here is something very simple which is to show how to initialize a vector and plot a sine function, just so that you see how we can make use of these Jupyter Notebooks. So, in order to do that, we first import NumPy, which is a library dealing with numbers and processing. So, as np, so we import it as np, which means we access all these functions by np.something. We also want to do some plotting, and for that we use the matplotlib library. So, we import, actually part of it, this is matplotlib.pyplot as plt. So, let's see what happens if we Shift Return, and we're now running it. You can see at the top this is now Python code. So, if we do that, we don't get an error message, so that looks good. So, now let's initialize a vector, let's again add a subsection, initialize vector, Shift Return, wait we have to change it to markdown. And now let's use a function called linspace to initialize a vector. So, np.linspace, we want a vector that's defined from zero to two pi, two times np.pi, and we want to use 1,000 numbers in that domain, Shift Return, and we now have a vector that's defined between zero and two pi with 1,000 numbers. Now, let's do some plotting. Plot a sine function. So, this is again a subsection. So, let's give it two hashes and also we give it the markdown format. Shift Return, and here we go. Now, to make it a little more interesting, let's define a wave number. Let's start with one and then plot a sine function. So, we use plt.plot, we plot, the x-axis will be x, and the y axis will be our sine function. So, sine k times x, this is an element by element multiplication, well, k is a scalar here, and also we need plt.show, open bracket, close bracket, and let's hope this works. We have an error here, and that's happening quite often. So, we forgot the np., and that should do the trick, and yes we have now a sine function in the plot. The power of these Jupyter Notebooks is actually now, also you can basically save this as an ASCII file, mail it to a friend if you want to start a project, and you can use this here to change the parameters. So, for example, let's just change k to 10, and what I recommend always is you basically then run all from the top, and you get the graph, the sine function with a different wave number. So, that's basically about it. Of course you can now start playing around with this. A very powerful very nice tool that we're going to use later to illustrate the Python implementation of our numerical algorithms for the wave equation that we're going to develop. If you're interested in exploring some of the more advanced implementations of these Jupyter Notebooks, there are a lot of examples for seismology, seismic wave propagation, data processing, spectral analysis on a platform called www.seismo-live.org. I invite you to maybe spend some time there if you're interested in learning more about how these Jupyter Notebooks actually work. Now, this is the end of week one, we are now basically prepared to dive into the numerical algorithms and numerical methods that we're going to employ, and in week two, we actually going to start with the finite difference method applied to the wave propagation problem.