I jumped straight into a hands-on assignment and built a Custom Tokenizer visualization website from scratch.

The project helped me internalize how text becomes numbers — the same idea big models rely on. Here’s a simplified look at how a query might be tokenized in this demo:

Query: Hello, How are you?

Tokenization (simplified):
Hello  -> 543
How    -> 3745
Are    -> 867
you    -> 1290
?      -> 44

Conceptual lessons from Day 1

Beyond the practical build, Day 1 focused on several conceptual takeaways that make the AI learning curve much less intimidating.

• You don’t need to be a math genius to work in AI. There are many meaningful roles beyond cutting-edge research.

• Understanding the ecosystem and where you fit makes it easier to choose what to learn next.

We sketched a simple industry split to help visualize career paths:

=========================================
🔬 Machine Learning (The Researchers)
=========================================
• Focus on Research
• They create the core models
• They code the neural networks
• Heavy focus on Stats & Maths

-----------------------------------------
💻 Developers (The Builders)
-----------------------------------------
• They solve real-world problems
• They make money
• They build and deploy things
• Focus on Agentic AI & Workflows
=========================================

For me, knowing I’m on the “builders” side is freeing — I don’t need to rebuild models, I need to build solutions that use them.

Vector embeddings — a quick mental model

We also learned about vector embeddings: a way to map concepts into a geometric space so related things are close together. Imagine an X/Y plot where “France” is near “Eiffel Tower” and “India” is near “India Gate.” This geometric intuition is powerful for search, recommendations, clustering, and more.

What’s next

On my docket for upcoming posts:

1. Explain GPT to a 5-year-old

2. Explain vector embeddings to my mom

3. Explain tokenization to a fresher

I’ll be documenting each of these as simple, shareable explainers. Follow along as I convert these lessons into approachable posts and small demos.

Deep diving into a 35hrs+ course content and many other lessons.

Thanks for reading — I’ll keep sharing progress. If you’re learning GenAI too, I’d love to hear how you started and what helped you most.

I Recently got Graduated🎓 in 2020, yep in the Pandemic. We all hit very hard by this Corona Pandemic and we all got stuck at home for very long. We all realize the Importance of Socializing, Fitness (Physically as well Mentally), Diet of course.

The Motive of writing ✍️ this article is to share the knowledge and skills I developed So Far during this Pandemic, which was a very great opportunity for me as well as for all of you to Use this time to become more productive like never before, tell me your story in the comment section, I will love to hear from you. Moving on When I was in the Final Semester of my college which generally runs between Nov 2019 To June 2020. I Got placed in the Tech Company from College Campus and that was my biggest achievement so far after getting rejected from Interviews and Aptitude Rounds.

So after that, I had nothing to do except my college Curriculum, and deep inside my mind I always wanted to do something like a startup, following my passion, or something out of the box. But I nor Find my passion nor I got any idea to start the Startup.

"One thing About me: So far from my 2nd semester to my 7th Semester, I Choose Python as my primary language in my sem 4 and I continue to use it to explore the Web Fundamentals, and From that, I developed strong technical skills in me, but there is always a scope for improvement"

Especially in India, We all have heard that our Computer Science and IT Engineering graduates don't have the right skills set and are not fit for the Job. And This taught was always in my mind and we have to do something to stand out from the crowd and become the best in our field.

But the question was How?? How we are going to get the right industry skills without really working on it. As our Curriculum is mostly theory Based so students have to put extra effort to work on their skills.

But there is one more problem that most students are willing to put effort into building their skills but they don't have the right guidance/mentorship. Because you can't learn something if you don't know what to learn and for self-learner, they have to put a lot of effort in research and after lots of trial and error they understand and figure out whats will be good for them, but not everyone can put so much of time and efforts, right??

Things are not clear when you are starting, you don't know what is right or what is wrong the only way to know is to try it out.

With all that said, We all know that we are living in the age of Google, what is not available on the internet, everything is available and that too for free. I repeat, For free.

You don't believe, right!! See this Website Teach Me Bro. I build this with a cost of Just Rs 95 that too with GST, As I wanted .com domain else that too I could get it for free. Spectacular right !!

If you still think, you have an Idea and you wanted to showcase that to the world but you don't have enough money to build the Website or Mobile App well, then I am sorry to say that you have not explored the internet very well.

Thank you so much if you are still reading the Post. Trust me your time will worth spending here. Let move ahead with ado.

TeachMeBro 🧑‍💻

With a mindset to get highly skilled at Web Development Skills, I thought to build a Blogging Platform where I will share my Knowledge and expose to the technologies to my juniors in their early stages with proper guidance & direction. Initially, my Only aim was this but later With Pandemic gave me to open up my wings more, lets discuss them later in the post.

But Hold on!! You were thinking there are a lot of platforms available to do blogging, why you are re-inventing the wheel and not reusing the existing Websites like

• Blogger
• Medium
• Dev.to (I was not aware of such a site early)
• Hashnode (I was not aware of such a site early)

But My Aim was to hone my Developing and Programming skills and I wanted to explore how these things are made and How one I can build the same.

• I wanted to become an expert in Django Framework for that I need to explore the framework in-depth
• I wanted to Get the Whole Idea of Developing a web application locally and with Continuous Integration and Continuous Deployment how I can seamlessly push code to production.
• Wanted to Learn How to Rank The Website on google, how to optimized web pages for SEO
• How to Architect and Design the Web App to Serve the Clients.
• To Design Frontend UI to understand the Frontend Technologies better
• To Get the 360 View of the application development, which will help me to become a better developer and problem solver, and System Designer.

So that's why I Decide to Build things from scratch to gain the fundamentals knowledge of web development not only theoretically but to experience it practically in a real-world scenario before working formally in any company. And Trust Me this helped he a lot in my JOB training, It made my foundation strong and I was able to Grasp thing quickly and this helps me to understand web fundamentals better and made me dive deep into it.

How did I Achieve All this?🤔

I Used Github Education Pack to build the TeachMeBro Project

What is Github Education Pack ? 👀

Github Education Pack is the most significant set of free tools and services brought to you by GitHub and its partners across the globe to the student at zero cost. From coding boot camps, logging service, code checkers, online IDEs, mass email service -- everything is available to students at no cost. Yes, you heard that right. Any student who is 13 or above years of age and enrolled in a school or college (institution) can get this. Sounds awesome right? Read on!

You can get a free domain with SSL enabled and host your websites/apps on the servers provided by AWS, Azure, or DigitalOcean. You can also launch your great application on the cloud using Bitnami. You can use Visual Studio from Microsoft for programming and host your servers using Windows Server.

How to get it?

Prerequisites:

• Age: You need to be at least 13 years of age.
• Email address: College-issued email address to verify your academic status.

Note: If you don't have access to a college email address, you can still verify yourself as a student by uploading a picture of your college id card, report card, and issued a certificate.

How to apply 🚀

1. Register for an account on Github if not already registered.
2. If you have already registered for an account previously just add your institution-issued email address in the Email settings section of your account.
3. Go to the Education Pack Section and log in with your GitHub account.
4. Click on Get My pack and fill in all the details as required about your usage of GitHub and your school/college details
5. Click on Submit My Application and wait for approval from the Github team. Approval duration is generally around 2-3 weeks.

What are the Benefits of the Github Education Pack? 🤑

Github Education Pack provides a variety of benefits from its partnerships with software companies across the globe. The pack offers almost >$200k worth of products and licenses for free to students. They are listed below:-

• DataCamp: learn from the world’s top data scientists
• MongoDB: $200 in MongoDB Atlas Credits, plus access to MongoDB Compass and MongoDB University including free certification.
• Better Code Hub: Online source code analysis service which allows you to check your code with 10 software development guidelines and get immediate reviews and required improvements
• Canva: With Canva, anyone can create professional-looking graphics and designs. Featuring thousands of templates and an easy-to-use editor. Free for 1 year.
• ConfigCat: A feature flag and configuration management service where you can push releases to users without deploying new code. It is best suited for alpha-beta testing or soft launches.
• Cryptolens: A cloud-based software licensing platform
• Gitpod: It provides an automated and fast online IDE for GitHub
• Frontend Masters: In-depth JavaScript, Node.js, and front-end engineering courses
• Educative: Level up on trending coding skills at your own pace with interactive, text-based courses.
• Icons8: Design resources including icons, UI illustrations, photos, and more
• LogDNA: A log management platform having seamless integration with your platform and providing live monitoring and log tailing.
• Name.com: A domain name registrar and web host providing one free domain to students with Privacy Protection and SSL certificate
• Next.tech: Browser-based computing environments having no annoying IDE setup or building from prerequisite software
• Phrase: A cloud-based localization service for translation APIs and enabling localization in your apps
• PushBots: Scalable push notification system for mobile applications
• SQL Smash: A better productivity plugin for SQL Server Management Studio
• .TECH: It provides domains for your tech startup, business, event, community, or publication. Best suited for tech-based companies, providing them with a unique TLD suited for their purpose.
• One Month: Learn HTML, CSS, JavaScript, and Python in just 30 days!
• Termius: A cross-platform SSH client for desktop(Win, Linux, and macOS and mobile(iOS and Android).
• TransloadIt: A file uploading and processing service to convert files from any type to any required format, be it images, videos, audios or text/docs.
• Bootstrap Studio: A desktop app for creating responsive websites using the Bootstrap framework
• Microsoft Azure: A set of cloud services by Microsoft to help you build, manage, and deploy applications by giving free credit to students to leverage the power of the cloud to run their development workloads
• PomoDone: A Pomodoro time-tracking application to eliminate distraction, sharpen focus, and prevent burnout during your work-intensive hours using the Pomodoro Technique.
• SymfonyCasts: Symfony and PHP video tutorials and code challenges
• Algolia: A hosted search API that provides support for front-end and back-end frameworks and libraries
• AWS Educate Program: A reliable, scalable, and inexpensive cloud computing service brought to you by Amazon Web Services plus free training, and collaboration resources
• Datadog: cloud-based infrastructure monitoring
• DigitalOcean: Simple cloud hosting built for developers with virtual private servers starting from as low as $5/month.Also has support for Kubernetes clusters.
• Flatiron School: Web coding Bootcamp for launching developers
• Heroku: A flexible, easy-to-use platform to deploy, run, and manage your apps with one-click deployment options for any framework plus integration with famous repository hosting services.
• LambdaTest: An automated, live, and interactive cross-browser testing on 2,000+ real browsers and operating systems
• Jetbrains: Student Licenses of professional desktop IDEs such as IntelliJ IDEA, PyCharm, and more.
• Namecheap: Affordable domain registration, hosting, and management
• Sendgrid: The world's largest cloud-based email delivery platform to attach to your applications
• Stripe: A web and mobile payment APIs, built for developers
• Thinkful: courseware and mentoring to launch your career as a developer
• Travis CI: a continuous integration platform for open source and private projects
• And Many More!!

Start your developer journey by exploring the pack here: https://education.github.com/pack

How long will it take to get my application reviewed?

The Github team manually reviews every request so that only genuine applicants get their packs. This process takes time, that's why it might be long before you get a response. If you have a college email which is already whitelisted by them, you can get it instantly.

If you have queries regarding their process or problem redeeming any benefits, you can contact them on their support email.

GitHub Education Pack Will give you everything you need to build a scalable application with the best standards.

What things I used From this pack ✨

1. Heroku - I used Heroku to host my application and the pack includes a Hobby Dyno which is enough to handle application load.

2. Godaddy: I used Godaddy to purchase the .com domain as in the pack no tool was offering a .com domain and which is fine.

3. NameCheap - provides free domain

4. DataCamp - to learn Shell Scripting and other courses.

5. Canva - I manage the Instagram page where I share tech posts, so for creating posts I used Canva

6. Bootstrap Studio - I learned this tool but never used it as I prefer to code.

7. And Other tools which provide learning content.

How I Applied SEO to the Website 🔍

Applying the best Search Engine Optimization (SEO) strategy was difficult with a lack of knowledge. I used the following sites and random searches on google to get things done.

1. Moz SEO Learning
2. Digital Marketing Course By Google - I didn't complete the whole course

Free Tools I used for SEO Analysis: 🔥

• SEO Optimizer
• Neil Patel
• SEO Site Check

💡TIP: I think the best way to learn and apply SEO skills is to use the above tools and see the SEO report and from there you will know exactly whats needs to be done to fix the SEO of your Website.

My Learnings 🧠

Got Experienced in building responsive websites, Ranking web pages, SEO, Domain Ranking, User Authentication, Hosting the App with CI, CD process, Monitoring the Web app, Maintaining the App In Production, used Google Analytics, Adsense, Disqus & I learned to optimize static files for better user experience and also this project helped me to understand the core of CMS (Content Management System) system. Libraries used CK-Editor, Prism, Data Tables.

Also, I trained Students on Web Fundamentals by giving Internships under the community which I formed during the lockdown 🔒.

Takeaways🏆

• You can take up any project and target the skills you want to build/improve
• Googling is an Art. Asking the right set of questions will get you closer to what you want.
• You can learn anything you want to learn, just use the Internet wisely.
• Keep Learning and Keep Exploring.

Thanks to Github💯

I would like to thanks Github for providing free access to the best developer tools in one place so we can learn by doing and get hands-on experience with real-world tools

Github Education Pack helped me a lot in building the skills that I wanted to. And I hope with this blog you got aware of such opportunity.

If you already have a project to track your files then you can skip this section and if not then continue.

Initializing a Repository from Non-existing Directory:

So if you don't have a project folder to track with git then we will create one from scratch. Follow the below steps:

1. Create a folder with the name 'test' on Desktop or you can create it anywhere on your system.
2. Then open your terminal and change your directory to 'test' folder in my case it will be cd /home/altaf/Desktop/Tutorial/Git/test in your case cd 'path of your test directory'
3. Now type git init to initialize a git repository.

altaf@kali:~/Desktop/Tutorial/Git/test$ git init

Initialized empty Git repository in /home/altaf/Desktop/Tutorial/Git/test/.git/

This creates a new subdirectory named .git that contains all of your necessary repository files --- a Git repository skeleton.

Now create two files in the test directory named them test1.txt and test2.txt, you can use the below command to create them directly from the terminal.

$ touch test1.txt test2.txt

And also add some random data inside both the files.

So now we have a project folder with some files. Now move ahead to start working in the project folder with git and now you can skip the next section because you have already created a project folder in this section initialized it with git.

Initializing a Repository in an Existing Directory

If you have a project directory that is currently not under version control and you want to start controlling it with Git, you first need to go to that project's directory. If you've never done this, it looks a little different depending on which system you're running:

for Linux:

$ cd /home/user/my_project

for macOS:

$ cd /Users/user/my_project

for Windows:

$ cd C:/Users/user/my_project

and type:

$ git init

Example:

altaf@kali:~/Desktop/Tutorial/Git/test$ git init

Initialized empty Git repository in /home/altaf/Desktop/Tutorial/Git/test/.git/

This creates a new subdirectory named .git that contains all of your necessary repository files --- a Git repository skeleton.

So now we have a project folder which is now under version control and now we can start controlling it with Git.

Git in Action:

Now let's start controlling our project with git,

Run the git status command to check the status of your local repository,

altaf@kali:~/Desktop/Tutorial/Git/test$ git status

Output:

On branch master

No commits yet

Untracked files:

  (use "git add <file>..." to include in what will be committed)

        test1.txt

        test2.txt

nothing added to commit but untracked files present (use "git add" to track)

It says you have untracked files test1.txt and test2.txt, use git add . command to track all the files present in the directory or use can use git add test1.txt and git add test2.txt to track a file using the filename.

Now run the following commands:

altaf@kali:~/Desktop/Tutorial/Git/test$ git add .

altaf@kali:~/Desktop/Tutorial/Git/test$ git status

Output:

On branch master

No commits yet

Changes to be committed:

  (use "git rm --cached <file>..." to unstage)

        new file:   test1.txt

        new file:   test2.txt

Now we have added the files into the staging area (where we save the file so that git is able to track any changes made to those files) and This stages them for the first commit. Now we are ready to commit the changes.

Now run the following commands:

$ git commit -m "First commit"

Output:

[master (root-commit) 8db38b6] First commit

 2 files changed, 0 insertions(+), 0 deletions(-)

 create mode 100644 test1.txt

 create mode 100644 test2.txt

This will Commit the files that you've staged in our local repository.

So before pushing our code into the Remote repository i.e on Github (our online repository) let's check one more command.

Git Log:

The Git Log tool allows you to view information about previous commits that have occurred in a project.

altaf@kali:~/Desktop/Tutorial/Git/test$ git log

Output:

commit 8db38b60919a67b9f912d1e9e782a5ccb7588eb4 (HEAD -> master)

Author: altaf99 <iamaltafshaikh07@gmail.com>

Date:   Wed Apr 1 22:37:02 2020 +0530

    First commit

Pushing our code on Remote Repository (Github):

Before pushing our code we need a repository to share/upload our code, so let's create one.

1. Go to https://github.com/ and login into your account.
2. In the upper-right corner of any page, click on +, and then click New repository.

3. Type "hello-world" as a name for your repository, and an optional description.

4. Choose to make the repository either public or private. Public repositories are visible to the public, while private repositories are only accessible to you, and people you share them with.

5. When you're finished, click Create repository.

6. At the top of your GitHub repository's Quick Setup page, click to copy the remote repository URL.

Now to connect Remote repository "hello-world" with our local repository will use git remote add origin command which we have previously learned.

In Terminal, add the URL for the remote repository where your local repository will be pushed.

$ git remote add origin https://github.com/altaf99/Hello-world.git

Now Verifies the new remote URL

$ git remote -v

altaf@kali:~/Desktop/Tutorial/Git/test$ git remote -v
#output

origin  https://github.com/altaf99/Hello-world.git (fetch)

origin  https://github.com/altaf99/Hello-world.git (push)

Now let's Push the changes in your local repository to GitHub.

$ git push origin master

Kudos!! We have Pushes the changes in your local repository up to the remote repository we have specified.

Congratulations!! We have successfully pushed the code into our remote repository and also we have learned and understand the basics of Git and we are also successfully able to implement the Git commands.

Hope you enjoyed the tutorial, please share this tutorial with your friends if you find this tutorial helpful.

Thank You!!

We will see the advanced concept of Git in upcoming sections.

Basic Git Commands:

1) git init

Utility: To initialize a git repository for a new or existing project.

How to: git init in the root of your project directory.

Example:

git init

2) git clone

Utility: To copy a git repository from a remote source, it also sets the remote to original source so that you can pull again.

How to: git clone <:git url:>

Example:

git clone https://github.com/altafshaikh/Friends-The-Social-Network.git

3) git status

Utility: To check the status of files you've changed in your working directory, i.e, what all has changed since your last commit.

How to: git status in your working directory. lists out all the files that have been changed.

Example:

git status

4) git add

Utility: adds changes to stage/index in your working directory.

How to:

git add .

5) git commit

Utility: To save changes to the local repository safely. Commit takes a snapshot of the project and treats it as a version.

How to:

git commit -m "sweet little commit message"

6) git push

Utility: It is used to transfer or push the commit, which is made on a local branch in your computer to a remote repository

How to: git push <:remote:> <:branch:>

Example:

git push origin master

7) git pull

Utility: It is used to fetch and download content from a remote repository and immediately update the local repository to match that content.

How to: git pull <:remote:> <:branch:>

Example:

git pull origin master

8) git --version

Utility: To check the version if the git is installed

How to:

git --version

9) git remote

Utility: To check what remote/source you have or add a new remote.

How to: git remote to check and list. And git remote add <:remote_url:> to add a remote.

Example:

git remote add https://github.com/altafshaikh/Friends-The-Social-Network.git

​Congratulations!! We have learned basic commands of Git and now we are ready to use them and see Git in action, in our next section.

​

Getting Started - Installing Git

Installing Git

Before you start using Git, you have to make it available on your computer. Even if it's already installed, it's probably a good idea to update to the latest version. You can either install it as a package or via another installer or download the source code and compile it yourself.

Installing on Linux

Git is already installed in all Linux flavors but if your system doesn't have git installed then follow along with the tutorial. If you want to install the basic Git tools on Linux via a binary installer, you can generally do so through the package management tool that comes with your distribution.

If you're on Fedora (or any closely-related RPM-based distribution, such as RHEL or CentOS), you can use dnf:

$ sudo dnf install git-all

If you're on a Debian-based distribution, such as Ubuntu, Kali Linux try apt:

$ sudo apt install git-all

For more options, there are instructions for installing on several different Unix distributions on the Git website, at https://git-scm.com/download/linux.

Installing on macOS

There are several ways to install Git on a Mac. The easiest is probably to install the Xcode Command Line Tools. On Mavericks (10.9) or above you can do this simply by trying to run git from the Terminal the very first time.

$ git --version

If you don't have it installed already, it will prompt you to install it.

If you want a more up-to-date version, you can also install it via a binary installer. A macOS Git installer is maintained and available for download at the Git website, at https://git-scm.com/download/mac.

Figure. Git macOS Installer.

You can also install it as part of the GitHub for macOS install. Their GUI Git tool has an option to install command line tools as well. You can download that tool from the GitHub for macOS website, at https://desktop.github.com.

Steps to Install Git on Windows

1) Download the latest Git for Windows.

2) Go to the folder where new downloads gets store, at my machine by default folder is Downloadfolder. Double click on the installer. The installer gets save on the machine as per the Windows OS configuration. My machine is 64 bits.

Note: When you've successfully started the installer, you should see the Git Setup wizard screen. Follow the Next and Finish prompts to complete the installation. The default options are pretty sensible for most users.

3) You may like to keep the installation to another folder, so here is the chance to do so. I just want to keep it in the suggested default folder in my Program Files\Git.

4) This is the option to store the shortcut of the Git under the Program Menu.

5) This is asking your choice, whether you like to Git from the Windows Command Prompt or you like to use some other program like Git Bash. As of now just select the Windows Cmd for simplicity of the tutorial, later we will cover Git Bash and other as well.

6) If you have PuTTY/TortoiseSVN installed, you may see this screen, otherwise just ignore this. Regardless, use OpenSSL to make things easy.

7) Here, we recommend to choose the option of Checkout Windows-style, commit Unix-style line endings. Select next once you have done this.

8) Again, just go with default selection and move forward.

9) Just go with default selections, as we will cover the details in later advance chapter.

10) Now, it's all done. This will just take a few minutes to complete the installation as per your machine speed.

11) Once done, just click on Finish button

12) Let's just verify if the installation went well for Git. Go to cmdand type gitand press enter. you should get the following output on the screen.

Configure GitHub Credentials with Git:

Configure your local Git installation to use your GitHub credentials by entering the following:

git config ----global user.name "<github_username>"

git config ----global user.email "<email_address>"

Note: Replace <github_username> and <email_address> with your GitHub credentials.

Example:

git config ----global user.name "altafshaikh"

git config ----global user.email "iamaltafshaikh07@gmail.com"

Checking Your Settings

If you want to check your configuration settings, you can use the git config --list command to list all the settings Git can find at that point:

$ git config --list

Output:

user.email=iamaltafshaikh07@gmail.com

user.name=altafshaikh

Now we are ready to use the Git. In the next section, we will see some basic commands of Git.

​

What is git?

Git is a free and open-source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. Git is easy to learn and has a tiny footprint with lightning-fast performance. Git was initially designed and developed by Linus Torvalds for Linux kernel development.

So let's see what do we mean by the version control system.

Version Control System

Version Control System (VCS) is a software that helps software developers to work together and maintain a complete history of their work.

Listed below are the functions of a VCS -

• It allows developers to work simultaneously.
• Maintains a history of every version.
• It does not allow overwriting each other's changes.

Following are the types of VCS -

• Centralized version control system (CVCS).
• Distributed/Decentralized version control system (DVCS).

Centralized Version Control

Centralized version control systems are based on the idea that there is a single "central" copy of your project somewhere (probably on a server), and programmers will "commit" their changes to this central copy. There are quite a lot of tools available to meet this need, including Perforce, Mercurial, SVN are examples of centralized version control.

Distributed Version Control System

A centralized version control system (CVCS) uses a central server to store all files and enables team collaboration. But the major drawback of CVCS is its single point of failure, i.e., failure of the central server. Unfortunately, if the central server goes down for an hour, then during that hour, no one can collaborate at all. And even in a worst-case, if the disk of the central server gets corrupted and proper backup has not been taken, then you will lose the entire history of the project. Here, a distributed version control system (DVCS) comes into the picture.

DVCS clients not only check out the latest snapshot of the directory but they also fully mirror the repository. If the server goes down, then the repository from any client can be copied back to the server to restore it. Every checkout is a full backup of the repository. Git does not rely on the central server and that is why you can perform many operations when you are offline. You can commit changes, create branches, view logs, and perform other operations when you are offline. You require a network connection only to publish your changes and take the latest changes.

Advantages:

• Distributed model: This means your work is your own. You can let others see only what is necessary. Not everything has to be public. There are other advantages to the distributed model, such as the speed (since most everything is local) and possibility of working offline Branching and merging are easy: Branching is a walk in the park. It feels like a natural part of the workflow. They are cheap (fast and consume very little space) so that you can branch whenever you want. This means you can sandbox your features and ideas till they are ready for the mainstream.
• Workflow is flexible: Compared to Centralized VCS, git has the qualities that allow you to choose your own workflow.
• Data integrity is assured: Because git uses SHA1 trees, data corruption due to external reasons can be easily detected.
• Security: Git uses a common cryptographic hash function called secure hash function (SHA1), to name and identify objects within its database. Every file and commit is check-summed and retrieved by its checksum at the time of checkout. It implies that it is impossible to change file, date, and commit message and any other data from the Git database without knowing Git.\ Icing on the cake:
• Fast: Git is very fast, even when compared to other DVCS, for local as well as network operations
• Staging area: Make sure your commits have logically grouped changes and not everything else you are working on.
• Free: I am sure you don't want to spend 450$ for your personal project. Your manager will appreciate it if you save him N x 450$

Disadvantages:

• Steep learning curve: Many commands with many options, some commands are non-intuitive and need a level of understanding the internals of git, commands and arguments are inconsistent to some degree
• Binary files are a big no: If your project has non-text files that are updated frequently (images for websites or MS Office documents), then git becomes bloated and slow. (I believe it still does better than most systems)

That's it!! In the next section, we will see how toinstallandconfigureGit onto your system.

Let's Begin

​If you are a beginner and don't know how to use Github then this post is for you. In this post, I will guide you on how to use the Github account in an easy way.

GitHub is a website and service that we hear geeks rave about all the time, yet a lot of people don't really understand what it does. Want to know what all GitHub is about? Read on to find out.

First, we will need a Github account. If you don't have a Github account then click here to create a Github account else you can continue reading the post, if you already had one.

After having the Github account login into your account and now we are ready to use Github and understand the Github environment.

Let's first understand few terminologies mentioned below:

What is Github?

GitHub is a code hosting platform for collaboration and version control and lets you (and others) work together on projects.

What is Github Profile?

A GitHub Profile is just like any other social media profile, like a Facebook or Twitter profile, except for the fact that it's for GitHub. It's also very programming-centric and helps promote the visibility of your GitHub-hosted projects and a Github profile link looks like this https://github.com/username/

For example, my Github username is altafshaikh so my Github profile link will be https://github.com/altafshaikh/.

Let's see how a Github profile looks like...

What is meant by contribution and contribution graph?

Your profile contributions graph is a record of contributions you've made to GitHub repositories. Contributions are timestamped according to Coordinated Universal Time (UTC) rather than your local time zone.

Let's see how a Github Contribution Graph looks like...

What is a Repository or Repo?

A repository (usually abbreviated to "repo") is a location where all the files for a particular project are stored. Each project has its own repo, and you can access it with a unique URL.

Let's see how a Github Repository looks like...

Repository Overview

How to download a project or repository from Github?

There are mainly two ways in which you can download a repository from Github.

1. Direct download zip from the repository and extract it.

1. Using git clone command to clone or download the repository directly into your local machine via terminal. (we will learn more about git and git commands in further posts)

git clone https://github.com/altafshaikh/Friends-The-Social-Network.git

PS: Some Screenshots used in this article are old when my username was different, so don't get confused just stick to the concept : )

How to create a Github repository?

• Click on +
• Click on New Repository

• Fill in the details of the repository.

• And Hit on the Create Repository button to create the repository.

Congratulations, you have learned the basics of Github and how to use it. In further posts, we will learn more advanced concepts. I hope you enjoyed the post.

`Thank you for reading my post and I will bring more such posts so stay tuned with me.

In this Section, we will see how to configure the routes and controllers together and also one request to you is to keep a little more focus and have patience and faith in me : D, because from this point of time, you may get lost inside files and folder and nothing will make sense to you, and you wouldn't know what exactly is happening so have patience, in the end, everything will connect and make sense : )

So we will start with the routes, we have already defined our routes and their purpose.

As we can see in the table, we have 5 routes, so we will have 5 controllers. But there is one logical problem we have only 2 routes not 5, if you closely look at the Path column we only have /todos and /todos/:id and they are reused multiple times this is because we can future differentiate same route based on the HTTP methods ( GET, POST, PUT, DELETE, etc ). So you can see in the Method column, we have different HTTP methods for the same routes.

So let's start with the /todos route, this will return all tasks from database, now we will create a route and define the respective controller for it and then the process will repeat for other routes.

Create a todoRoutes.js file inside /routers folder we had created previously.

/todos/todoRouters.js

// import express
const express = require("express");

// controllers
const { getAllTodos } = require("../controllers/todoControllers");

// initialize route using express router
const todoRoute = express.Router();

// define the /todos + / => /todos/ route to get all todos
todoRoute
  .route("/")
  .get(getAllTodos);  // we will define and import this function soon

// export the route
module.exports = todoRoute;

Now, let's move onto the controller, create a todoControllers.js file inside /controllers and also now we will require our todo model we had created inside model/todos.js

/controllers/todoControllers.js

// import the todo model
const Todos = require("../models/todos");

const getAllTodos = (req, res) => {

 // mongoose find
  Todos.find({}) 

      .then((todos) => {

        res.status(200); // setting 200 ok  response status
        res.setHeader("Content-Type", "application/json");  // setting header as json
        res.json({ todos: todos });  // sending data to client in JSON 

      })
      .catch((err) => {

        res.status(500);   // setting 500 internal server error
        res.json({ error: err });   // sending error to client in JSON 

      });
};

// export the controllers
module.exports = {
  getAllTodos,
};

Now, lets link our router to our express app.

Open app.js file and import todoRouter from todoRouters.js :

//routes
const todoRouter = require("./routes/todoRoutes");

now, add the following line below your initialization of express app line 

.
.

const app = express();
.
.

app.use("/todos", todoRouter);

Updated app.js

// import express
const express = require("express");

//import mongoose
const mongoose = require("mongoose");

// import dotenv
const dotenv = require("dotenv");

// routers
const todoRouter = require("./routes/todoRoutes");

// load environment variable
dotenv.config({ path: ".env" });

// read env variable using process.env.<your_env_variable_name>
const PORT = process.env.PORT;
const dbURI = process.env.DATABASE_URL;

// making connection object
const connect = mongoose.connect(dbURI, {

  useNewUrlParser: true,
  useUnifiedTopology: true,

});

// connecting with database
connect.then(

  (db) => {
    console.log("Connected Successfully to Mongodb Server");
  },

  (err) => {
    console.log(err);
  }

);

// initialize express app
const app = express();

// sending a hello response on visiting http://localhost:3000/
app.get("/", (req, res) => {

  res
    .status(200)
    .json({ message: "Hi I am Server", data: "no data on this endpoint" });

});

app.use("/todos", todoRouter);

// listening for any HTTP requests on PORT 3000
app.listen(PORT, () => {

  console.log(`Server is running at http://localhost:${PORT}`);

});

Now if you visit http://localhost:3000/todos/ you should see the below response on your browser.

Output:

{"todos":[]}

Congratulations! You have created your very own REST API backend : )

Now, let's move on to completing our routes and controllers for all the remaining Endpoints.

Completing Routes And Controllers - CRUD Operations

​ ​We are almost done! Finally, let's implement the remaining routes and controllers, and after that, we will test our API Endpoints using Postman.

Now, the process remains the same for all other routes except the logic will change, like for delete route your controller will implement the logic to delete the todo using the provided todoID.

Lets, quickly define the route handlers for all the remaining routes

Final /todos/todoRouters.js

// import express
const express = require("express");

//controllers
const {
  getAllTodos,
  createTodo,
  getTodoById,
  updateTodo,
  deleteTodo,
  taskCompletionTime,
} = require("../controllers/todoControllers");

// initialize route using express router
const todoRoute = express.Router();

// define the /todos + / => /todos/ route to get all todos
todoRoute.route("/").get(getAllTodos).post(createTodo); // same route different method chained together
todoRoute.route("/:id").get(getTodoById).put(updateTodo).delete(deleteTodo);

// export the route
module.exports = todoRoute;

Kindly ignore the error and warning in the console they all will disappear soon : D

Remaining Controllers

Create Todo Controller

// import uniquid to generate unique ids
const uniquid = require("uniquid");

const createTodo = (req, res) => {
    const { description } = req.body;

    Todos.create({ taskID: uniquid(), description: description})
    .then((todo) => {
      res.status(200);
      res.setHeader("Content-Type", "application/json");
      res.json({ status: "Todo added successfully", data: todo });
    })
    .catch((err) => {
      res.status(404);
      res.json({ message: "Invalid Object Property", error: err });
    });
};

Get Single Todo Controller

const getTodoById = (req, res) => {
  Todos.findById(req.params.id)
    .then((todo) => {
        res.status(200);
        res.setHeader("Content-Type", "application/json");
        res.json(todo);
    })
    .catch((err) => {
      res.status(404);
      res.json({ message: "Id did not exists", error: err });
    });
};

Update Todo Controller

const updateTodo = (req, res, next) => {
     Todos.findByIdAndUpdate(
          { _id: req.params.id },
          {
            $set: req.body,
          },
          { new: true, useFindAndModify: false } //get updated result
        )
          .then((todo) => {
            res.status(200);
            res.setHeader("Content-Type", "application/json");
            res.json(todo);
          })
          .catch((err) => {
            res.status(404);
            res.json({ message: "unable to update", error: err });
     });
};

Delete Todo Controller

const deleteTodo = (req, res, next) => {
    Todos.findByIdAndRemove(req.params.id)
        .then((response) => {
            res.status(200);
            res.setHeader("Content-Type", "application/json");
            res.json({
              status: "Todo deleted successfully",
              response: response,
            });
          })
        .catch((err) => {
            res.status(404);
            res.json({ message: "unable to delete", error: err });
      });
};

Updated Controllers - Final

/controllers/todoControllers.js

// import uniquid to generate unique ids
const uniquid = require("uniquid");

// import the todo model
const Todos = require("../models/todos");

// get all todos
const getAllTodos = (req, res) => {
  // mongoose find
  Todos.find({})
    .then((todos) => {
      res.status(200); // setting 200 ok  response status
      res.setHeader("Content-Type", "application/json"); // setting header as json
      res.json({ todos: todos }); // sending data to client in JSON
    })
    .catch((err) => {
      res.status(500); // setting 500 internal server error
      res.json({ error: err }); // sending error to client in JSON
    });
};

// create task in todo
const createTodo = (req, res) => {
  const { description } = req.body;

  Todos.create({ taskID: uniquid(), description: description })
    .then((todo) => {
      res.status(200);
      res.setHeader("Content-Type", "application/json");
      res.json({ status: "Todo added successfully", data: todo });
    })
    .catch((err) => {
      res.status(404);
      res.json({ message: "Invalid Object Property", error: err });
    });
};

// get a single todo task
const getTodoById = (req, res) => {
  Todos.findById(req.params.id)
    .then((todo) => {
      res.status(200);
      res.setHeader("Content-Type", "application/json");
      res.json(todo);
    })
    .catch((err) => {
      res.status(404);
      res.json({ message: "Id did not exists", error: err });
    });
};

// update todo task
const updateTodo = (req, res, next) => {
  Todos.findByIdAndUpdate(
    { _id: req.params.id },
    {
      $set: req.body,
    },
    { new: true, useFindAndModify: false } //get updated result
  )
    .then((todo) => {
      res.status(200);
      res.setHeader("Content-Type", "application/json");
      res.json(todo);
    })
    .catch((err) => {
      res.status(404);
      res.json({ message: "unable to update", error: err });
    });
};

// delete single todo task
const deleteTodo = (req, res, next) => {
  Todos.findByIdAndRemove(req.params.id)
    .then((response) => {
      res.status(200);
      res.setHeader("Content-Type", "application/json");
      res.json({
        status: "Todo deleted successfully",
        response: response,
      });
    })
    .catch((err) => {
      res.status(404);
      res.json({ message: "unable to delete", error: err });
    });
};

// export the controllers
module.exports = {
  getAllTodos,
  createTodo,
  getTodoById,
  updateTodo,
  deleteTodo,
};

Browser can only perform GET request, so in order to perform POST, PUT, DELETE requests we will be using an industry-standard tool for testing APIs i.e Postman

Lastly, add following more lines into the app.js:

npm install cors

Cors module allows your frontend application to fetch data from this backend, which is running on different ORIGIN.Learn more about Browser's Same Origin Policy

// import cors on top
const cors = require("cors");

Now below this line add the following lines
const app = express();
.
.
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: false }));

Updated app.js

// import express
const express = require("express");
//import mongoose
const mongoose = require("mongoose");
// import dotenv
const dotenv = require("dotenv");
const cors = require("cors");

// routers
const todoRouter = require("./routes/todoRoutes");

// load environment variable
dotenv.config({ path: ".env" });

// read env variable using process.env.<your_env_variable_name>
const PORT = process.env.PORT;
const dbURI = process.env.DATABASE_URL;

// making connection object
const connect = mongoose.connect(dbURI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

// connecting with database
connect.then(
  (db) => {
    console.log("Connected Successfully to Mongodb Server");
  },
  (err) => {
    console.log(err);
  }
);

// initialize express app
const app = express();

app.use(cors());
app.use(express.json());  // parse JSON data into JS object
app.use(express.urlencoded({ extended: false })); //allows you to accept form submitted data

// sending a hello response on visiting http://localhost:3000/
app.get("/", (req, res) => {
  res
    .status(200)
    .json({ message: "Hi I am Server", data: "no data on this endpoint" });
});

app.use("/todos", todoRouter);

// listening for any HTTP requests on PORT 3000
app.listen(PORT, () => {
  console.log(`Server is running at http://localhost:${PORT}`);
});

So Finally, Our Code is Completed, we had successfully created our REST API Backend using Nodejs, MongoDB, and Express. In the next section, we will test our backend using Postman

Get the Final Code on Github

Building Todo Backend Code

Workshop Video

Watch My Hands-On Workshop on Building A TODO REST API BAckend

​

So before connecting with the MongoDB database we need to structure how we are going to model our data for todo. In our case which fields we will need to store the information about a todo task.

Task model

• taskID - to uniquely identify the task

• description - to store description about a task

• completed - this will hold boolean value and it will help us to determine whether the task is completed or uncompleted

These fields are sufficient for a basic todo app to store information about a task, we can easily perform CRUD operation on this model.

So we have finalized the fields for our model, so now let's move ahead and create our mongoose schema model.

Mongoose Schema Model

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It manages relationships between data, provides schema validation, and is used to translate between objects in code and the representation of those objects in MongoDB.

I know the definition would not have made much sense to you so let me explain it to you in simple words.

Mongodb is schema less database so to enforce a definite schema on the database mongoose is used, along with the power of noSQL, it has in-built validation, we can define on our schemas.

To learn more about mongoose checkout this tutorial here.

Creating Todo Model

Model is an object representation of data in the database.

Install following packages:

npm install mongoose uniquid

We had installed the mongoose and uniquid packages to generate unique ids for taskID.

So, Let's create a file models/todo.js with the content:

// import mongoose
const mongoose = require("mongoose");

// reference to Schema from mongoose
const Schema = mongoose.Schema;

// creating and defining the schema
const todoSchema = new Schema(
{

  taskID: {

    type: String,

    required: true,

  },

  description: {

    type: String,

    required: true,

  },

  completed: {

    type: Boolean,

    default: false,

  },

},

{

  timestamps: true,

}

);

// use the schema to create a model
var Todos = mongoose.model("Todo", todoSchema);

// export the Todos model to use inside other modules(js files)
module.exports = Todos;

So now our Todo model is ready we can now move on to make a database connection with the MongoDB for that we are going to use MongoDB Atlas.

Making Database Connection​​

Now follow the steps in this blog and get the database url which will look like this:

mongodb+srv://sample_user:<password>@my-sample-cluster-b3ugy.mongodb.net/<dbname>?retryWrites=true&w=majority

Now, Add the below line in the .env file, complete the database string with your passwordand database name

DATABASE_URL=mongodb+srv://sample_user:<password>@my-sample-cluster-b3ugy.mongodb.net/<dbname>?retryWrites=true&w=majority

Updated .env

.env

PORT=3000

DATABASE_URL=mongodb+srv://sample_user:<password>@my-sample-cluster-b3ugy.mongodb.net/<dbname>?retryWrites=true&w=majority

Making Database Connection

Open app.js file

Import mongoose

const mongoose = require("mongoose");

Add this line below where PORT is defined:

const dbURI = process.env.DATABASE_URL;

now create a database connection

// making database object 
const connect = mongoose.connect(dbURI, {

  useNewUrlParser: true,

  useUnifiedTopology: true,

});

// connecting with database
connect.then(

  (db) => {

    console.log("Connected Successfully to Mongodb Server");

  },

  (err) => {

    console.log(err);
  }

);

Update app.js

// import express
const express = require("express");

//import mongoose
const mongoose = require("mongoose");

// import dotenv
const dotenv = require("dotenv");

// load environment variable
dotenv.config({ path: ".env" });

// read env variable using process.env.<your_env_variable_name>

const PORT = process.env.PORT;
const dbURI = process.env.DATABASE_URL;

// making connection object

const connect = mongoose.connect(dbURI, {

  useNewUrlParser: true,

  useUnifiedTopology: true,

});

// connecting with database
connect.then(
  (db) => {

    console.log("Connected Successfully to Mongodb Server");

  },

  (err) => {

    console.log(err);

  }

);

// initialize express app
const app = express();

// sending a hello response on visiting http://localhost:3000/
app.get("/", (req, res) => {

  res

    .status(200)

    .json({ message: "Hi I am Server", data: "no data on this endpoint" });

});

// listening for any HTTP requests on PORT 3000
app.listen(PORT, () => {

  console.log(`Server is running at http://localhost:${PORT}`);

});

Restart your server and you should see the following output in your terminal:

Output:

Server is running at http://localhost:3000

Connected Successfully to Mongodb Server

Now we are successfully connected with the database and now we can move on to create routes and controllers.

​

I am Using VS code as my editor to code the project you can feel free to choose any other editor

So we will follow MVC pattern (model, View, Controller) for our project which is an industry standard. So don't worry about this heavy term its basically means we are going to create some folders and we keep relative code in the respective folders. Simple!. Lets talk little about MVC before going ahead.

MVC Architecture Pattern:

The Model-View-Controller (MVC) is an architectural pattern that separates an application into three main logical components: the model, the view, and the controller. Each of these components are built to handle specific development aspects of an application. MVC is one of the most frequently used industry-standard web development framework to create scalable and extensible projects.

In our case, we will only focus on Model and Controller, the View can be separately handled by frontend frameworks like React Js, Vue JS, ect. With the help of REST APIs. In this way we are creating a decoupled Web application where backend is written in Node JS and Frontend can be written separately using react or any other framework of your choice, both the application will talk with each other via API calls.

We'll create just 3 folders in the directory you created above.

1. models: This houses our entity (Todo data structure).

2. routes: A route is an entry to your application. This folder contains a file that defines what should happen when a user accesses a particular route.

3. controllers: This file basically contains functions which hold actual execution logic and each function is linked with a route specifying which controller(function) present in this file needs to be executed when a particular route is matched inside the route file.

So we have setup our project directory, lets setup the Express server now.

Setting Up The Express App

Let's setup our Express server to handle HTTP request made by any client.

Now, open the terminal in your project folder to create a package.json file using the below command, this file will store the basic info about our project and our project dependencies

npm init -y

-y flag will skip all the question asked by npm init command and directly create a package.json file you can also run npm init

so, once we have our package.json file we can now move on to installing some packages.

npm install express dotenv

We had installed express to create a backend server and dotenv to load and read environment variables.

npm install -g nodemon

We are installing the nodemon package globally because nodemon is a tool that helps develop node.js based applications by automatically restarting the node application when file changes in the directory are detected. So that we don't need to manually restart the server for any changes in the code.

Next, create a file called app.js and lets create an express application server which is running on PORT 3000 and also we will store this PORT value inside the .env file and read using dotenv package.

// .env file

PORT=3000

app.js

// import express 
const express = require("express");

// import dotenv
const dotenv = require("dotenv");

// load environment variable
dotenv.config({ path: ".env" });

// read env variable using process.env.<your_env_variable_name>
const PORT = process.env.PORT;

// initialize express app

const app = express();

// sending a hello response on visiting http://localhost:3000/
app.get("/", (req, res) => {

  res.status(200).json({ message: "Hi I am Server", data: "no data on this endpoint" });

});

// listening for any HTTP requests on PORT 3000
app.listen(PORT, () => {

  console.log(`Server is running at http://localhost:${PORT}`);

});

So our express app is Setup. Run the below command and open your browser and visit http://localhost:3000 to see the response from server

nodemon app.js

Output:

{ message: "Hi I am Server", data: "no data on this endpoint" }

You should see similar output on your browser on visiting http://localhost:3000

​

In a nutshell, if you want to learn how to build APIs with Node.Js, you have come to the right place.

What you will need to install

• You will need Node v10.0.0+
• You will need to install PostMan

What you need to Know

If you are new to the Nodejs world you can follow up the below Tutorials to get more from this tutorial series, and if you have basic knowledge of Nodejs, Express JS and Mongoose then you can skip this.

NodeJs tutorial for beginners

Learn Express Framework by building an application.

Learn how to use Mongoose with Nodejs and Express

Now you can grab a mug of coffee and let's get our hands dirty.

Lets understand some Terms:

What is ExpressJs?

ExpressJs simply put, it's a web framework for Node.Js - stolen from the official docs. Taylor Otwell (Laravel's creator) once said, "Developers build tools for developers". ExpressJs was built for developers to simplify Node APIs.

What is MongoDB?

MongoDB is a NoSQL database. It's completely document-oriented. A NoSQL database allows you to store data in the form of JSON and any formats. If you want to learn more about MongoDB, visit the official documentation here

Now Let's start by defining our API routes.

Defining Todo APIs Routes

I like to begin by defining my APIs. As it is very important for a developer to first think of how the API endpoints are going to look like and what they do, also they should be easy to remember and easy to use. The table below shows what APIs we need to create and what each does.

Having defined our APIs, let's delve into setting up the Express App and the project directories.

If you are a person who understands concepts better through videos, then you can Watch My Hands-On Workshop on Building A TODO REST API BAckend which we are discussing in this tutorial series.

In this article, we will learn how we can use MongoDB database in Node JS using Mogoose library, which is a very popular library widely used in the Industries.

In this article we had used the MongoDB Cloud service called MongoDB Atlas, you can also use the MongoDB server running locally, the process remains the same.

What is Mongoose?

Mongoose is an Object Data Modeling (ODM) library for MongoDB and Node.js. It manages relationships between data, provides schema validation, and is used to translate between objects in code and the representation of those objects in MongoDB.

MongoDb VS SQL

MongoDB is a schema-less NoSQL document database. It means you can store JSON documents in it, and the structure of these documents can vary as it is not enforced like SQL databases. This is one of the advantages of using NoSQL as it speeds up application development and reduces the complexity of deployments.

Below is an example of how data is stored in Mongo vs. SQL Database:

Mongoose has great documentation, checkout the docs here to learn more about Mongoose.

Mongoose Terminologies

Collections

'Collections' in Mongo are equivalent to tables in relational databases. They can hold multiple JSON documents.

Documents

'Documents' are equivalent to records or rows of data in SQL. While a SQL row can reference data in other tables, Mongo documents usually combine that in a document.

Fields

'Fields' or attributes are similar to columns in a SQL table.

Schema

While Mongo is schema-less, SQL defines a schema via the table definition. A Mongoose 'schema' is a document data structure (or shape of the document) that is enforced via the application layer.

Models

'Models' are higher-order constructors that take a schema and create an instance of a document equivalent to records in a relational database.

​Mongoose In Action

Referencing

So now, we will see a subtle difference between Mongoose Schema and Model, after that we will start working with mongoose and we will proceed further step by step explain each concept.

Mongoose Schema vs. Model

A Mongoose model is a wrapper on the Mongoose schema. A Mongoose schema defines the structure of the document, default values, validators, etc., whereas a Mongoose model provides an interface to the database for creating, querying, updating, deleting records, etc.

Don't Jump for coding right now, have some patience and for now just read the sections, in further section we will create and setup the project step by step : )

Creating a Mongoose model comprises primarily of three parts:

1. Referencing Mongoose
2. Defining the Schema
3. Exporting a Model

1. Referencing Mongoose

const mongoose = require('mongoose')

This reference will be the same as the one that was returned when we connected to the database, which means the schema and model definitions will not need to explicitly connect to the database, we will see database connection in the further section.

now, lets create a reference to Schema class from mongoose:

const Schema = mongoose.Schema;

Now let's move on to create our very own Schema.

2. Defining the Schema

const todoSchema = new Schema(
  {
    description: {
      type: String,
      required: true,
    },
  },
);

So here we have created an instance of Schema and named it todoSchema. The Schema takes object as a parameter, so we had passed an object and inside that we have a key called description and its value is again an object in which we had specified we need a field description of type "String", this type is in-built with mongoose you can refer more on official docs and also it is a required field so we had defined this with the key required and with a boolean value of true.

Lets add more field into the schema,

const todoSchema = new Schema(
  {
    description: {
      type: String,
      required: true,
    },
    completed: {
      type: Boolean,
      default: false,
    },
  },
  {
    timestamps: true,
  }
);

So similarly we had define a field called completed and it is of type Boolean and it hold a default value false.

And if you carefully looked at the structure we had passed a second parameter which is an object with a key timestamps so this second parameter is a configuration object in which we had only used an inbuilt feature of mongoose which adds to additional fields to every documents namely createdAt and updatedAt.

The following Schema Types are permitted:

• Array
• Boolean
• Buffer
• Date
• Mixed (A generic / flexible data type)
• Number
• ObjectId
• String

3. Exporting a Model

Finally, let's create the model using the Schema we had created and Export the model to use it in other modules where we need to interact with the database.

​We need to call the model constructor on the Mongoose instance and pass it the name of the collection and a reference to the schema definition.

var Todos = mongoose.model("Todo", todoSchema);

And now finally let's export this model so that we can use this model throughout the project.

module.exports = Todos;

Now, we understand how we can define a schema and using schema how we can make our model. So this was the major part of the Mongoose model creation and now we have to make use of this model.

Next, we will see how to setup the project and start writing some code.

Creating an Application

​So let's create a project folder node-mongoose and inside your project folder create a folder called models and inside that create a file called todos.js and paste below code into it and your todos.js model file should look like this:

// models/todos.js

const mongoose = require("mongoose");
const Schema = mongoose.Schema;

const todoSchema = new Schema(
  {
    description: {
      type: String,
      required: [true, "please enter task details"],
    },
    completed: {
      type: Boolean,
      default: false,
    },
  },
  {
    timestamps: true,
  }
);

var Todos = mongoose.model("Todo", todoSchema);

module.exports = Todos;

Previously we had implemented this model, if you haven't followed that checkout the Referencing Mongoose Section above, then you are good to continue this section.

Folder Structure:

node-mongoose
  - models
     - todos.js

Now, open a terminal in node-mongoose i.e root folder of your project and follow below steps:-

1. npm init -y
2. Create a file called app.js
3. Install express using npm install express
4. Install mongoose using npm install mongoose
5. Install dotenv using npm install dotenv
6. Create a file called app.js in root folder of your project
7. Now follow the steps in this blog and get the database url which will look like this : mongodb+srv://sample_user:<password>@my-sample-cluster-b3ugy.mongodb.net/<dbname>?retryWrites=true&w=majority
8. Create a .env file in the root folder
9. Add this line in the .env file with your password and database name DATABASE_URL=mongodb+srv://sample_user:<password>@my-sample-cluster-b3ugy.mongodb.net/<dbname>?retryWrites=true&w=majority
10. Also to ensure your database connection should not visible to other if you are storing your code on a service like Github. Create a .gitignore file and enter the file name .env inside it. So git will not keep track of this file.
11. Also add one more variable on new line inside .env file called PORT=3000

Your .env file should look like:

DATABASE_URL=mongodb+srv://sample_user:<password>@my-sample-cluster-b3ugy.mongodb.net/<dbname>?retryWrites=true&w=majority
PORT=3000

Your .gitignore file should look like

node_modules
.env

Now, lets import the packages we have install into the app.js file

const express = require("express");
const mongoose = require("mongoose");
const dotenv = require("dotenv");

Now, lets load the environment variable

dotenv.config({ path: ".env" });
const PORT = process.env.PORT;
const dbURI = process.env.DATABASE_URL;

Now lets import the model todos we have created inside the models/ folder

//model
const Tasks = require("./models/todos");

now , lets create a database connection:

const connect = mongoose.connect(dbURI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

connect.then(
  (db) => {
    console.log("Connected Successfully to Mongodb Server");

  },
  (err) => {
    console.log(err);
  }
);

Lets initialize the express app:

const app = express();

Lets add a middleware which converts the request body into json:

app.use(express.json());

Finally lets create a listener to accept incoming HTTP request on specific port:

app.listen(PORT, () => {
  console.log(`Server is running at http://localhost:${PORT}`);
});

Your Final app.js should look like this:

const express = require("express");
const mongoose = require("mongoose");
const dotenv = require("dotenv");

dotenv.config({ path: ".env" });
const PORT = process.env.PORT;
const dbURI = process.env.DATABASE_URL;

//model
const Tasks = require("./models/todos");

const connect = mongoose.connect(dbURI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

connect.then(
  (db) => {
    console.log("Connected Successfully to Mongodb Server");

  },
  (err) => {
    console.log(err);
  }
);

const app = express();

app.use(express.json());

app.listen(PORT, () => {
  console.log(`Server is running at http://localhost:${PORT}`);
});

Now we are good to go with basic CRUD operations.

Mongoose CRUD Operations

Mongoose has a flexible API and provides many ways to accomplish a task. We will not focus on the variations because that is out of scope for this article, but remember that most of the operations can be done in more than one way either syntactically or via the application architecture.

Create Record

Let's create a todo and save into our database:

let newTask = {
      description: "task added using create",
};

Tasks.create(newTask)
  .then((data) => {
      console.log(data);
   })
   .catch((err) => {
      console.log(err);
});

Firstly we had created a newTask object with description of a todo which is a mandatory field required to create a document in the database. Mongoose model has a create() method which is a promise and on successful we get the response in data and in-case of failure it is catched and error is displayed.

Find All Tasks

To get all the documents stored inside a collection.

//all tasks

Tasks.find({})
   .then((data) => {
       console.log("All tasks", data);
    })
    .catch((err) => {
       console.log(err);
 });

Find A Single Document or Record

Let's see how we can find a single document from the collection.

 //find with condition

  Tasks.find({ completed: false })
    .then((data) => {
         console.log("All tasks", data);
     })
     .catch((err) => {
         console.log(err);
    });

Update a Document

Let's modify the record by updating the status completed:false to completed:true

    Tasks.findByIdAndUpdate({ _id: req.params.id },{
            $set: {completed:true},
          },
          { new: true, useFindAndModify: false } //get updated result
       )
       .then((data) => {
         console.log("Updated todo data", data);
       })
       .catch((err) => {
         console.log(err);
       });

Delete a document from the collection

 //delete all tasks
     Tasks.remove({});

// delete specific task

    Tasks.findByIdAndRemove(task_id)
       .then((data) => {
         console.log("All tasks", data);
       })
       .catch((err) => {
         console.log(err);
       });

In the above example replace the task_id with the value of _id of a task in mongoDB databse which looks like 5a78fe3e2f44ba8f85a2409a

So we have seen all the CRUD operations namely, create, read, update, delete

Let's use them in our app.js file.

const express = require("express");
const mongoose = require("mongoose");
const dotenv = require("dotenv");

dotenv.config({ path: ".env" });
const PORT = process.env.PORT;
const dbURI = process.env.DATABASE_URL;

//model
const Tasks = require("./models/todos");

const connect = mongoose.connect(dbURI, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
});

connect.then(
  (db) => {
    console.log("Connected Successfully to Mongodb Server");

    //all tasks
    Tasks.find({})
      .then((data) => {
        console.log("All tasks", data);
      })
      .catch((err) => {
        console.log(err);
      });

    // similary use all the other operation here

    // CAUTION: don't put all the operation together, use one operation
    // at a time
  },
  (err) => {
    console.log(err);
  }
);

const app = express();

app.use(express.json());

app.listen(PORT, () => {
  console.log(`Server is running at http://localhost:${PORT}`);
});

Now, run your server by using the following command:

first install,

npm install -g nodemon

then,

nodemon app.js

Congratulations !! We had learned the fundamentals of Mongoose and How we can use it in Node JS.

I hope this article helped you to understand the core idea : ) Do give a like to this article to motivate me to write more : D ​

Welcome to this blog post in this blog we will learn how to build a Simple Hello World Express Application using Node JS, previously in this series here we learn the fundamentals of Node JS, So if you are not familiar with Node JS and new to it then kindly check out the series to proceed further.

Later on, we will build a Full Fledge Express Backend using the tech stack Node JS, MongoDB, and Express. So stay tuned and follow along with me : )

You can Watch My Hands-On Workshop on Building A TODO REST API BAckend

So let's Get Started!!

What is Express?

Express is the most popular Node web framework, and is the underlying library for a number of other popular Node web frameworks. It provides mechanisms to:

• Write handlers for requests with different HTTP verbs at different URL paths (routes).
• Integrate with view rendering engines in order to generate responses by inserting data into templates.
• Set common web application settings like the port to use for connecting, and the location of templates that are used for rendering the response.
• Add additional request processing middleware at any point within the request handling pipeline.

While Express itself is fairly minimalist, developers have created compatible middleware packages to address almost any web development problem. There are libraries to work with cookies, sessions, user logins, URL parameters, POST data, security headers, and many more.

You can find a list of middleware packages maintained by the Express team at Express Middleware (along with a list of some popular 3rd party packages).

Now before proceeding to build the Express App let's understand the concept of API and REST APIs.

What is an API?

API is the acronym for Application Programming Interface, which is a software intermediary that allows two applications to talk to each other.

To explain this better, let us take a familiar example.

Imagine you're sitting at a table in a restaurant with a menu of choices to order from. The kitchen is the part of the system that will prepare your order. What is missing is the critical link to communicate your order to the kitchen and deliver your food back to your table. That's where the waiter or API comes in. The waiter is the messenger -- or API -- that takes your request or order and tells the kitchen -- the system -- what to do. Then the waiter delivers the response back to you; in this case, it is the food.

Technically:

When you use an application on your mobile phone, the application connects to the Internet and sends data to a server. The server then retrieves that data, interprets it, performs the necessary actions, and sends it back to your phone. The application then interprets that data and presents you with the information you wanted in a readable way. This is what an API is - all of this happens via API.

What is Rest API?

Let's say you're trying to find videos about Batman on Youtube. You open up Youtube, type "Batman" into a search field, hit enter, and you see a list of videos about Batman. A REST API works in a similar way. You search for something, and you get a list of results back from the service you're requesting from.

An API is an application programming interface. It is a set of rules that allow programs to talk to each other. The developer creates the API on the server and allows the client to talk to it.

REST determines how the API looks like. It stands for "Representational State Transfer". It is a set of rules that developers follow when they create their API. One of these rules states that you should be able to get a piece of data (called a resource) when you link to a specific URL.

Each URL is called a request while the data sent back to you is called a response.

The Anatomy Of A Request

It's important to know that a request is made up of four things:

• The endpoint
• The method
• The headers
• The data (or body)

The endpoint (or route) is the url you request for. It follows this structure:

 root-endpoint/?

The root-endpoint is the starting point of the API you're requesting from. The root-endpoint of Github's API is https://api.github.com while the root-endpoint Twitter's API is https://api.twitter.com, and Hashnode's root-endpoint API is https://api.hashnode.com/

The path determines the resource you're requesting for. Think of it like an automatic answering machine that asks you to press 1 for a service, press 2 for another service, 3 for yet another service and so on.

The Method

The method is the type of request you send to the server. You can choose from these five types below:

• GET
• POST
• PUT
• PATCH
• DELETE

These methods provide meaning for the request you're making. They are used to perform four possible actions: Create, Read, Update and Delete (CRUD).

The Purpose of APIs and REST APIs

When We talk about API and REST APIs we are talking about the DATA and NOT about the HTML pages from the Server.

• Server generally serves you or returns you the HTML (UI- Look Of the Webpage) and your browser knows how to render the HTML onto the screen.

• But you can also allow your server to send only DATA - no HTML. The Data sent is in the form of JSON or either XML.

• With Modern Web architectures like JAMstack we are separating the Data and the UI.

• So we have the data on the servers like Django, Express JS, Spring, etc. Which exposes API Endpoints to Access the Data. These are commonly known as Backend Servers

• And we use Frontend frameworks and libraries like REACT, VUE, Plain Javascript, and Angular to create the UI by using the API Endpoints made available to us by backend server to Fetch the Data and create the HTML Markup so that your Browser can renders the HTML onto the screen as your browser only understand HTML (Structure the webpage), CSS (beautify's your webpage) and Javascript (to program the behavior of web pages)

• These allows no dependencies on creating the UI and you can use the data the way you want to and you can scale your system easily.

• These gave rise to the CMS (Content Management System), Large Distributed Web Applications systems, Microservices architecture, etc.

Routes vs Endpoints

Endpoints are functions available through the API. This can be things like retrieving the posts, updating a post, or deleting a comment. Endpoints perform a specific function, taking some number of parameters and returning data to the client.

A route is the “name” you use to access endpoints, used in the URL. A route can have multiple endpoints associated with it, and which is used depends on the HTTP verb.

For example, with the URL https://www.teachmebro.com/post/javascript-asynchronous-programming-and-callbacks:

The “route” is post/javascript-asynchronous-programming-and-callbacks – The route doesn’t include domain name because domain name is the base path for the API itself.

Routes

Routes in the REST API are represented by URIs. The route itself is what is tacked onto the end of https://ourawesomesite.com/wp-json. The index route for the API is '/' which is why https://ourawesomesite.com/wp-json/ returns all of the available information for the API. All routes should be built onto this route, the wp-json portion can be changed, but in general, it is advised to keep it the same.

We want to make sure that our routes are unique. For instance we could have a route for books like this: /books. Our books route would now live at https://ourawesomesite.com/wp-json/books. However, this is not a good practice as we would end up polluting potential routes for the API. What if another plugin we wanted to register a books route as well? We would be in big trouble in that case, as the two routes would conflict with each other and only one could be used.

Building The Express Application

Let's learn how to start developing and using the Express Library. To start with, you should have the Node and the npm (node package manager) installed. If you don't already have these, go to the Node setup to install the node on your local system. Confirm that node and npm are installed by running the following commands in your terminal.

node --version

npm --version

You should get an output similar to the following.

v5.0.0

3.5.2

Now that we have Node and npm setup lets start,

Whenever we create a project using npm, we need to provide a package.json file, which has all the details about our project. npm makes it easy for us to set up this file. Let us set up our development project.

Step 1 - Start your terminal/cmd, create a new folder named hello-world and cd (create directory) into it -

Step 2 - Now to create the package.json file using npm, use the following code.

npm init -y

Step 3 - Now we have our package.json file set up, we will further install Express. To install Express and add it to our package.json file, use the following command -

npm install --save express

Tip - The --save flag can be replaced by the -S flag. This flag ensures that Express is added as a dependency to our package.json file. This has an advantage, the next time we need to install all the dependencies of our project we can just run the command npm install and it will find the dependencies in this file and install them for us.

This is all we need to start development using the Express Library. To make our development process a lot easier, we will install a tool from npm, nodemon. This tool restarts our server as soon as we make a change in any of our files, otherwise we need to restart the server manually after each file modification. To install nodemon, use the following command -

npm install -g nodemon

We have set up the development, now it is time to start developing our first app using Express. Create a new file called app.js and type the following in it.

// import module
var express = require('express');

// initialize express app
var app = express();

// accept request and send a response
app.get('/', function(req, res){

   res.send("Hello world from server!");

});

// listen on PORT 3000 for incoming HTTP request
app.listen(3000);

Save the file, go to your terminal and type the following.

nodemon app.js

This will start the server. To test this app, open your browser and go to http://localhost:3000 and a message will be displayed as in the following demo.

Hurrayy!! We learned the fundamentals of APIs and learned how to use the Express Library in Node JS to build the Backend Application.

If you learned something new from this article then do like this article to make me feel good and to motivate me to write more : D : D

In NodeJS, every JS file is a module.

Consider modules to be the same as JavaScript libraries. A set of functions, variables, you want to include in other JS files (modules) of your application.

Built-in Modules

Node.js has a set of built-in modules which you can use without any further installation.

Include Modules

To include a module, use the require() function with the name of the module:

var http = require('http');

Now your application has access to the HTTP module, and is able to create a server:

http.createServer(function (req, res) {

  res.writeHead(200, {'Content-Type': 'text/html'});

  res.end('Hello World!');

}).listen(3000);

Create Your Own Modules

You can create your own modules, and easily include them in your applications.

The following example creates a module that returns a date and time object:

exports.myDateTime = function () {

  return Date();

};

Use the exports keyword to make properties and methods available outside the module file.

Save the code above in a file called "myfirstmodule.js"

Include Your Own Module

Now you can include and use the module in any of your Node.js files.

var http = require('http');

var dt = require('./myfirstmodule');

http.createServer(function (req, res) {

  res.writeHead(200, {'Content-Type': 'text/html'});

  res.write("The date and time are currently: " + dt.myDateTime());

  res.end();

}).listen(3000);

Notice that we use ./ to locate the module, that means that the module is located in the same folder as the Node.js file, if you want to go one folder up use ../

Save the code above in a file called "demo_module.js", and run the file:

node demo_module.js

If you have followed the same steps on your computer, you will see the same result as the example: http://localhost:3000

So In this section, We saw types of Modules in Javascript and how to use them in different situations.

• Online repositories for node.js packages/modules which are searchable on search.nodejs.org
• Command line utility to install Node.js packages, do version management and dependency management of Node.js packages.

NPM comes bundled with Node.js installables after v0.6.3 version. To verify the same, open console and type the following command and see the result -

npm --version

Installing Modules using NPM

// syntax
npm install <Module Name>

For example, following is the command to install a famous Node.js web framework module called express -

npm install express

Global vs Local Installation

By default, NPM installs any dependency in the local mode. Here local mode refers to the package installation in node_modules directory lying in the folder where Node application is present. Locally deployed packages are accessible via require() method.

Now let's try installing the express module using local installation.

npm install express

Globally installed packages/dependencies are stored in system directory. Such dependencies can be used in CLI (Command Line Interface) function of any node.js but cannot be imported using require() in Node application directly. Now let's try installing the express module using global installation.

npm install express -g

Using package.json

package.json is present in the root directory of any Node application/module and is used to define the information of the current project and it contains list of dependencies present in your project.

As node_modules/ folder contains packages and is not a part of code base so we don't share this folder along with the source code but this folder can be regenerate using package.json by using below command in the root directory of the project

npm install

OR

npm i

In this section, we saw the learn about Node JS package manager and its Usage

node script.js

If we omit the filename, we use it in REPL (Read Evaluate Print Loop) mode:

node

Note: REPL also known as Read Evaluate Print Loop is a programming language environment(Basically a console window) that takes single expression as user input and returns the result back to the console after execution.

If you try it now in your terminal, this is what happens:

❯ node

>

the command stays in idle mode and waits for us to enter something.

Tip: if you are unsure how to open your terminal, google "How to open terminal on ".

The REPL is waiting for us to enter some JavaScript code, to be more precise.

Start simple and enter

> console.log('test')

test

undefined

>

The first value, test, is the output we told the console to print, then we get undefined which is the return value of running console.log().

We can now enter a new line of JavaScript.

REPL Commands

• ctrl + c - terminate the current command.
• ctrl + c twice - terminate the Node REPL.
• ctrl + d - terminate the Node REPL.
• Up/Down Keys - see command history and modify previous commands.
• tab Keys - list of current commands.
• .help - list of all commands.
• .break - exit from multiline expression.
• .clear - exit from multiline expression.
• .save filename - save the current Node REPL session to a file.
• .load filename - load file content in current Node REPL session.

So in this section, we saw the usage of Node REPL to execute Javascript code.

​

• Both the browser and Node.js use JavaScript as their programming language.
• Building apps that run in the browser is a completely different thing than building a Node.js application.
• Despite the fact that it's always JavaScript, there are some key differences that make the experience radically different.

From the perspective of a frontend developer who extensively uses JavaScript, Node.js apps bring with them a huge advantage: the comfort of programming everything - the frontend and the backend- in a single language.

Javascript - the comfort of programming everything - the frontend and the backend - in a single language.

You have a huge opportunity because we know how hard it is to fully, deeply learn a programming language, and by using the same language to perform all your work on the web - both on the client and on the server, you're in a unique position of advantage.

What changes in the ecosystem.

In the browser, most of the time what you are doing is interacting with the DOM (Document Object Model), or other Web Platform APIs like Cookies. Those do not exist in Node.js, of course. You don't have the document, window and all the other objects that are provided by the browser.

And in the browser, we don't have all the nice APIs that Node.js provides through its modules, like the filesystem access functionality.

Another big difference is that in Node.js you control the environment. Unless you are building an open source application that anyone can deploy anywhere, you know which version of Node.js you will run the application on. Compared to the browser environment, where you don't get the luxury to choose what browser your visitors will use, this is very convenient.

This means that you can write all the modern ES6-7-8-9 JavaScript that your Node.js version supports.

Since JavaScript moves so fast, but browsers can be a bit slow and users a bit slow to upgrade, sometimes on the web, you are stuck with using older JavaScript / ECMAScript releases.

You can use Babel to transform your code to be ES5-compatible before shipping it to the browser, but in Node.js, you won't need that.

Another difference is that Node.js uses the CommonJS module system, while in the browser we are starting to see the ES Modules standard being implemented.

In practice, this means that for the time being you use require() in Node.js and import in the browser.

So In this section, we saw some major differences between the Javascript running on Browser and Javascript Running on Server Side.

Before creating an actual "Hello, World!" application using Node.js, let us see the components of a Node.js application. A Node.js application consists of the following three important components -

• Import required modules - We use the require directive to load Node.js modules.
• Create server - A server which will listen to client's requests similar to Apache HTTP Server.
• Read request and return response - The server created in an earlier step will read the HTTP request made by the client which can be a browser or a console and return the response.

Creating Node.js Application

Create an app.js file and add the below code in it:

Step 1 - Import Required Module

We use the require directive to load the httpmodule and store the returned HTTP instance into an http variable as follows -

const http = require("http");

Step 2 - Define Port

We define our port application port on 3000. It basically means our app will be available on port 3000 and if we visit http://localhost:3000 we can access our app.

const port = 3000;

Step 3 - Create Server

const server = http.createServer((req, res) => {

 res.statusCode = 200;

 res.setHeader("Content-Type", "text/plain");

 res.end("Hello World!\n");

});

The createServer() method of http creates a new HTTP server and returns it. The server is set to listen on the specified port. When the server is ready, the callback function is called, in this case informing us that the server is running.

Whenever a new request is received, the request event is called, providing two objects: a request (an http.IncomingMessage object) and a response (an http.ServerResponse object).

Those 2 objects are essential to handle the `HTTP call.

The first provides the request details. In this simple example, this is not used, but you could access the request headers and request data.

The second is used to return data to the caller.

In this case with:

res.statusCode = 200

we set the statusCode property to 200, to indicate a successful response.

Now, we set the Content-Type header:

res.setHeader('Content-Type', 'text/plain')

and we close the response, adding the content as an argument to end():

res.end('Hello World\n')

Step 4: Listen

server.listen(port, () => {

 console.log(`Server running on http://localhost:${port}/`);

});

listen()helps the server to listens for incoming traffic at port 3000 i.e. it waits for a request over 3000 port on the local machine and if any request arrives the server will handle/respond to that request.

Whole code in app.js will look like this:

// app.js

// import http module
const http = require("http");

// define port
const port = 3000;

// create server
const server = http.createServer((req, res) => {

 res.statusCode = 200;

 res.setHeader("Content-Type", "text/plain");

 res.end("Hello World!\n");

});

// listen on defined PORT
server.listen(port, () => {

 console.log(`Server running on http://localhost:${port}/`);

});

Now execute the app.js to start the server as follows -

node app.js

Open http://localhost:3000/ in any browser and observe the following result.

Live Code Example:

Node.js is available on Ubuntu. So all you need to do is to open a terminal and use the following command:

sudo apt install nodejs

To install npm, use the following command:

sudo apt install npm

I recommend installing npm as well because you're going to need it anyway. Both Node.js and npm are quite small.

Install development tools

To be able to compile and install native add-ons from npm you need to install the development tools. The following command will install all the necessary packages including the GCC compilers :

sudo apt install build-essential

Open a new terminal (you may need restart) and type the below command to verify the installation:

node -v

The console should respond with a version string. Repeat the process for npm:

npm -v

If both commands work, your installation was a success, and you can start using Node.js!

Uninstall NodeJS

If for some reasons you want to uninstall Node.js and npm packages, you can use the following command:

sudo apt remove nodejs npm

Congratulations!! We had successfully installed the Nodejs On Ubuntu : D

Node.js is a run-time environment which includes everything you need to execute a program written in JavaScript. It's used for running scripts on the server to render content before it is delivered to a web browser.

NPM stands for Node Package Manager, which is an application and repository for developing and sharing JavaScript code.

The first steps in using Node.js is the installation of the Node.js libraries on the client system. To perform the installation of Node.js, perform the below steps;

Step 1) Go to the site https://nodejs.org/en/download/ and download the necessary binary files. In our example, we are going to download the 64-bit setup files for Node.js.

At the time this article was written, version 14.15.0-x64 was the latest version. The Node.js installer includes the NPM package manager.

Step 2) Double click on the downloaded .msi file to start the installation. Click the Run button on the first screen to begin the installation.

Step 3) In the next screen, click the "Next" button to continue with the installation

Step 4) In the next screen, Accept the license agreement and click on the Next button.

Step 5) In the next screen, choose the location where Node.js needs to be installed and then click on the Next button. Keep the default location and Click on the Next button to proceed ahead with the installation.

Step 6) Accept the default components and click on the Next button.

Step 7) In the next screen, click the Install button to start the installation.

Step 8) Click the Finish button to complete the installation.

node -v

The console should respond with a version string. Repeat the process for npm:

npm -v

If both commands work, your installation was a success, and you can start using Node.js!