 as well. So welcome back everyone on Moodle. Also welcome back people on YouTube. Today we will teach you how to create an R package. So the R package that we will create today is named your package name. So normally you would create a package which has a certain name like I came up with a new method for fish analysis, which is called fishy something, right? But in this case, because it's an example, the package is going to be called your package name, which is of course a little bit annoying because I'm making it harder for myself because every time I have to say your package name instead of using a name. And afterwards we will do some more advanced stuff. So I will also teach you how to use things like C code and call C code from R. Because a lot of times when you make an R package or when you write code in R, you end up with code which is sometimes relatively slow. I also notice now that actually the bottom of the slide is a little bit cut off. So let me move that thing up a little bit. Can I do that using this? Oh, that's going horribly wrong. There it goes. All right, so let's make the university proud. Like let's put the logo in. It's a little bit too big. Just all right, and sit like this, make it a little bit smaller, and then move it a little bit further down again. That's the wrong thing. That's also the wrong thing. All right, so let's make the university proud and show the logo as well. All right, I hope everything is visible and stuff doesn't get cut off on the bottom. So today package your package name. So first things first, when you want to create your own R package, you have to install the R compiler, which is different from R itself. So you have to install something called R tools, and you have to do that only when you are on Windows. So if you are on Windows, you go to this thing, and there you can download the latest version of R tools. You have to make sure that the version that you are installing is matching your version of R, right? Because the version of R that you are using needs to match the version of the R compiler that you are installing. Fortunately, the name is generally more or less similar to the R compatibility, right? So the thing that you want to download is the one which is having your version of R in range. So if you're using R 3.0, then you need R tools 3.1. If you are using R 3.1, then you need R tools 3.2. And of course, for the latest version of R version 4, there's also an R tools package available. And if you want to create the PDFs, because our packages come with documentation, so generally you want to also look if the documentation is generated correctly. For Windows, you also need to install something called Mixtex, which you can download from here. And this is big. I think Mixtex is almost 1.2 gigabytes to download. And then when you extract it, it's like 2 gigabytes on your hard drive. You can also install Mixtex for Linux, because under Linux, you also don't have Mixtex installed by default. But you don't need R tools when you are using Linux. Or if you're on Mac OS X, I also don't think that you need it. But I never did package development on Mac OS X, so I wouldn't know exactly. But on Windows, you need the R compiler and you need Mixtex when you want to make sure that the documentation is generated correctly. So first things first, you need to create a folder on your desktop or on a location that you know, right? So for this whole lecture, I will pretend like I made an empty folder on my desktop. And this is where I'm going to put the structure in. So our packages are all about structure. Structure is everything. So the structure of the folders inside of this folder that you're going to create, so the create your folder on the desktop. So in my case, because my package is called your package name, I have to make a folder which is called your package name. The name of the folder has to match the name of your package. And the structure, so everything that you put inside of this folder needs to adhere to the official guidelines. And you can click on this link and find the official guidelines. If you click on this link, you will see that the official guidelines is around 600 pages, a PDF file. So there are like 600 pages of guidelines that you have to adhere to. And we're just going to boil it down now to a 15-minute lecture. And I'm going to go through more or less all of it. And then you don't have to read this whole 600-page document. So I did that for you, so you don't have to do that. All right. So took a roll, redeemed, next slide in Dutch. Good. So the first thing we're going to do is we're going to go to the command line, the command prompt, or what's summer to say, in Windows. So in Windows, if you use Windows, then it's called the command prompt. And the command prompt is advanced stuff, right? So it's very difficult. Because most people who use Windows do point and click. So you point with your mouse somewhere, you double click it up and then you do that. But how starts your command prompt in Windows? Well, it's very simple. You press the Windows to, or you press your start button for Windows. So in Windows 7 it looks like this. And you type CMD. And if you type CMD, then you have one program that matches CMD indexes. And then you can click or you just press enter at the moment that it is selected. All right. I think it's pretty obvious what this slide does. There's not a lot of text on it. So it's an easy slide to do in Dutch. But then we're going to execute R from the command line. And executing R from the command line is just pressing the Windows key, and then typing CMD. And then one program should come up. It's always installed because it's a Windows default thing. And it's called CMD.exe. And when you click on it, it looks more or less like this. It's not the best redemption. So this slide is just an empty slide. Like it's just showing you how it looks on the Windows 7. But this is something that people generally in Windows never touch. I will redeem your points so you can use the thousand points later on for another slide or in another lecture. But I can't do that now. I think my moderator should be able to, but I don't have to. I just have the OBS open. So I can't redeem them now, but I will redeem them later on. So this is how it looks. So the first thing that we need to do is check the package. You could translate all text in the screenshot. But it's just English. And it's also German because it already says, alle Rechten vorbehalten. Don't worry, I have 5k more points. No, it's not called Mikroweigfenster. That's actually my username on my computer here, but whatever. Yeah, you guys should have been earning a lot of points. Like there's not a lot of things that you can do with channel point redemptions. Or like if you have some ideas what you guys want to do with your channel points, then let me know. But they're Danny bucks, right? And spend your Danny bucks on something, but I don't know exactly what. So anyway, Mikroweigfenster. No, it's not Mikroweigfenster. It's just Microsoft Windows. Anyway, so creating your package is just a loop again. So we're going to do the same thing over and over again. And the first thing that we want to do is checking our package, see if the package so that the empty folder called your package name that we created is actually a valid one. So in the in the in the command window, we type CD desktop, because that's where I made it, right? So I was in C users, user two. And then I have to go to the desktop folder. So I just type CD desktop, and it goes to the desktop. And then I do this magic command saying our CMD small letters check your package name, which is the name of the folder. And then what will happen? It will look like this, right? So it will tell us so I do CD desktop, and then I do our CMD check. And then it says, okay, I'm using this log directory. This is the R version that I'm using. So 3.1.0. I'm using a 64 bit windows. I'm using minimal GNU for Windows to compile. I'm going to compile 64 bits. It's using this character set, which is ISO 8859, which doesn't really matter. And then it checks to see if there's a file. And this file is called your package name slash description. And it says no, right? And that is because everything is about structure. So you need certain files to be there, and you need certain folders to be there as well. So apparently, there needs to be a file called description. And this is something that is hard under Windows, because this description file, this file called description written all in capital letters is not allowed to have the TXT extension, right? So the thing that I'm going to do is I'm going to create a new empty file called description, right? So I'm going to open up a new a new text document in notepad plus plus, for example. And then when I save it, I have to save it as description. So no dot txt at the end, because if there's dot txt, then it won't recognize it as a valid description file. So inside the file, we add the following. So we say this is a package double point, your package name. I'm going to save version double point, and I'm going to give it a version. And this version is a semfer version, which means that it is 0.0.0 dash one. And you can, of course, make it version 1.3.2 dash a, but it has to adhere to this structure. The date at which it was created. So the first time that I did this lecture was the ninth of June 2015. I have to give a title. So the title is called my package. The title is just a sentence, which I can choose freely. The author needs to be mentioned. So the author is me, Danny Adams, and my email address between the larger than and smaller than characters. And I need to specify a maintainer. The maintainer is the person who's going to maintain the package long term. And this is the email address that will be mailed. So they will when, for example, there's an error in your package. And so I submit my package to cram, and there's an error. Then the people from cram will start mailing the author and the maintainer. So the maintainer will get an email. If the maintainer doesn't respond, then they are mailing the author. But in this case, it's both the same. I have to specify what my package need, which is called the dependency. And the dependence is specifying that. So I'm going to specify that you need to have r installed. And you need to have r at least equal to or greater than version 3.0.0, right? So and this, of course, if you want to write software, which is also for older versions of r, then of course, you can specify, well, I need to have r 2.8.1, right? But of course, depending on which version of r you are targeting, some functions might be available in the standard library and some might not. So generally, you always target the version that you have installed yourself. So the description is just one sentence, which is my first r package. And you have to specify a license. And this license, you have to choose from a list of approved licenses, which is available on the website. Next lecture in Dutch, I guess. You want to have the whole lecture in Dutch. I don't think that many people will start understanding that. Perhaps the Dutch people will like it. But I think English is better. But I generally go for GPL3. There's different licenses that you can choose from. And this depends on what you want to do with your code, or if there are any restrictions that are there because of the university that you're working for. Some universities only allow you to do things like CC by attribution. But in this case, it's just a GPL3 license, which means that you can do anything with it. But if you do anything with it, you have to mention that I made the original package. And if you change something in the package, then you have to contribute that back to me. And those are the only two requirements for the license, more or less in a GPL. But if you're interested in licenses, we can talk a whole lecture about that. But it's not that interesting here. All right. So again, we do the same thing. So I create this file called description in this folder. And then I'm going to do our CMD check your package name again. And now, of course, it finds this description file here. So it says okay. And then it starts doing all kinds of other checks. And then in the end, we are almost there. But we see that there is one note, right? So there's one note. And that says packages without our code can be installed without a namespace file, but it is cleaner to add an empty one. So let's do that, right? Because we want to have a package that is perfect, right? We don't want to have any notes or warnings or these kinds of things. No, we want to have a package which is fully fine. So it says that we have to create a namespace file. So let's create a namespace file. The reason why we need a namespace file is that we might want to load dynamic libraries, right? We might want to load other R packages. Or we might want to load like Windows DLLs, or we might want to load DLLs or SO objects, which are available on Linux. So that is the reason why it is there. And it names all the functions that are available to the user, right? So normally, I have to specify a list and own. So if I make a package, then I have to tell R that this package contains the following functions. And only those functions will be visible to the user. All the other functions will be hidden. So I'm creating a new empty file called namespace. Again, no.txt is allowed at the end. And inside of this file, I add the following, right? Because I don't want to create a package without any R code. But I want to give at least one function to the user. And the function that I'm going to give to the user is called my first package function, right? So in your case, when you have, for example, some code that does underworld, no, thank you for following. Thank you for following underworld. Welcome to the lecture. So in this case, we're just going to give one function to the user of our package. And this is called my first package function. So of course, we have to make this function. But first, I'm just going to make the file. And I'm going to say, this is the function that I'm going to export. Of course, I now need to create a folder to hold the R code. So I'm going to add a folder called R, capital R, right? So if I look now in the Windows Explorer, then if I go into your package name, what did I call it again? Your package name. So I go into the folder, your package name. And now it looks like this, right? So I have a description file, I have a namespace file, and I have an empty folder called R, right? But the folder called R with the capital will contain all the R code files. And I have a very specific structure. And this is not required. But normally, I have one file, one function. So the file has the same name as the function that is in the file. And that is easy, because then if there's an error in a certain function, then I can directly open up the file, because I'm using one file, one function. But it's not required. But it's a good thing to do. So let's create an R code file, right? So in the R folder, I create a new file. And this is what I put in. So I, of course, put in a header, which is very important. I'm going to say the file name. So my first package function dot R, the copyright is by the group that I'm working for, but also by me, it was last modified and it was first written. And I'm just going to make an empty function. So my first package function. And I'm going to say this is a function, it has no input parameters. And it does not do anything. And I save it into the R folder. So now we have everything that we kind of need, we have our description file, we have our namespace file, we have our R folder containing the R code, and we have our file containing a single function that is mentioned in the namespace file, which is going to be given to the user. All right, let's check. So we do our CMD check your package name. Again, it will roll all kinds of diagnostics into the screen. But it says now a warning. Okay, so what is the warning? So the warning says undocumented code objects, all user level objects in a package should have a documentation entry. See chapter writing our documentation file in the writing R extension manual. So now you have to pick up the 600 page manual, you have to go through it, you have to find this section. But of course, you don't really have to because you're watching the lecture. So we're just going to tell you what you need to do. But this is one of the things which is fundamental in our every function inside a package needs to have a documentation. So there needs to be a help file describing what the function does. It needs to give an example. And there are some other requirements to the help file. All right, so help files are in a folder which is called man small letters this time. Any other structure won't work and capitalized and small won't work. No, it has to be called man. This will hold all the manual files. And again, I normally have one file, one function, right? So now this thing, so I create a new month file, and manuals have the extension rd. So the way that it looks now on the hard drive is that I have a namespace file, I have my description file, I have my r folder in which there is my first package function dot r, and I have my manuals. And there I have one file called my first package function dot rd. So the rd files follow a very, a structure which is very similar to Lathech, which is a layout language. And this is what you just can copy paste in, right? So this is the most basic r data file that you can make. So you have to specify the name. In this case, it's called my first package function. You can specify an alias, you have to specify the name as an alias, but you can give multiple aliases, because you don't have to have, you can have multiple names for the same function. You have to specify a title, so my first package function, and then you generally do a minus and then a short description. So like a four, five, six word description on what it does. And then you have a description field to provide a very long description, which can be up to like a four of text. We then have a usage section, which explains how to use the function. So in this case, the function doesn't have any parameters. So the way that you use it is just my first package function open close arguments, you have to specify them, even though we don't have any arguments, I'm just going to say to do add details. Then we have details, and we have to specify the details, what does this function do. So this function doesn't do anything, but I still have to write something here. So I'm just going to say to do add details, because I'm going to have to fill this in later on, when the function does something. Then I have the value. So the slash value contains a description of what the function will return. So the return value of the function is described here. But in this case, since it doesn't return anything, I'm just going to say to do add a return value. And then I have the example section. And the example section needs to be specified. So the example here as an example, we execute the function. So since we have no parameters, no return value, I just say my first package function, call it. And then I have to specify keywords. And in this case, this is a method, right? So it's a function that I'm giving to the user. And that is called in our a methods. So it just needs to say keyword methods. And you can freely choose this, you can only say methods. And I think there's like data and a couple of other ones. But in this case, since it's a function, it needs to have the keyword methods. All right, so we retract, recheck the package, because we changed something. So we do our CMD check your package name. And perfect. So we just created our first R package. It is that easy. It is all about structure. You only have to create four files at the minimum. And you just have to make sure that everything kind of lines up. So step one is learn how to build an R package. Then there's a question mark. And then there's profit, probably. Of course, we also need to install the package, right? Because we just checked the package, which means that it's not yet installed in R. So we can also install the package from the command line. So we can say, our CMD install, this time with capital letters, your package name, and then what it will do, it will start installing it. And then it ends with done. And then we have created our first R package. So very easy. Just follow the structure. Of course, we need to test it, because we open up R and then we load our library. So we load the library, your package name, I call the function, which does nothing, but I have to test or I want to test make sure that everything works. And then of course, I'm also going to test if the help file works. So I'm going to do question mark, my first package function, and then we'll open up the help file. And of course, the help file will not have a lot of things in there. But it's just a way. Of course, we can make this much, much better. So any questions, because that's, that's how you make our packages. So if you just have our code, you just put one function, one file, create a manual file for all of them, fill in the required sections, and then compile your package and do this. Good. Then we will do more advanced stuff. So there are some special files that we can provide. So one of the things that we can provide is a package description file, right? So this is the general description of the whole package. This file is called mon slash your package name minus package dot rd. It is the global package description. And it is more or less an index. So it's kind of I've had this package contain 17 functions, which are related to hamster management. And these are the different functions. And if you want to do hamster breeding program function number three, you can find it here. The other one that you want to have is an internal one, because generally, there are a certain amount of functions that you give to the user. But there are also some functions that you need for yourself, which are only used within the package, but are generally not available for users. So because all functions need documentations, these small internal functions that are not used by the user, you can store here, you can you can refer to them, right? So if I have an internal function, which the user shouldn't see, it still needs a documentation file. But I just say that the your package name minus internal has a new alias to the function that I create. So I'm we're going to show you so you're using the alias field for this. So all of the internal functions, when people ask question mark, internal function name, then it will go to this kind of internal document where it just says that, well, this is a function that is generally not called by the user. So the your package name minus package.rd follows this structure, right? So this is has a keyword, which is called package. And this is a smaller thing. So it's just called the name is your package name minus package. It has an alias, it has a dock type, which is package. So it formats it as the index page, it has a title, it has a description, it has details, and it has an author and a maintainer section. And that's it. And then it has keywords package. And of course, the details can be long as long as you want. So you put all of the text describing your package there. And the description is just a long description of what your package does. Generally, like one paragraph, and the details are very detailed on which functions are provided and which publications people should cite and these kinds of things. The internal one looks like this. So if you have internal functions that you use to do your computation, but that you don't want the user to call, then you can link them to here, right? So you say this is the name is your package name minus internal, the title is internal functions. And then we define all of the different functions that we want to link to this file as aliases. So imagine that I have three internal functions, internal function one, two and three, then by aliasing this file to all of these three functions, I have one documentation file, and I have three different files in my r folder and all of these link to this one documentation. And the description is generally something like internal functions, generally not called by the user. You do have to specify the author, like who wrote the internal functions. And it has the keyword internal. All right. So something else that you can do and which is done a lot in our window, in our packages is to provide data, right? Because generally, if you did some research and you wrote some code, then of course, you have data, which is used by your code, or which functions as a test case, right? Because you have measured some snails, and these snails, they, they, you have your measurement and then you have your code, and the code works on these measurements. And then you have some output, which you kind of computed before. But if you want to give this data set that you generated to the user, you can do that in the data folder. So the data folder is written with small letters again. And data is stored as a name dot R data. And here again, R is capitalized, D is capitalized, the other two or other three are small. For data files, the same thing holds every data file that you provide in R to the user has to have a manual file. So again, when we create a random matrix dot R data, we have to also create a manual file describing that there is a data set, who collected it, when it was collected, how it is structured and these kinds of things. For example, we can save a random data matrix, right? So I just make a random matrix, which is a matrix, which contains 1000 random numbers, 100 rows, 10 columns, and I just save it in R using the save function, because I need to have a binary R object. So I just say save random matrix to the file data slash random matrix dot R data, right? Then we create our manual file describing the data set, which is stored in month slash random matrix dot RD. So it has a name. Again, it has an alias. The doc type is data. So that R knows that this has to be formatted as a data kind of section. It has a title. It has a description. It has a usage section. The usage section for data is always data. And then the name of the data set, then we have to specify the format, which describes how the data is formatted, like this is a matrix containing 12 rows and 500 columns with measurements on snails. The details are, for example, data was collected by me on January 15, 2025, and these kinds of things. And the references, so the references are references to the data collection. So for example, your publication where you publish your data. And then of course, there's an example and the example for data sets is relatively stupid because it's just the thing which was in the usage section. So just data random matrix. But again, every manual file, except for the internal and the package file, they need to have an example because that's just the requirement in R. And of course, here we have to use keyword data sets so that R knows that this data or that this manual file describes a data set so that it belongs to something in the data folder. All right. So besides, because the examples we have to provide because R uses your examples as tests. So when you when you do our CMD check your package name, it goes through all of the help files and it runs the examples to make sure that there's no error on the examples. However, we can have more tests because we might want to have that we might want to test certain parameters to our functions that we don't test in the examples. So tests go into a folder called tests. And generally, I use a structure like this. So I just say test underscore 0001 dot R. So create a folder called test and our files in this folder will be executed automatically during the building of the package. So when you do our CMD check or when you do our CMD build or you do our CMD install, it will run the test to make sure that all tests pass. So it gives you more certainty about that. I changed a little bit in the code, but the output of the test should not differ now, right? Because you can, you can imagine that if you have something which computes the mean, and then you can test if you take five numbers and you know what the mean is, then the test will just calculate the mean using your function and then compare that to the to the overall mean of the test. All right, so you can add more tests if you wanted to and those go into the test folder or tests folder, which is also written with small letters. So for example, how did I do one of the tests? So this is a test which fails randomly. So I just draw a random number, which is larger than 0.8. And then it will say stop unsuccessful test. So this will cost 20% of the compiling or the checking of the package to fail, because there is a failing test, which is of course not a good test. But test failure is just calling the stop function, right? So normally, you would say, well, call my very complex function, store the result, compare the result to something that I know. And if this is not the case, then throw a stop error. So you can use stop errors to make sure that your test can fail. All right, so there's another folder that you can use in our packages, and that is SRC. So the SRC folder contains source code. So it holds for Tron or C code or C plus plus code that needs to be compiled when you build your package, right? Because R is a language which allows you to also call into C or call into C plus plus. So I just want to show you a basic example on how you can do that. So in the end, if you ever end up in a situation where you have R code, which partially depends on C code, then you can use the SRC folder to provide that to the user. Could someone band the spam in chat? And that's a request to my moderator though. Right, so that's perfectly fine. All right, already banned. Very good, very good. Thank you, moderator. Right, so if I have for Tron code or C or C plus plus code, then I can use that code in R as well. So I'm just going to give you a very quick basic example on how you can call C code from R. So first things first, we need to have a C code file, right? So I'm creating a new file, which is called SRC slash call test C from R dot C. In C plus plus or in C, comments are not hashtags, but they are like double slashes, or a multi line comment can be slash star and star slash ends the multi line comment. So again, of course, I always provide a header. And the only thing that this thing is going to do is take two pointers to integers and a pointer to a result. And it's just going to add these two together, and then store this in result. Right, so it's a very basic C code, which you could also do in R. But for this, we are just going to take two numbers, add them together, and store them in the result. So it's a function with three parameters, two integers, so whole numbers, and a resulting number, which is also a whole number. And this is the way that you do it in C. And I'm not going to teach you how to program in C. But if you are capable in programming in C, then you kind of know that here we dereference the pointer of A, plus the dereference of the pointer of B. And then we store this into the position which is pointed to by the result point. But that's just a little bit C code. Then of course, we have to create an R file. So we create an R file called R slash call test C from R dot R. Again, we add a header, we of course have this function saying, so the function is called call test C from R, which is a function, it takes two names or two parameters as input, A and B. So the numbers that we want to add up, it has an internal variable called results, where we are going to store the result of the computation. And then calling C code in R from your own package is as easy as just doing dot C, specify the name of the function. So the name of the R function. So in this case, it's R underscore add, which is slightly yeah, so it's which is similar to the to the name of the C function. And then I'm going to say, well, this R underscore add function takes three parameters, it takes a so as integer a, as integer B, and then it takes something called result, which is as integer result. So I just couple the two input parameters from the R function to the two input parameters of the of the C function, and I'm coupling the result internal parameter in R to the input parameter of the C code. So this calls the C code, and it returns the result. So it returns the whole result, which will contain A and B and the resulting value. Of course, we have to add a manual file for this function, because every R function needs to have a manual file. So we have to now also update the namespace file, because we need to export this function to the user. But we also have to use, we have to add this use dinlib function, because we are now using our own dynamic library, right, because we have C code, which gets compiled, which then gets distributed with our package. So we need to inform the package that when it starts up, it needs to load this your package name dot DLL, which is automatically compiled by R when the packages is made. So the use dinlib function here loads this dynamic library. So the library containing the C code or the Fortrum code or the C plus plus code. And of course, the export, because we now have a second function that we want to offer to the user, we need to export or expose this call test C from R to the user of our package. We create a manual file. So in this case, the manual file is a little bit different than the one that we had. Because now if we look at the usage section, we have to specify that there are two parameters that the user needs to provide, right, the user needs to provide an A and a B parameter. So in the arguments here, we also need to specify that we have two items. So the first item is item A, which is the first number to add up. And then we have an item B, which is the second number to add up. And of course, the value here would be, we can update that as well, because the value is the return value and the return value is the sum of A plus B done using C code. Of course, we now test the package again. So we do our CMD check. And this should not throw any errors, notes, or warnings. And then we do RCMD install. This should install the package, make sure that the R window is closed. You should never install a package while you have the R window open in R, because then it won't be able to override the DLL, so the C code or the R code, right, because it needs to override it. So when you do RCMD install, make sure that you have no R windows open. And now we can see if our new code works. So we do library your package name, and then we say call test C from R 5 comma 10. And then it will return this. So it will return the two input parameters, plus the result, which is computed in C. All right, so some common mistakes when building R packages, when you install a package, make sure that R is not running, because the code might not update. And that is because the file might be in use or R might have locked the file when you loaded the library. So you should always make sure that when you install a package from the command line, to make sure that all R windows are closed, always check your package before installing. Because if you don't run RCMD check, then you cannot see if there's anything wrong. And then when you do RCMD install, it will try to install it. And then the installation will fail, but it won't tell you why. So the RCMD check will tell you why stuff is failing. And make sure to add enough testing in the test folder. Have used the documentation for quick and simple tests or an example how and how people should use it. But if you have code which requires more thorough testing, then of course you have to use the test directory. And you can put in five or 10 or 100 tests in there. All right, so the created package can be found on Moodle. Not yet, but at the end of the day. So after the lecture finishes, I will upload my your package name to Moodle so you can get it from there. So you can look at how I made this very simple package. Although the assignment for today is creating a package. So try and create it first based on the slides. If that doesn't work, just look at the example package on Moodle to see how I did it. So all right, so that's it for this section. So we're nicely on time. I gained some time by talking a little bit faster. And it's now 403. So any questions about our packages and how you can make them? So it's all about structure, right? Things need to be in the correct folder. They have to have the correct name. Sometimes a file is not allowed to have an extension. And you can put a random file somewhere. So you're not allowed to just create a temporary file somewhere and just give it a name because everything is about structure. So every file that is in there, that is not according to the specs of the 600 page document will cause your package to be rejected. So it's very diligent work creating an R package. But it's rewarding work because from that point on, you can submit it to cram. And people can just do install the packages, your package name, and then they can install your package from anywhere in the world and use your code, which is a very good way to not just get citations on the research that you're doing, but to also earn citations and like track record or like for your career as a scientist, so that people can also cite the code that you made, so the work that you put in to create the analysis code. All right, I see no questions in chat. So is everyone still awake? Like, didn't we boil down to kind of a nothing yet? Like, I'm sweating like mad here. So everyone's still awake? No, I'm just talking to myself and commander root shout out to commander root for always being here. He's one of the bots that monitors channel. So he's always there. All right, Florian is also still here. Very good Florian awake, tired, but awake. All right, very good. So like, you guys think that you can make an R package after this very short introduction? Let me stop the recording here for the people watching on YouTube and the people watching on