 Yes, a timetable that we will follow very roughly. So we did have this course once before, but we have made significant changes and the timings are not at all exact, but essentially we'll start with an intro to Julia, the basic syntax and we'll talk about functions because they are very important in Julia. And once we've done with functions, in fact, we basically have all the, everything that's special about Julia, mostly covered. There's things that exist in all modern languages, but not in many compiled languages, like package managers and so on, and testing that we will also cover tomorrow. But yeah, the basics will be covered today. So here's about copying, cloning the materials, and then there were instructions of how to install Julia. And I asked you here to run these commands. So if you didn't do that yet, please do that now. So if you have installed Julia, you can go to any command line in your system and type Julia to run the Julia interpreter and it should look something like this. So it gives you a link to the documentation and it also tells you how to get some help for running things in Julia. Let's go away from here for a while though. So I am actually in the election materials folder, the election materials, yeah. So there's notebooks, solutions, and there's a data folder. So if you are in the correct folder, you should see data, notebooks and solutions and some other files that we will mostly go to a bit later. This other option, oh, okay. Let's first go through the main option. So you run Julia, and then I have already run installed the iJulia package, which means this shouldn't take long, so I will run the commands anyway. So if you type using package, PKG, now you will be able to use the package, package, a package called package, oops. And then inside this package, there is this package.add, which installs stuff. And if you run the lines in the election materials, you saw what happened. So this time though, it will not install all that much. It will check if there is something to install. It might take a moment. Okay. So I is in fact fetching something. Okay. There is an update since yesterday, which is interesting. Since yesterday at 10 in the evening. So, okay, no changes. So what this will, this will install some files into your system and you can see from here basically where where your Julia packages are. So where the Julia files are. That's your soon information. And now we should have iJulia. So just like we started using the package package, we can also now start using the iJulia package. And by the way, this is all standard Julia code. So you could put this into a file and you could run that file using the Julia command. Now we are using the interpreter for the interactivity, but also just to test things. Okay. But what we'll be actually using for most of this course is the notebook interface. This is what you will see in a moment is Jupyter notebooks. So I'm typing different things that I'm saying and I should never do that. So the notebook function is in the iJulia package. When you start using the iJulia package, you get the notebook function and we are running the function with one parameter. The directory of folder equals this one. So we will start the notebooks in this folder. It's a bunch of stuff and there we go. So I want to move this to the side and it opens this notebook interface, which again might look a bit different if you have a wider, actually it looks mostly the same. I should have mentioned this in the beginning. So I am sharing a kind of a vertical window and that's on purpose. So you should be able to see the screen share in a window and open your own notebook or your command line or whatever you want to be using on the other side of your screen, even on a small laptop screen, hopefully you can use half the space for seeing my screen share and the other half for working yourself. And the basic idea is that you type along more or less everything that I type. So if you don't have the notebooks open, let us know in the HackMD or in the chat. These over there, okay, I will not open it. But if we are all fine, then let's go look at the notebooks. So the notebooks folder now contains all of the actual chapters in the course. The first one is an introduction to the course which we have already started a good while ago. And then it contains an introduction to how the notebooks work. So again, we have a markdown like in the HackMD. So there's a couple of different types of cells. If you select the cell here, you can choose the type of cell. So it can be code or it can be markdown or two other options that I never really use, heading and raw content. Raw content is just text. So if I change it into code, it will now think it's Julia code. So let's change it back to markdown. When you run a markdown cell, so one way to run a cell is to click here. When you run a markdown cell, it just displays it as markdown or as formatted text. Okay, so the learning outcomes, these are not necessarily super ambitious because they are what we expect everyone to get from this course. So don't be discouraged if you want more advanced stuff. But what we really want to get across for everyone is the basics of how to write code in Julia, how Julia works, how it's different from some common other languages and then where to look for more information. So there's a lot of packages for Julia. When I double click, it opens the cell. So there's a lot of packages and it's easy to write more. So it's the main thing beyond the basic syntax is knowing how to find or how to look for packages. Okay, which is mostly Google. So I mean, finding the documentation is the most important thing. Okay, so target audience is mainly beginners and intermediate students, but people who already know programming in some language. If you don't know any programming language, hopefully you saw the link in the email or in the course page to the software carpentry programming course, but you should be fine. If you have questions, feel free to ask in the chat in the HackMD or the Zoom chat is also fine but the HackMD is easy to respond to. There's also some address stuff. So you shouldn't get bored. Okay, so throughout the course, we'll go through this simulation of an epidemic to tie everything together. So we will write a Julia package, essentially by the end of the course that runs a relatively simple simulation and plots creates an animation of how the simulation of how an epidemic spreads in a population of plants. And okay, this is what should be in the notebook. This give. Okay, so in this simulation, there's a bunch of, it's a two-dimensional grid of plants. I'm calling them plants, essentially only because they don't move and the disease will only spread vertically and horizontally. So they never visit each other or anything like that. In a better simulation of an epidemic in humans or in animals, you would need to have them move around. But this actually does work surprisingly well to simulate an infection in basically any kind of population. So in animals, it would look very similar, the curves here. So you get first essentially an exponential growth and then it will turn back and then taper off when there's nothing to infect anymore. And in the beginning you see that there are some immune plants here. So adding more immune plants or changing the other parameters, how easily it spreads and how long it takes and so on. Those will of course change the results but they will keep the overall pattern. The same. So this is what we'll write and we'll write something that produces this animation. This looks correct. If you try it, you have to learn a lot to trust it. If you click trust that. Not trust it. Okay. And it loads the page. Okay. Now it works. Good. Thank you. Okay. So some general remarks about Julia itself. I didn't mention all of this yet, I think. So yeah, Julia is a high level language. It's a modern, basically a modern programming language. So a lot like Python in that you can rather quickly write code that works and that's what you intended to do. It has dynamic typing and how the functions are dynamic in the same way as in Python. So, but also important that the functions are quite different, which we'll come back to. But it's intended for numerical computing. So, or at least that's one of the main use cases. So it's fast. So whereas Python is intended to be high level and simple. Julia tries to take as much of that as possible. While keeping it as fast or reasonably close to as fast as C or Fortran or any compiled language or C plus plus is probably the best comparison. And it achieves that by essentially using a function as the scope for compiling. So in when you write a C program, you have to compile it once and it takes the entire program and composite or the C plus plus. You compile the entire program in one go. And then it basically needs all the runtime information or it needs all the information in order to be fast. And if there is any runtime dependencies, some types are defined only at runtime, then it will need to do a lot of checking and it will be a lot slower. So, if you are used to those compiled languages, you can think of Julia as being something like Python, something that is basically dynamic and not compiled. Except whenever you go into function, it will compile that function and everything that depends on it, put that together into a program and run that. So it's like a C program from there on. And this is really sort of, it's convenient for the compiler because most of the time, almost all the time, it will know all the types when going into the function, it can just compile it and go. So it's relatively easy to make it fast. And at the same time, it's really convenient for the programmer because you don't need to care about the types that much. It's dynamic, it uses duck typing, you just write a function and it go and it works. Because it figures it out all in the runtime. Julia is also free and open source. It's under the MIT license. So it will be there forever basically. When one something is under MIT license, if you have a copy of it, you can keep it forever and you can make any branches and so on. There's no restrictions whatsoever. Multiple dispatch is something we'll get back to, but it's basically the way it handles calling these functions with different types. And while it goes beyond that, it basically implements everything that object oriented programming can do and a bit more than that. So, but it sort of follows naturally from having to compile all the functions, which is kind of cool. So it uses dynamic typing, which means that you can assign any type of object to any variable. You don't need to declare the types to start with, but of course you can declare the types if it's useful. I also already mentioned it's sort of intending to achieve C like performance and it gets there. It has a built-in package manager like any good modern programming language. And then there's metaprogramming facilities, which will probably not spend a lot of time on, unless we have time at the end than you want to. You can call Python code, C, Fortran code and many other languages directly from Julia. And you can define your own types, which goes into the multiple dispatch thing. It doesn't have objects like C++ or Python or it doesn't have classes, but you can define your own types and then define functions for them. So it gets basically there and a bit further than object-oriented if you use those features. Okay. So I mentioned the MIT license. And I also mentioned that it compiles the functions. For this, it uses an LLVM-based compiler. LLVM is also basically what Clang uses to compile C and Fortran and C++. But of course it needs to be changed a bit to compile Julia code. But yeah, LLVM is kind of convenient for this extension. So it's what many languages use. So it's a sort of performance comparison. You can go to the details a bit more on your own. It's all compared to C. So C is one. And then other languages are sort of all over the place. So Julia is in most things pretty close to C. And the variation is not much more than in something like Fortran or Java, Go and so on. Okay. Now, Python, this is not as unfair as you might think because they are actually using libraries like NumPy here. And well, these are relatively low-level tests. So they are actually mostly comparing to what you would do in Python if you were using it properly. All right. And then there's a bit about the Jupyter Notebooks, which is exactly what we're looking at. Jupyter is for Julia, Python and R. That's where Jupyter comes from. So Jupyter is in the iJuli repository, which we installed already. And run. Let's see. The other option, if you're in Altar, you can use the CS computer science Notebook interface to run Julia. And well, if you're in Altar, you have the work folder, the cloud folders, and you can put your Notebooks there, and they will be accessible to you. So that is useful. And probably other universities, CSC has a Notebook interface and probably other universities do as well, but I can't really tell you where it is or how to use it. Okay. So now we get to the point. Oh, we actually get to where we are running and writing some stuff. So I will actually stop sharing the Notebooks themselves because the idea is to type along. So I will start a new Notebook. So from here, and I will choose Julia. So to run Julia code in a cell, you just type the code in and you can run it from here. Like I already mentioned, it will take a while to start the Julia interpreter and when it has started to run. You can also press control and enter to run it. This for demonstration. So when you run here, it will create a new cell below. If you press control and enter, it doesn't. Shift and enter will create a new cell or move to the existing next cell if it exists. Alt and enter will create a new cell. If you're on a Mac, this will probably difference or play around and see what works. But you can also always create a new cell by clicking the plus here. Okay. So if you run two different commands, you just have them on two different lines and it will print out the result of the last one. And you can prevent it from printing out anything by adding a semicolon at the end. So then it kind of looks more like C when you start adding semicolons. Okay. Let's create a markdown cell. Also to demonstrate this thing. So what did I just do? Sorry. Something to get rid of a cell that I wanted to see in the other. Okay. This is kind of annoying. Because you can use later, but now I don't have an example of how to use later in the notebook. Is it frozen or? No, it's just that I I tried to open a cell with markdown in it and it deleted the content. And I can't find how to get it back. Okay, fine. We'll get back to later if we have a chance. Let's see if this works. Okay. So it's obvious enough that I don't need anything to prove how to do it. So you just put in inside dollar signs, you can put any later equations and it will work. So this is in this Jupiter markdown cells. Okay. So there's a bit of more of this magic commands that you kind of just have to remember. So you can run shell commands in the in a notebook by starting with a semicolon. So it will now less list the contents of the current folder. And this is what we have the untitled I Python notebook is is this one to add a new cell. We can also run. I mean, we can run on command print working directory. Okay, there we are. And then finally in Julia itself. So when in when you put in a cell, you put a string, for example, it will print the last statement. So it brings the cell. If you want to print something in between, or if you're writing a script that goes into a file, you might want to use the print command. Now print doesn't add a new line. Print LN adds a new line at the end. You usually want to use print LN. Let's show demonstrate print. Hi. Remove it from there. That new line. This is a line. Okay. So yeah, print doesn't add a new line and print LN does. And one more thing. So these also all work in the Julia interpreter. So when you type Julia and press enter, you can type in any of these commands. And this is especially useful. So starting with a question mark. And typing a function name or the name of any other object gives the help string for that object. But this tells us how to use this function. And with print, it's basically the same except it doesn't add a, it doesn't actually say much about adding to line end. Okay. But it does tell you that there is print LN print styled and S print for if you really like the C style versions, there's also print F. And then the rest of that kind of match print don't really. Okay, so let's close this notebook. Oh, no, sorry. We are at the end of the first section, but of course I don't want to close my notebook. You just want to go to the notebooks folder and open O2 Julia, which is essentially the basic syntax of Julia. So there's a lot of stuff there. And the plan is to go through this quite quickly. Let us know if you don't know other programming languages because if everybody does, or if most, almost all people do, we can sort of run through this. And there will be a break. Also, there will be exercises, but there will be a break relatively soon. And then if you are kind of lost, we can talk in more detail.