‫In this video, let's take a look
‫at the two types of packages that we can install
‫with npm, and also the two type of installs that there are.
‫So the two types of packages that we can install
‫are simple dependencies or development dependencies.
‫Now simple, or regular dependencies, are simply packages
‫that contain some code that we will include in our own code.
‫So code upon which we built our own application,
‫and that's why we actually call them dependencies,
‫because our project and our code depend on them
‫to work correctly.
‫For example, Express, which is, again,
‫the Node framework that we're gonna be using
‫later in the course,
‫that'll be a dependency.
‫So let's now install our very first dependency
‫just to show you how it works.
‫And the package that we're gonna install is called Slugify,
‫which is a small tool that we can use
‫to make more readable URLs out of names.
‫For example, like product names in the case
‫of our node form example.
‫So in order to install a simple dependency in npm,
‫all we have to do is say npm install,
‫and then the name of the package,
‫which is simply Slugify.
‫In previous versions, you would also have to say
‫dash dash save, like this,
‫but right now that's no longer necessary.
‫So if you just specify npm install slugify,
‫it'll then install this package as a regular dependency.
‫And watch what happens to our package.json file
‫once that installation is done.
‫So we'll hit return now, and let's see what happens.
‫And actually, that was really fast
‫and it installed our package right away,
‫and then created this new field here called dependencies,
‫and put our first dependency, Slugify, right in there.
‫It also then has the version of the package,
‫but we're gonna talk a bit more about that later
‫in this section.
‫This is our first dependency,
‫and again, this is just a regular dependency.
‫And we will use Slugify right in the next video,
‫so just to get a sense of how we use these
‫third party dependencies in our code.
‫But right now, what I want to show you
‫is that besides these regular dependencies,
‫we also have development dependencies.
‫And these are usually just tools for development,
‫for example like a code bundler like Webpack,
‫or a debugger tool or a testing library.
‫So these are development dependencies.
‫They are not needed for production,
‫so our code does not really depend on them,
‫we simply use them to develop our applications.
‫So let's now install a dev dependency,
‫which is just a short name for development dependency,
‫and the tool that we're gonna install
‫is called nodemon.
‫So npm install nodemon, like this,
‫and then what we have to do to specify
‫that this is a development dependency is to say save dev,
‫and so this will then add an entry to this package.json
‫in the dev dependencies.
‫So let's actually take a look at that
‫once this is done installing.
‫Now nodemon is a very nice tool that helps us develop
‫Node JS applications by automatically restarting
‫the Node application whenever we change some files
‫in our working directory.
‫So remember that in the project,
‫I was actually closing down the server all the time
‫and then restarting it each time
‫that I was changing the code.
‫But with this tool, that's no longer necessary.
‫So it will automatically restart the server each time
‫that we do a change.
‫So it's now done installing,
‫and it created a new field called dev dependencies,
‫and then of course added nodemon in there.
‫And so our project now basically knows
‫that we depend on this tool here to develop our application,
‫and this package here to actually build our code base.
‫So these are the two types of packages.
‫Now let's also talk about the two types of installs
‫of these packages,
‫because right now all we did was to install
‫these packages locally,
‫so they only work in this project
‫and we can actually see that right here
‫in our project folder
‫because npm created this new folder
‫called node modules for us.
‫It has all the dependencies of our project.
‫But now you might ask, well we only specified
‫Slugify and nodemon,
‫so what are all of these packages doing here?
‫Well, that's simply because they in turn
‫are dependencies of our dependencies.
‫If, for example, Slugify needs one of these packages,
‫well, then npm will install these dependencies as well.
‫And so we end up with all of these dependencies here
‫in our project.
‫So these are for local modules,
‫so Slugify and nodemon, again,
‫we just installed them locally in our project folder
‫and they're not gonna work anywhere else.
‫But with npm, we can also have global installs,
‫and global installs will then be available anywhere,
‫not just our project folder,
‫but in every folder across your entire machine.
‫So a package should be installed globally
‫when it provides an executable command that you can run
‫from the command line interface.
‫And nodemon, for example, is one tool like that.
‫So I use nodemon in all Node projects that I work on,
‫and so I have nodemon installed as a global dependency
‫because that way I don't have to install it each time
‫that I'm creating a new project.
‫I can simply use it in a new project
‫because it's already installed globally.
‫So let's now actually do that.
‫Clear the console here,
‫and then install it globally.
‫So npm install,
‫and there's actually a shorthand for install.
‫It actually is enough to just write i, like this.
‫That's actually usually how I do it.
‫So npm i nodemon, and then flag global.
‫Hit return now,
‫and so now it is being installed globally.
‫But it actually gives us this error,
‫and if you're on a Mac and did it like this,
‫then it will also give you an error
‫simply because you don't have the permissions
‫to install this package.
‫If you're on a Mac, it doesn't work,
‫and I believe on Windows it should work,
‫at least that's the experience that I have,
‫but if you're on a Mac, you have actually put sudo
‫in front of it and then put in your password
‫basically just to give it permission.
‫Well in my case I have Touch ID,
‫but if you don't have that,
‫you can use your user account password.
‫Anyway, now that works, and we can now start using nodemon
‫on this project.
‫So let me actually show you how it works.
‫So before to run our app, we did it like this.
‫We wrote node and then index.js.
‫What I did here now was actually an autocomplete,
‫and I think I hadn't talked to you about that
‫at this point,
‫so let me go ahead and delete this.
‫So I started typing the i here,
‫and since there is no other file which starts with an i,
‫I can now hit tab,
‫and so it will automatically complete
‫the rest of the filename for me.
‫We used to do it like this, then hit return,
‫and then whenever we wanted to do some change,
‫we would have to exit it like this,
‫and restart everything again.
‫But that's no longer the case because now we have nodemon.
‫So all we have to do is to instead of writing node,
‫we write nodemon and then index.js.
‫Okay, and so now it's watching every file
‫with every extension.
‫If we go now back to our file here,
‫we don't even need to change anything,
‫all I have to do is to give it a save
‫and take a look at what happens down here in the console.
‫So I'll save it now,
‫and you see restarting due to changes.
‫Now it start again, node index.js.
‫So you see that behind the scenes,
‫it is actually still running the original command
‫that we used to do, so node index.js,
‫and so nodemon is basically just a wrapper
‫around that node command
‫simply to make our lives a bit easier.
‫This is an extremely, extremely handy tool
‫for us to work with Node,
‫and for rest of the course, I will always be using nodemon
‫instead of the node command.
‫And now just to finish, there's one more small thing
‫that I wanted to show you here.
‫So let's say we didn't install nodemon globally.
‫Well, how would we then use our dev dependency here locally?
‫So the local nodemon that we have installed.
‫Well, we couldn't simply run it from the command line
‫because the local dependencies, they don't work like that.
‫We cannot simply use them right away in the command line,
‫but what we can do is to specify an npm script
‫and we do that here in this script field.
‫When we did npm in it,
‫it actually put this one script here for us,
‫which is for testing,
‫and then simply said that we don't have any test specified.
‫So that is just like a placeholder for us now,
‫which we can replace now with start,
‫and then nodemon index.js.
‫And this nodemon that I'm using here
‫will actually be the nodemon
‫coming from the dev dependencies.
‫Instead of writing the command down here in the command line
‫like I did here,
‫I will simply put the same thing into an npm script.
‫The script is called start in this case,
‫and now we will be able to run that.
‫So let me finish this one here.
‫So this is how we run an npm script,
‫npm run and start,
‫and indeed it gives us the command here nodemon index.js,
‫and now everything works the exact same way as before.
‫Right?
‫And this has nothing to do with the fact
‫that we installed nodemon globally before,
‫it simply works like this because, again,
‫nodemon is our dev dependency right here in the npm script.
‫We can then write something
‫like a command line interface instruction
‫that it's gonna use that local dependency
‫and not the global one.
‫Again, this would've worked just fine
‫without nodemon installed globally.
‫This is how you specify npm script,
‫and we will do a bunch more throughout this course
‫and we can give them all sorts of names.
‫Start is kind of a default one for development.
‫So actually for start,
‫we don't even have to write npm run start,
‫but writing npm start is actually enough
‫to trigger this special command.
‫So you see again, it works just fine like this.
‫Perfect.
‫So in this video, you learned the difference
‫between regular dependencies and development dependencies,
‫and then you also learned that you can install them
‫either locally or globally,
‫or you can also install them in both places, right?
‫But actually, usually the global dependencies
‫that we install are usually always development tools
‫because they are the ones who make more sense
‫to install like that, again because they usually provide us
‫like a nice command line interface program.
‫In the next video, we will then use this dependency
‫that we installed here actually in our code
‫so that you learn actually how to include
‫a third party module into your code.