This article contains a curated collection of questions related to Linux which everyone should know. These questions are also among the most asked questions in company interviews, especially in devops profile/system engineer profile/Network engineer profile or Linux/Unix administrator profile.

Note: This article is targeted for beginners. I would recommend all the interested people to not to just read rather try on your system or your friend’s system 😅.

How will you tell which version of kernel a system is currently running?
The answer is uname .
uname is used for printing certain system information.

2. How will you get the IP address of a machine ?
The answer is ifconfig.

ifconfig is used to configure the kernel-resident network interfaces. It is used at boot time to set up interfaces as necessary. After that, it is usually
only needed when debugging or when system tuning is needed.

If no arguments are given, ifconfig displays the status of the currently active interfaces. If a single interface argument is given, it displays the status
of the given interface only; if a single -a argument is given, it displays the status of all interfaces, even those that are down. Otherwise, it configures
an interface.
Another utility command to get the IP address of a machine is ip addr show

3. Check for free disk space
The answer is df -ah

df displays the amount of disk space available on the file system containing each file name argument. The a flag depicts all files(pseudo, inaccessible or duplicate) and h flag is used for viewing results in human readable format.

4. How will you check the status of a service in a system?
The answer is using service or systemctl.

service udev status
systemctl status service

5. How to check the size of a directory’s contents on the disk?
du -sh directoryName/

6. How to check for open ports on a Linux Machine?
The answer is using netstat.

This is really an amazing utility. Netstat prints information about the Linux networking subsystem.

netstat -tulpn

The above command uses different flags. Without going in much detail, the t flag is for TCP sockets, u for UDP sockets, l for only listening sockets, p to show the PID and name of the program to which each socket belongs and n is to show numerical addresses instead of trying to determine symbolic host, port or user names.

7. How can you check CPU usage for a process?
ps aux | grep name_of_process
alt: top, htop

8. How to check for network connectivity from command line?

Ping utility is a useful diagnostic tool. It allows you to quickly test if you’re connected to your router or the Internet, and gives some indication of the quality of that connection.

I hope you by this time you must have went across all the commands I wrote above. I would again request you to try it on your own so that you get comfortable using these commands.

Happy Programming!

If you liked this article, please do give a clap 👏 and share ▶️ it with your friends 🙌.
You can reach me out on Twitter, Github or Linkedin.

✉️ Subscribe to CodeBurst’s once-weekly Email Blast, 🐦 Follow CodeBurst onTwitter, view 🗺️ The 2018 Web Developer Roadmap, and 🕸️ Learn Full Stack Web Development.

Top Linux Commands You should know was originally published in codeburst on Medium, where people are continuing the conversation by highlighting and responding to this story.

This is the continuation of the previous article in which we discussed the TCP/IP protocol suite. If you haven’t gone through my previous article, I would recommend you to have a look at it as I have already explained some basic terminologies in it that we will be discussing here again. Although, the whole post is a little long but I request you to read till the last. I can guarantee you will get to know so many in depth details just by reading this article. :)

In this article, we will try to get answers to the following questions:

• What actually the OSI Model is ?
• What is the need of OSI model ?
• What constitutes OSI model? ( Hint: Some bunch of layers similar to that in TCP/IP)
• Where we can see the practical implementation of this model ?

Let’s get started!

History

In the early days, when the network communication systems were in nascent stages, the architecture designers and engineers faced the frequently occurring issue of debugging where in the whole system, some error occurred. Further, it was a need to bring all the manufacturers of various hardware equipments to follow some references and benchmarks for manufacturing so as to standardize everything under the hood.

The OSI Model

The Open System Interconnection (OSI) is a reference model for how various applications communicate over any network.

Reference Model : A reference model is a conceptual model for understanding basic relationships between various basic elements.( Computer systems in terms of networking).

Need for this model

As already discussed in the introduction, the purpose behind this model was to provide developers, programmers, engineers, vendors and all the associated people a standard that can serve as a guide for them using which they would be able to create communication equipments and softwares inter operable.

Constituents of the OSI Model

The concept of the OSI model is pretty easy to understand. The process of communication between any two systems will involve flow of data between them. Both the systems must have some programs which can enable them to send and receive data properly.

To solve specific type of problems, the committee grouped similar type of problems together and divided the architecture of the model in layers which was minimized to seven layers. Different problems are solved by numerous protocols that have evolved with time. Let’s discuss all the seven layers one by one in the next section.

Layers of OSI Model

1. Application Layer

In simple words, this is the layer which enables the user to access the Internet. This user might be a human and might not be!
Guess what, it could be a bot, script or any other software.

The function of this layer is to provide:

• User interfaces (UI)
• Compatible support for various services such as Electronic mail, remote file transfer and access, shared database or any other type of distribution services.

2. Presentation Layer

This layer is concerned with the semantics and syntax of the information exchanged between the systems.

Some of the specific responsibilities of this layer are:

• Encryption/Decryption of data: In simple words, encryption is the method of transforming the original message and sending it so as to ensure the privacy of data being transmitted. The decryption reverses the original process to transform the message back to its original form.
• Compression: It is the reducing the number of bits contained in the information to be sent. This plays vital role in the transmission of information in form of audio, video, images, etc.
• Translation: The information exchanged between two systems happens in form of bit streams (many bits at once), but since different computers use different encoding systems( ASCII, Unicode or may be some other), it is the responsibility of this layer to ensure interoperability between these different encoding methods.

3. Session Layer

As per Forouzan, the session layer is the network dialog controller, i.e. It establishes, maintains and synchronizes the interaction between communicating systems.

The responsibilities of this layer will make us understand about it’s existence.

• Dialog Control: This layer allows two communicating systems to enter into a dialog. It allows the communication between two processes to take place in half duplex (one way at a time) or in full duplex mode ( both ways at a time).

• Synchronization: This layer allows a process to add some checkpoints into a stream of data. Why so?

Consider a system sending a file of 100 pages with a checkpoint of say 10 pages. Thus after 10 pages being sent, the process will verify whether those 10 pages have been sent and received correctly or not.

If we wouldn’t have used checkpoint mechanism and some error would have arrived either while receiving or during transmission, it would be very hard to troubleshoot where the error occurred and the process would have to send all the 100 pages again. So, is the utility of using the checkpoints that if some error occurs during the transmission, the sender doesn’t have to send unnecessary frames again.

4. Transport Layer

The basic function of this layer is to accept data from session layer, split up in smaller chunks(referred to as segments), pass these segments to network layer while ensuring that all the pieces arrive correctly at the other end.

Very Important Point: The transport layer is responsible for the process to process delivery of the entire message.

A process is an application program running on a system.

The transport layer ensures that the whole message arrives at the receiver intact and in order. This is not done by the network layer(discussed below) as it only oversees the source to destination delivery and the network layer doesn’t identify any relationship between the packets of same message.

Some other responsibilities of the transport layer are:

• Service Point Addressing: There are two users (A and B) on different systems in a network running same program say Skype. Let us assume they are already added as contacts to each other. Now user A sends a message to user B. So, the task of transmitting the message from User A and delivering it to user B will involve all the layers in the protocol suite, but ensuring that the message from User A’s Skype comes on User B’s skype is ensured by the Transport Layer at both sides. Think of the consequences in terms of Security if Skype’s message appears on some other random process!
• Flow Control: Both Transport layer and Data Link Layer (DLL) implements flow control mechanism. We will discuss this in detail in DLL. The only thing worth noting here is that flow control at this layer is performed end to end rather than across a single link.
• Error Control: Again, both transport layer and DLL have error control mechanism. However, at this layer error control is performed end to end rather than across a single link.
  The transport layer on sender side ensures that the message arrives correctly on the transport layer on the other side.

What will happen if some error occurred in this process?
The answer is Retransmission. The error correction is usually done by this.

5. Network Layer

This layer is responsible for ensuring the source to destination delivery of a packet.

Is network layer needed always?
The answer is No.
If two systems are connected to the same link, there is usually no need for network layer. But, if two systems are attached to different networks with connecting devices between the networks, there is often a need for the network layer to accomplish packet delivery from the source to the destination.

Some of the responsibilities of the network layer are:

• Logical Addressing: The logical addressing of nodes in the network is required to clearly identify among source, intermediate and destination nodes. This layer add in its headers, the logical addresses of the sender and the receiver before passing down to DLL.
• Routing: It is the mechanism of identifying suitable routes for sending data packets in the fastest possible and efficient way. In a large network, the connecting devices route the packets to their final destination starting from the source destination following particular route.

6. Data Link Layer (DLL)

Data link is the means of connecting one location to another for the purpose of transmitting and receiving digital information. It can also refer to a set of electronics assemblies consisting of transmitter and receiver.

This layer makes the physical layer(discussed below) appear error-free to the upper layer. It provides end-to-end validity of the data being transmitted. It forms data frames from the packets of data received by the network layer and performs some operations and send those frames to the physical layer.
The other responsibilities of DLL are :

• Flow Control: The DLL imposes a flow control mechanism, this is done so as to avoid the condition of receiver overwhelming at the receiver’s side. We can consider this in analogy of a traffic jam at receiver side.
  i.e. when the speed with which sender is transmitting the data is much higher than the speed with which the receiver is receiving the data.
• Error control: The DLL provides mechanism to detect and retransmit damaged or lost frames. This is done by adding a trailer at the end of the frame.
• Access Control: When two or more devices are connected to the same link, the DLL determines which device will have control over the link at any given time. This mechanism of providing control to some device is called as access control mechanism.

Extra Point: The DLL is further divided into two sub-layers:

• Media Access Control (MAC) : This sublayer determines the physical addressing of the host systems.
  Have you ever heard of the word MAC address/ Physical Address/ Hardware address?
  Let me tell you that the Physical/Hardware address of your computer system is technically known as MAC address. This is the address which gives unique identity to your computer system. This address is nothing but a 48 bit number given to Network Interface Card(NIC) of your system.
• Logical Link Control (LLC): This sublayer is responsible for frame synchronization, flow control and error checking mechanisms.

7. Physical Layer

We already discussed that the data flows in the network in form of bit stream. It is the responsibility of the physical layer to:

• coordinate between all the functions required to carry a bit stream over a physical medium.
• deal with the mechanical and electrical specifications of the interfaces and transmission media (cables, air, etc.)
• define the functions and procedures that physical devices and interfaces have to perform for transmission to occur.

The physical layer is also concerned with :

• Representations of bits : You might be wondering how bits ( 0 and 1) are actually sent from one place to another. Isn’t it?
  To transmit the data over some transmission medium, the data in the form of bits must be transformed into some other form.

Could you guess what it could be?
The answer is signals. These signals could be electrical or optical. Thus, this layer transforms bits into signals which in practicality travel over the transmission medium.

• Physical Topology: It defines how devices are connected with each other to form a network. Have a look at some of the topologies in the following illustration. Every purple circle is a node(system) in the network.
  
  Note:
  In Ring topology, nodes are connected in the form of a ring. In Star, each node is connected via a central node. In Fully Connected, every node is connected to each other node, while line and bus have end points. If at any point in the system, the connection breaks, the Line and bus will stop working.
  Think what will happen when the central node in the Star topology stops working?
  Obviously, all the nodes won’t be able to communicate if the central node stops working. Thus, every topology has its own pros and cons.

• Synchronization of bits: The speed with which sender is sending the bits might not be the same as the speed with which receiver is receiving. Thus, they both need to be synchronized which is taken care by physical layer.
• Transmission Mode: In simple words, the physical layer also defines the direction of transmission between two devices: simplex, half-duplex and full-duplex. The only thing to note is that in simplex mode, only one side could be the sender unlike the other two modes.

In this article, we discussed in detail about the OSI Model. Why it was created. What constitutes this model and what are the different layers and their functionalities.

To Sum Up: The OSI Model is said to be prescriptive model as opposite to the descriptive TCP/IP model. It was a reference model but heavily bloated and referred to as everything to everybody model. Being heavily complex, it was very difficult to implement its specifications completely and hence TCP/IP was brought in which was effective in practicality and the cost involved in designing TCP/IP protocol suite(which was inspired from OSI Model and incorporated many features and designs in it) was very less as compared to implementing the unrealistic OSI Model.
Thus, even today while using the TCP/IP suite, most of the implementation is somewhat similar to what we have discussed and surely gives us in depth details of basics of computer networking.

If you liked this article, please show your support by clapping and sharing it among other people.
If you would like to support my writing. You can help me out here. It will keep me motivated to share more knowledge with people. :)
For any queries, reach out to me @donvikas

✉️ Subscribe to CodeBurst’s once-weekly Email Blast, 🐦 Follow CodeBurst on Twitter, view 🗺️ The 2018 Web Developer Roadmap, and 🕸️ Learn Full Stack Web Development.

Learning the OSI Model was originally published in codeburst on Medium, where people are continuing the conversation by highlighting and responding to this story.

We need to know what actually is a protocol.

In terms of networking, a Protocol corresponds to a set of rules which govern how system communicate with each other.

Then we need to know what a Protocol suite is.

A protocol suite is simply a collection of protocols that are designed to work together.

What is TCP/IP Model?

The TCP/IP (Transmission Control Protocol / Internet Protocol) was created in the 1970s by DARPA. The model came from ARPANET and is also known as the “Internet Model”. It has four abstraction layer which describe a general set of design guidelines and implementations of specific protocols for network communication. We will be discussing all these four layers in brief with some popular protocols of each layer.

1. Application Layer

This layer provides applications the ability to access the services of the other layers and defines the protocols that applications use to exchange data. This layer adds it’s own header and sends down to the Transport layer.

Some of the popular protocols of this layer are :
HTTP, FTP, SMTP, Telnet, NFS, RIP, etc.

2. Transport Layer

It is mainly responsible for providing the application layer with session and datagram communication services. It accepts data from application layer, splits it up into smaller units and pass these to the network layer. This layer adds it’s own headers and sends down to the Internet layer.

It is the responsibility of this layer to ensure that all the split pieces arrive correctly at the other end. It is concerned with end-to-end transportation of data and setups up a logical connection between the hosts.

There are two protocols available in this layer:
TCP and UDP

3. Internet Layer

The segments sent by the above layers are received here. Now, we need to send this segment of data to a destination host which could be anywhere ( in the same network or may be external network). This layer ensures that the segment is moved across the networks to the destination network. It provides logical addressing, path determination for the segments to be sent and forwarding .

This layer also adds it’s own headers and convert and send the received segments in form of packets.

Some of the popular protocols of this layer are :
Internet Protocol (IP), ICMP, etc.

4. Network Access Layer ( Data Link + Physical Layer)

This layer defines the protocols and hardware required to connect a host to a physical network and to deliver data across it. For delivery within a given physical network, packets are sent from the above layer to this layer.

The destination can be another host in the network, itself, or a router for further forwarding. So the Internet layer has a view of the entire Internetwork whereas the Network Access layer is limited to the physical layer boundary that is often defined by a layer 3 device such as a router.

The protocols in this layer depends upon which physical network is being used. When the physical network is LAN, Ethernet(802.3) and it’s many variants are used while if the physical network is a WAN, protocols such as Point to Point Protocol (PPP) and Frame relay are common.

To Sum up : This article helps us understand the foundation behind everything happening in the computer networking. Every layer has its own functions and responsibilities. The data flow from one layer to another with some modifications and reach from the source to the destination.TCP/IP is said to be descriptive model as it brings practicality to the OSI Model which we will discuss in the upcoming article in detail.

Edit 1: I have added the new article, you can visit it here.

If you liked this article, please like it and share this with other people.
You can reach me out @donvikas

✉️ Subscribe to CodeBurst’s once-weekly Email Blast, 🐦 Follow CodeBurst on Twitter, view 🗺️ The 2018 Web Developer Roadmap, and 🕸️ Learn Full Stack Web Development.

Learning the TCP/IP Protocol Suite was originally published in codeburst on Medium, where people are continuing the conversation by highlighting and responding to this story.

Now to understand WTH is seeders and leechers , first let’s take a look at a simpler method of sharing files — Hyper Text Transfer Protocol i.e. HTTP.

HTTP is used when you download files from a website using your web browser, or something like Internet Download Manager. (For example, when you download some Software, or drivers from manufacturer’s website, it’s usually done via HTTP).

How HTTP works is pretty simple.
Let’s say Jetbrains wants to distribute a 30-day latest trial version of WebStorm. They buy a computer, connect it to the Internet, place a copy of the WebStorm image on its hard drive, and configure some software (like Apache web server) to allow people to download the image.

When a user wants to download the image, he sends a request to Jetbrains’ web server. The web server starts replying with the WebStorm’s image data as fast as the Internet link between the two of you permits.

When the image is being transferred between the two (server and user), two things are happening simultaneously — upload of the image from the server, and download of image to the user’s device. (You can think of upload process as a person speaking on the phone, and download process as a person on the other end taking notes).

This is a pretty simple and convenient method of file sharing. But it has some drawbacks as:

— Someone needs to set up a server and buy a very fast Internet connection. If the server’s Internet connection is 500 kb/s — either one client can download at 500 kb/s, or if two clients are downloading, the speed will be divided among them — and each of them will get 250 kb/s.

- If one of the clients has a slow Internet— let’s say capped at 50 kb/s, the other client can download at 450 kb/s.

- On the other hand, if 15 clients with fast Internet connections are downloading, none of them will get a speed of more than 33 kb/s (500/15). Suffice it to say, Jetbrains’ servers have a very fast Internet connection.

It’s vulnerable and easy to block. If you don’t want your users to download Webstorm images, you just have to block Jetbrains’ sites. I can’t think of why non-programmers would want to block Webstorm’s image downloads, but in case of censored content (like Government crimes), or illegal content (like pirated movies), or both (NSA leaks), we can see why the government would want to block it.

Now let’s see how torrents solve these problems:

Let’s say you are a person with access to the proof of government crime (1GB of files). You tried to host it on a website, but the government blocked it. You now want to share it with the rest of the world.

What you do is — you create a torrent of the file!

A torrent is basically a very small file containing details of the files (names, file sizes, MD5 hashes etc.) that are shared using that torrent file. You can create it easily using your torrent client (uTorrent, Azureus, Transmission etc). You also have to add tracker details to the torrent file. A tracker is a server whose job is to distribute peer lists to new peers ).

You host this very small torrent file on some torrent sharing website. People who want to download your government crime proofs can go to the torrent website and download the torrent for it.

They then tell their torrent client to download the files described in the torrent. Since there is no server (like Jetbrains’ server for Webstorm’s image) to download the torrent, from their torrent, client talks to the tracker explained as:

Client — “Bro, any idea where I can get these govt. crime videos?”
Tracker — “I don’t know man, try these people” (gives client a list of other people interested in downloading the file).
Client — “By the way, add me to your list. Just in case anyone’s interested” (gives him his IP address)
Tracker — “Cool”

Your torrent client goes to each of the people in the list so obtained, and asks them if they are interested in sharing the files. Let’s say out of the 48 people in the list, 4 say they have File 1, 3 say they have File 2, and 6 say they have both the files. 9 say that they don’t have any files, but would like to download any files you have. The rest may or may not respond.

So you start downloading File 1 from all of those 4 + 6 people who have it, and File 2 from all of those 3 + 6 people who have it. Since you’re downloading the file, they are uploading it on the other end of the internet connection. Now since you downloaded it and used other people’s internet (in addition to your own), it is your moral responsibility to allow other people to download it from you.

Thus a torrent is a group of (100s or 1000s or more) people collaborating and giving each other pieces of the file until everyone has a copy of the entire file. It starts with the person who created the torrent simply uploading it until many people download, and then they upload it in turn and the torrent spreads.

So if the file is 1GB in size, the creator has to upload at least 1GB for it to spread. Ideally, he’d upload about 3–4GB, and that would give him 3–4 more friends, who’ll help spread it further.

This is why your torrent client is both downloading and uploading the torrent file. Downloading it — so that you can use, and uploading it so that others can also access the file.

Important Points to note:

1) All people engaged in the activity of sharing the torrent are called peers.

2) The people who are uploading are called seeders.

3) The people who are downloading are called leechers.

4) A lot of people, however are both downloading and uploading at the same time and can be called both (downloading parts they don’t have and uploading the ones they do).

5) If the number of seeders is more, you are likely to download the file faster.

6) If the number of leechers is more, the download is likely to be slow.

Advantages of torrents:

• Central servers (i.e. the website where you upload the torrent, and the tracker) don’t have to share a lot of data. Both torrent files and peer lists are very small in size, hence these servers don’t cost that much to set up and maintain.
• Difficult to block — since no central server is involved in the actual distribution and sharing of the files, it is difficult to block given its distributed nature.

Thus you may realize why uploading (seeding) is so important to the concept of torrents. You are able to download only because someone else was uploading it for you. A torrent dies quickly if people refuse to upload. It may also happen that no one wants to download the torrent any more, and people who are willing to upload don’t find any takers, and after some time they give up and stop uploading that particular torrent.

Happy Torrenting!

WTH are torrents!? Explained in Layman’s terms. was originally published in codeburst on Medium, where people are continuing the conversation by highlighting and responding to this story.

Mostly referred as “The art of Googling”. Many times it happens that we wish to search on the Internet for some topic and we end up getting unsatisfactory results. Here is a list of hacks experts like Quincy Larson have recommended which you may consider whenever you are conducting a search for any topic.

• You can search within a particular URL by including the operator site:example.com before or after your keywords. Extremely helpful to search on programming websites that do not have a search functionality.

• If you’re looking for an exact phrase, use quotation marks around the keywords to view results containing that exact phrase.

• If your search terms contain a keyword with several meanings, you can exclude one of the meanings by adding a hyphen (-) before the keyword.

• Google omits most non-alphanumeric characters from its queries. Symbols that programmers use all the time like !@#$%^& and * aren’t searched. Neither are (){}[]. Fortunately, DuckDuckGo recently started supporting all characters in searches. So consider using DuckDuckGo for your more sophisticated searches. They really are the most programmer-friendly search engine.

• To generate content similar to those found on a URL you already know, use the related: operator before adding the URL.

• You can retrieve pages whose titles contain the keywords you’re searching for, by using the allintitle: operator.

• To retrieve pages where all the keywords appear in the body of the page, use the allintext: operator before the search terms.

• You can enter more than one query into Google at a time to view pages with one of the specified keywords. Just use a capitalised “OR” to separate the terms.

• To look for news items emerging from a particular location, use the location: operator, then add the city name.

• An asterisk acts as a wildcard to help you find the missing word in a phrase.

• Using the link: operator, you can find pages that link to another url. This is probably more useful for SEOs who are searching for backlinks to a specific page.

• If you’re looking for a specific file on the Web, you can use the filetype: operator to specify the particular document type you’re searching for, and Google will restrict results to pages containing those document types.

• Use words that websites would use

When people use Google search to hunt the web, they generally search for things using the same language that they would use for speaking. Unfortunately, websites don’t say things the way people do; instead, they try to use language that sounds professional. Let’s look at some examples.

• “I have a flat tire” could be replaced by “repair a flat tire.”
• “My head hurts” could be replaced by “headache relief.”

The list goes on and on. When searching, try to use terminology you would find on a professional website. This will help you get more reliable results.

• Use important words only

The way Google search works is to take what you search for and match it with keywords in online content. When you search for too many words, it may limit your results. That means it may actually take you longer to find what you’re looking for. Thus, it is apropos to use only the important words when searching for something. Let’s see an example.

• Don’t use: Where can I find a Chinese restaurant that delivers.
• Instead try: Chinese restaurants nearby.
• Or: Chinese restaurants near me.

Doing this can help Google find what you need without all the clutter. So remember, keep it simple and use important words only.

• Google Advance Book Search or Google Scholar
  Use Google Advance Book Search or Google Scholar when your looking for technical publications. It also gives you an ability to easily cite the source.

Happy Searching !

The Art of Searching something on the Internet. was originally published in HackerNoon.com on Medium, where people are continuing the conversation by highlighting and responding to this story.

It’s a reflecting eddy of leaves
A river bank fluttering will entertain
the self-assured
mud.
Of a planet,
indicates the book’s attracting brow.

Part : I

This guide will teach you:

1. How to install Node.js and npm
2. How npm is different than what you may be used to.
3. How to create a package.json file, and what that means.
4. How to install the React and ReactDOM libraries.

Installing Node and npm

Getting React up and running is not as simple as downloading one large piece of software. You will need to install many, smaller software packages.

The first thing to install is a good installer! You need a way to download and install software packages easily, without having to worry about dependencies.

In other words, you need a good package manager. We’ll be using a popular package manager named npm. npm is a great way to download, install, and keep track of JavaScript software.

You can install npm by installing Node.js. Node.js is an environment for developing server-side applications. When you install Node.js, npm will install automatically.

1. Ctrl-click here to navigate to the Node.js homepage in a new tab.
2. You should see links to download Node.js. Click on the download link of your choice. Follow the subsequent instructions to install Node.js and npm. If you've already installed Node.js, that's okay, do it anyway.

Congratulations! You’ve just installed some incredibly powerful software!

How npm is Different

When you install software, you may be used to something like this: you install what you need, it sits there on your computer, and you can use it whenever you want.

You can do that with npm! But there's a different, better way: install what you need, over and over again, every time that you need it. Download and install React every time that you make a React app.

That sounds much worse! Here’s why it’s actually better:

First, npm makes installation extremely easy. Installing software over and over sounds like a headache, but it really isn't. We'll walk through how soon!

Second, npm modules ("modules" are another name for software that you download via npm) are usually small. There are countless modules for different specific purposes. Instead of starting your app with a giant framework that includes tons of code you don't need, you can install only modules that you will actually use! This helps keep your code quick, easy to navigate, and not vulnerable to dependencies that you don't understand.

IN CONCLUSION: Starting now, every step in this article series will be a step that you have to take every time you make a new React app. You don’t have to install Node.js and npm anymore, but you should start from here for every new React project that you make.

npm init

Alright, let’s make a React app on your home computer! Where do you start?

To begin, decide where you want to save your app, and what you want to name it. In the terminal, cd to wherever you want to save your app. Use mkdir to make a new directory with your app's name. cd into your new directory.

Once you’ve done all that, type this command into your terminal:

You will get a lot of prompts! You can answer them, but it’s also safe to just keep hitting return and not worry about it.

Once the prompts are done, use your favorite text editor to open all of the files in your project’s root directory. You could do this with a terminal command such as atom . or subl .. You will see that a new file named package.json has been created!

What just happened?

The command npm init automatically creates a new file named package.json. package.json contains metadata about your new project.

Soon, you will install more npm modules. package.json keeps track of the modules that you install. Other developers can look at your package.json file, easily install the same modules that you've installed, and run their own local versions of your project! This is fantastic for collaborating.

Install React

Alright! You’ve made a project folder, navigated into it, and used npm init to create a package.json file. Now you're ready to install some modules!

To install a module using npm, you need to know that module's name. If you want to install a module and you aren't sure of its exact name, you can search for it here. Our first module is named react.

To install the react module, type this command in the terminal:

install can be abbreviated as i, and --save can be abbreviated as -S, if you like to abbreviate:

You just installed React! Now you can access it in your files with the code var React = require('react').

Install ReactDOM

If you look at package.json, you can see that there's an object named dependencies that now has react listed as a dependency. This indicates that your project is "dependent" on having react installed. If someone tries to run your project, it probably won't work unless they install react first.

You can also see something else new in your directory: a folder named node_modules.

node_modules is where npm modules are saved. If you open node_modules, you should see a folder named react, which contains the code that makes React run.

The next thing that you want to install is react-dom. Once you install react-dom, you will be able access it in your files with the code var ReactDOM = require('react-dom').

To install react-dom, type one of these two commands in the terminal:

Part:II

Background

Before React code can run in the browser, it must be changed in certain ways. One necessary transformation is compiling JSX into vanilla JavaScript.

Install Babel

Babel is a JavaScript compiler that includes the ability to compile JSX into regular JavaScript. Babel can also do many other powerful things. It's worth exploring outside of the context of this course!

Babel's npm module's name is babel-core. You're going to install babel-core slightly differently than you installed react and react-dom. Instead of npm install --save babel-core, you will use the command npm install --save-dev babel-core.

This is because you will only be using Babel in development mode. When a React app is shipped into production, it no longer needs to make transformations: the transformations will be hard-coded in place. The --save-dev flag saves an npm module for development version only.

Just as --save can be shortened to -S, --save-dev can be shortened to -D.

You’re also going to install two other babel-related modules, named babel-loader and babel-preset-react, respectively. We'll explain those soon!

Use one of these terminal commands to install babel-core, babel-loader, and babel-preset-react:

Configure Babel

In order to make Babel work, you need to write a babel configuration file.

In your root directory, create a new file named .babelrc. If you get prompted about starting a filename with a period, go ahead and say that it’s okay.

Save the following code inside of .babelrc:

That’s it! Babel is now ready to go.

Part:III

em in which your React app will automatically run through Babel and compile your JSX, before reaching the browser.

Also, JSX to JavaScript is just one of many transformations that will need to happen to your React code. You need to set up a “transformation manager” that will take your code and run it through all of the transformations that you need, in the right order. How do you make that happen?

There are a lot of different software packages that can make this happen. The most popular as of this writing is a program called webpack.

Install webpack

webpack is a module that can be installed with npm, just like react and react-dom. You'll also be installing two webpack-related modules named webpack-dev-server and html-webpack-plugin, respectively. We'll explain these a little more soon.

webpack should be saved in development mode, just like babel.

Install webpack, webpack-dev-server, and html-webpack-plugin with one of these two terminal commands:

webpack.config.js

Alright! Webpack has been installed!

Webpack’s job is to run your React code through various transformations. Webpack needs to know exactly what transformations it should use!

You can set that information by making a special webpack configuration file. This file must be located in the outermost layer of your root directory, and must be named webpack.config.js. It is where you will put all of the details required to make webpack operate.

In your root directory, create a new file named webpack.config.js.

Configure webpack

Webpack is going to take your JavaScript, run it through some transformations, and create a new, transformed JavaScript file. This file will be the ones that the browser actually reads.

In order to do this, Webpack needs to know three things:

1. What JavaScript file it should transform.
2. Which transformations it should use on that file.
3. Where the new, transformed file should go.

Let’s walk through those three steps!

First, in webpack.config.js, write:

All of webpack’s configuration will go inside of that object literal!.

What JavaScript File Should Webpack Transform?

The first thing that webpack needs to know is an entry point. The entry point is the file that Webpack will transform.

Your entry point should be the outermost component class of your React project. It might look something like this:

In this example, webpack will transform the result of <App />. If <App />'s render function contains components from other files, then those components will be transformed as well. If you make your entry point the outermost component class of your app, then webpack will transform your entire app!

To specify an entry point, give module.exports a property named entry. entry's value can be a filepath, or an array of filepaths if you would like to have more than one entry point. For this project, you will only need one.

In webpack.config.js, update module.exports to look like this:

In Node.js, __dirname refers to the currently executing file. __dirname + /app/index.js will create a filepath pointing to the currently executing file, down into a folder named app, and landing on a file named index.js.

What Transformations Should Webpack Perform?

Webpack can now successfully grab your outermost component class file, and therefore grab your entire React app. Now that webpack can grab all of this code, you need to explain what webpack should do with it once it’s been grabbed.

You can tell webpack what to do with the code that it’s grabbed by adding a second property to module.exports. This property should have a name of module and a value of an object literal containing a loaders array:

Each “loader” that you add to the loaders array will represent a transformation that your code will go through before reaching the browser.

Write a Loader

Each loader transformation should be written as an object literal. Here’s your first loader, empty for now:

Each loader object needs a property called test. The test property specifies which files will be affected by the loader:

The regular expression /\.js$/ represents all strings that end with the pattern, ".js". That means that this loader will perform a transformation on all ".js" files.

In addition to “test”, each loader transformation can have a property named include or exclude. You can use "exclude" to specify files that match the "test" criteria, that you don't want to be transformed. Similarly you can use "include" to specify files that don't fit the "test" criteria, that you do want to be transformed:

The node_modules folder contains lots of JavaScript files that will be caught by your /\.js$/ test. However, you don't want anything in the node_modules folder to be transformed. node_modules holds the code for React itself, along with the other modules that you've downloaded. You don't want to transform that!

The final property of each loader is what transformation that loader should perform! You specify a particular transformation with a property named loader:

In this example, you have a loader with three properties: test, exclude, and loader. Your loader will search for all files ending in ".js", excluding files in the node_modules folder. Whatever files it finds, it will run through the 'babel-loader' transformation.

Where does the string 'babel-loader' come from? When you ran the command npm install --save-dev babel-core babel-loader babel-preset-react, you installed babel-loader into your node_modules folder. Your loader property will automatically be able to find it there. The magic of npm!

Add babel-loader to webpack.config.js.

What Should Webpack Do With The Transformed JavaScript?

Alright! Now you have told webpack which files to grab, and how to transform those files. Webpack will grab your React app and run it through babel-loader, translating all of your JSX into JavaScript.

The final question is, where should the transformed JavaScript go?

Answer this by adding another property to module.exports. This property should have a name of output, and a value of an object:

The output object should have two properties: filename and path. filename will be the name of the new, transformed JavaScript file. path will be the filepath to where that transformed JavaScript file ends up:

This will save your transformed JavaScript into a new file named build/transformed.js.

Part:IV

HTMLWebpackPlugin

Good work! The hardest part is over. There is, however, still one issue.

Your app’s main HTML file is named app/index.html. Your app’s outermost JavaScript file, which is also your entry point for webpack, is named app/index.js. These two files are neighbors, both living in the app folder.

Before webpack performs its transformations, your entry file (app/index.js) and your HTML file (app/index.html) are located in the same directory. The HTML file contains a link to the entry file, looking something like this: <script src="./index.js"></script>.

After webpack performs its transformations, your new entry file will be located in build/transformed.js, and that link won’t work anymore!

When webpack makes a new JavaScript file, it needs to make a new HTML file as well. There is a tool for this, and you’ve already installed it: html-webpack-plugin.

Configure HTMLWebpackPlugin

At the top of webpack.config.js, add this line of code:

When you call require('html-webpack-plugin'), the returned value is a constructor function. Most of the work of configuring HTMLWebpackPlugin should be done on an instance of that constructor function.

Add this new declaration, underneath the previous one:

The HTMLWebpackPlugin Configuration Object

That empty configuration object is where you will tell HTMLWebpackPlugin what it needs to know.

The object’s first property should be named template. template's value should be a filepath to the current HTML file, the one that you're trying to copy and move:

The object’s second property should be named filename. filename's value should be the name of the newly created HTML file. It's fine to name it index.html. Since the new HTML file will be located in the build folder, there won't be any naming conflicts:

The object’s final property should be named inject. inject value should be be a string: either 'head' or 'body'.

When HTMLWebpackPlugin creates a new HTML file, that new HTML file will contain a <script> tag linking to webpack's new JavaScript file. This <script> tag can appear in either the HTML file's <head> or <body>. You choose which one via the inject property.

Here’s an full example:

The Plugins Property

You have fully configured your HTMLWebpackPlugin instance! Now all that's left is to add that instance to module.exports.

You can do this by creating a new module.exports property named plugins. plugins value should be an array, containing your configured HTMLWebpackPlugin instance!

Find the plugins property at the bottom of module.exports:

Part:V

npm scripts

Great work! You’ve installed and configured Node, npm, React, ReactDOM, Babel, and Webpack. That’s all of the installation that you need!

To make these installed parts actually run, you will be using npm command-line scripts. You’ve already used some of these, such as npm init and npm install --save react.

You will find that as your applications become more complex, you will need to use more and more verbose command-line scripts. This can become a serious pain!

Fortunately, npm scripts are here to help.

Inside of your package.json file, find the scripts object. This object lets you give your command-line scripts easier names, and look them up whenever you forget them!

Let’s say that you need to use the script npm run build && npm run git-commit && npm run git-push. That's way too much to remember. In package.json, you could add:

After that, you only need to type npm run deploy, and it will execute the command saved as deploy's value. And even better, you can look up the command in package.json if you forget.

In package.json, replace the scripts object with this:

npm run build will make webpack perform its transformations.

npm run start will start a local server! npm run start will also give you the ability to change your app and see the changes automatically, without having to restart the server for each new change.

Run a Local React App

Inside of your root directory, create a new directory named app. Create two new files inside of app: app/index.js and app/index.html.

In app/index.html, copy the following code:

In app/index.js, copy the following code:

Inside of the app folder, create a new folder named components. Create a new file inside of app/components named app/components/App.js.

In app/components/App.js, write a component class. This component class can render whatever you want. Don’t forget to require React at the top of the file, and to set module.exports equal to your component class at the bottom of the file.

In the terminal, type:

Check for a newly created build folder inside of your root directory. The build folder should contain new html and js files: build/index.html and build/transformed.js.

In the terminal, type:

Open a new browser tab and navigate to http://localhost:8080. See your React component shining gloriously in the sun.

In app/components/App.js, make a change to your component class’s render function. Refresh the browser tab and see your change appear on the screen!

The Condensed Version

That seems like an enormous amount of work to get a simple app up and running!

Perhaps it was, but that was in large part due to the fact that we slowly explained every step. Executing the steps by rote is much faster.

Here’s a condensed version of how to get a React app up and running:

In the terminal, create a new directory. cd into that directory.

Type the following command-line scripts:

• npm init
• npm i -S {react,react-dom}
• npm i -D babel-{core,loader} babel-preset-react
• npm i -D webpack webpack-dev-server html-webpack-plugin

In your root directory, create a file named .babelrc. Write this inside:

In your root directory, create another file named webpack.config.js. Write (or copy) this inside:

In package.json, replace the scripts object with this:

Create a directory inside of your root directory named app, and another directory inside of app named app/components.

Create three new files: app/index.js, app/index.html, and app/components/App.js.

Copy the code from “Run a Local React App” into app/index.js and app/index.html. Make app/components/App.js the outermost component class of your new app.

In the terminal, type these two commands:

Enjoy programming in React!

I was without doubt the mother pheasant
there in the infinite night
when it looked me with its infinite ship eyes:
it had neither nose nor feet
but silk candles on its sides
the verdure film that forms in your salt
around the aquatic poppy, many fleeting flower heads
all hooves become keys?
With its incredulous promise,
and you rustled in the felicity
and enchanted a lighting angel.

Enjoy the many self-assured
attempts to stand?
Of a crimson giant that grows grapes
and rivers and waves.