DEV Community: Lavish Goyal

6 Reasons why student developers don't grow

Lavish Goyal — Mon, 10 Oct 2022 12:27:57 +0000

Everyone has experienced failure at some point in their lives. But what happens when this is the first experience you’ve had as a developer? Situations like these can often cause people to become fearful of taking risks, and it could lead to feelings of self-doubt especially when you are a high school/college/school student. Developing software involves making countless decisions every day. It’s important that these decisions are made thoughtfully and with the best intentions possible. With numerous things happening in your student life and you juggling around with decisions to make it becomes increasingly difficult to sometimes focus on efficiency and upskilling. If you don’t take the time to understand why things happen, or how other developers have dealt with similar situations, then you run a high risk of failing when things go wrong again and again. In this blog post, we will address some common pitfalls that new developers face, and how to avoid them if possible.

Bad habits

When you’re a beginner, you must be careful not to develop bad habits. Bad habits can be hard to spot when you’re just starting out, but they can cause a lot of problems later on as you progress. Here are some bad habits that new developers tend to fall into:

You don’t meet your deadlines - If you’ve never completed a project before, chances are you don’t know what it takes to finish a software project on time. This is especially true when you’re a beginner and you don’t have the experience or knowledge to help guide the way. When you don’t meet deadlines, it can cause unnecessary stress and anxiety. What usually happens with college projects is that the deadlines get extended and you work your a** off in the last couple of days to get it completed because you know it needs to be done, but, in the case of your side project, you don't have any kind of compulsion and your mind tends to leave it when you face some problem or you aren't able to meet a specific deadline.
You don’t collaborate - Do you know anything about this? Competition is bad; cooperation is better. This is definitely the case. Upskilling is a tremendously difficult task. Because it implies that you must upskill a skill after you learn or acquire it. You must improve it and use your talents to accomplish many more things much more effectively, but as a student, you frequently have a tendency to keep things to yourself and dislike disclosing or making public what you are learning. I get it. Don't, however, try to handle everything on your own. If your brilliant project concept incorporates elements of machine learning, the front-end, and other components, market your idea to invite like-minded people with similar types of zeal. Five people at a beginner level with their respective skills can do much better and benefit individually than you alone working on five different technologies which you don't have any idea about. Also, it saves you time.
You don’t work with a mentor - There are a few benefits to working with a mentor, both in the short and long term. Working with a mentor can help you develop good habits, resolve issues with your project, and learn how to work with other people on a team effectively. Working with a mentor is also beneficial when you want to start your own business because you can learn from their mistakes and apply what you’ve learned to your own business. Working with a mentor can greatly increase your chances of success. As a student you have a great opportunity to interact with your seniors and you know they are in front of you and you can legitimately check whether what they have achieved is real or not! But definitely connecting with mentors all over the world is made possible by following the practice of Learning In Public and efficient use of social media.

Lack of code review

Lack of code review is a common mistake that new developers make. It’s important to have a process for code review. What does code review really mean? Now, you learn from some blog posts or some video tutorials and then you write some code. But how do you know if what you have written is the best way to write it, until and unless you have exactly copy pasted from the video or blog post? For example, You write a program for fetching data from MongoDB and process that data to sort it in increasing order and send it to the front-end. Have you ever wondered how some other developer would have written that same program? or How can you optimise the code to send the data much more quickly or sort the data much more effectively?

That is a problem students often face and they don't even know that it is a problem. You keep writing code without knowing if it is the best way or not. It affects you in the long run when you have to work on bigger projects and you struggle with finding consistency in your codebase and optimising your program's performance.

It has a simple solution, explore the web to do things you already did in a different way. Definitely not the most basic things which are just easy or boilerplate but things which you actually think that you've done for the first time or have written completely by yourself. In your free time trying to explore articles and projects where you can find similar functionality so you can actually learn that "Oh! there's an even better way to fetch data from MongoDB!" or maybe your reaction can be like: "Damn! I didn't know Internationalization API functionality was built into JavaScript, I was wasting my time implementing it from scratch"
I have faced it a lot and trust me exploring what you did on the internet improves you more than practising your skill. And also an added advantage with this process is if you don't find something like what you did which means it may be a unique work you can market yourself with a good blog/article and tell the community and get suggestions!

You think you know everything

New developers often assume they know everything once they complete a BootCamp or a video tutorial. This is especially true in the beginning when you don’t have a lot of experience under your belt. As you continue to work as a developer, you’ll encounter situations that you haven’t dealt with before. This can cause you to panic, which will make it much harder to solve the problem at hand. If you find yourself thinking you know everything, try to remember that you don’t. Try to be open-minded, and accept that you might not know everything. You can also try to identify what areas of expertise you do have, and use those skills to problem-solve.

No reward system

Many companies use a reward system to motivate their employees. You must have heard about things like team lunches, free pizza Fridays, and other activities that provide a sense of community and reward. Similarly, as a student being rewarded for your efforts will help to keep you motivated, especially when things get hard. Working day and night is tough. You have to make notes in class, study for examinations, spend time chilling with your friends make memories and you have to code. You get yourself hassled to manage all these things and tend to leave one or two things completely, which is not good! You definitely need to spend time coding if you want to upskill but the human mind works effectively only when you reward yourself for your hard work. Sometimes for a completed project or a problem, you were stuck for some time, or maybe a break or a refreshment when you are stuck on a project and not able to find the solution.

Unrealistic deadlines

As a student, you often sometimes assume that, hey before the end of this semester I will learn these 4 different technologies and create a humongous life-changing product in the holidays! RELAX! You'll only end up learning 4 new technologies in a way that you can only write "Hello World" in them. Seriously, I've seen my friends setting completely unrealistic deadlines, completing or practising 3 different Udemy Courses at the same time aiming to achieve mastery in three different languages at the same time that too in one month. That is not how things work. If you want to really grasp something, really understand it and create something with it, you need to give it time!

You need to get stuck in it, spend time solving a problem, spend time thinking about why it is happening like this, explore various solutions etc. Until and unless you don't do this, you won't excel at your preferred skillset. Once you start putting time into one specific thing, you'll automatically learn next time how to optimise your time and how to divide your time into learning different things and you'll learn more efficiently at a much fast pace. So, take a chill pill! Be relaxed, set a realistic deadline, achieve it and get comfortable. Then gradually keep on increasing your deadline difficulties!

Not asking for help or taking advantage of opportunities

As you continue to work as a developer, you’ll encounter situations that you haven’t dealt with before. This can cause you to panic, which will make it much harder to solve the problem at hand. If you find yourself needing help, or want to take advantage of an opportunity, try to remember that everyone has a learning curve. New developers often assume that other people are more experienced than them, or that they know everything. This is especially true in the beginning when you don’t have a lot of experience under your belt.

There is no shame in asking for help, in admitting that you don't know it but still you wanna do it!

I will tell you an honest story when I grabbed the first internship I had no idea how to write a NodeJS Server Side application by myself. Every time I had to write a Server Side code I had to open some tutorial and start copying it. But still, I cracked the internship because things I didn't lack were:

My confidence that I have done this thing and this is how it works!
My habit of always keep searching and asking for help (in my developer journey) if I am not able to do it myself, like asking for help from Google/Senior Developers
My zeal to take the opportunity at hand and learn something from it!

I cracked the internship and worked hard to learn things and followed all the steps I told you above, read, research, asked for help, asked for guidance and most importantly never gave up on the opportunity I have received! I would have been completely fine if I would have lost that opportunity by not working efficiently but I would've at least learnt so many things.

So, just don't panic if you aren't highly skilled. There are lots and lots of communities which are really welcoming where you can put up your queries and ask for guidance and there are a lot of opportunities on your way which may not seem achievable at first but once you determine that you have that zeal to accomplish them, you can do wonders!

Conclusion

Developing software is challenging and difficult, but it can also be extremely rewarding. Becoming a developer requires a unique set of skills and knowledge that can take some time to develop. However, with the right mindset, initiative, and willingness to learn, anyone can become a successful developer. As you can see, there are many reasons why developers fail. The best way to prevent failure is to be prepared for failure. This means that you need to identify the areas where you need improvement and work towards improving them.

Be happy and be rewarding for yourself, that is the key :)

You can definitely connect with me over LinkedIn or Twitter for any queries or guidance or support you would want. I would definitely love to help you <3

My gadgets

Laptop (Macbook Air 2020 M1)

Keyboard and Mouse: https://amzn.to/3eTvFTP

External Display Monitor: https://amzn.to/3doZI5z

External SSD: https://amzn.to/3BrrSoD

USB Hub for Macbook Air: https://amzn.to/3ScC3E1

Headphones: https://amzn.to/3qR5yzP

Laptop Sleeve: https://amzn.to/3R7MkAz

(some of the above are affiliate links ie if you purchase any item using the links above I'll get a very small percentage of it and you'll get the product at the same price)

How to start Web Development?

Lavish Goyal — Sun, 09 Oct 2022 10:25:31 +0000

Hi, I am Lavish Goyal and this is my first Hashnode Blog. Basically, I'm starting my blogging journey through this particular blog and what's better than helping you start your journey as a web developer.

Web Development as we see it today is a very popular choice for both full-time jobs and freelancing. I have been doing freelancing for the past year and I have learned a few of the technologies from the large pool of existing technologies used for web development. So let's get you started on your journey to develop crazy web applications.

What is web development?

You are viewing this article on a web page and the development of these web pages is called web development.

How do websites work?

Websites are nothing but files stored on a computer located somewhere else, generally called a server. Every time you visit a website some files are requested and downloaded by the browser which loads up on your computer and you see that particular website.

Division of tasks in Web Development

Front-end
Back-end
DevOps

DevOps

It refers to development operations. Basically, when you are writing the code for a website you need to test it and deploy it so everyone around the globe can use it and you need to maintain versions of the website as you keep changing and upgrading it over time.

Let's get started with learning paths

Frontend

Take a good look at the roadmap and don't worry if it is overwhelming at first, because I am going to make a shorter and easier path for you.

As the name suggests front-end refers to everything the user sees, basically the content, images, graphics etc on a web page is the frontend, and basically, you need to learn to create a frontend part of the website are:

HTML
CSS
Javascript

HTML: It is HyperText Markup Language, as the name tells it is not a programming language but a markup language which is used to present content on a webpage.

CSS: It is an acronym for Cascading Style Sheets which is used to style a website.

These two technologies together create a static (non-functional) website, but what about something dynamic, which can respond to user input, and user actions? That's where Javascript comes in.

Javascript is a scripting language that provides an interactive element for the user on any website.

Consider you want to build a coffee shop. You contact construction workers and have them build a building with bricks, rocks etc. The structure of your coffee shop. Then you contact painters, designers, and carpenters to make it look good, that is the styling of your coffee shop. Then you need coffee machines, computers, and managers to take orders and start operation in a coffee shop. This is the same with a website. HTML gives structure, CSS styles a website and Javascript makes it operatable.

It is important that you shouldn't learn highly advanced concepts for all three of these technologies in the early stage of your journey. Learn the stuff with which you can build basic websites.

Udemy Course you can follow for learning HTML CSS

Udemy Course you can follow for learning JS

This link will take you to the course I followed for learning web development as a beginner. It takes you from absolute beginner to a level you can start building web pages on your own.

It is not an affiliate link

Once you get hold of HTML, CSS & Javascript. You can start learning CSS frameworks. The most popular of them are:

Bootstrap
Tailwind CSS

CSS frameworks are already prepared CSS files, which you can directly use in your HTML files for easier front-end development.

If you find yourself interested in front-end development, take the next step ahead and learn a Javascript Framework.

A Javascript Framework is pre-written javascript code consisting some commonly used JS libraries, modules and add-ons to build web pages more efficiently and in lesser time. There are numerous Javascript frameworks out there and it seems like every month a new framework is released. But most popular of them are:

React
Vue
Angular (developed by Google)

The most popular choice is React as it is easier to get started with, but choosing a Javascript framework is totally up to you.

So, once you are done with HTML, CSS, JS, React/Vue/Angular you can pretty much call yourself a Front-End Web Developer.

Backend

It refers to everything happening behind the pretty web pages you see. The data collection, logging into a website, sending a friend request on Facebook, basically 80% of the tasks of any website are handled by the backend.

If you look at the roadmap image you can see there are plenty of languages you can learn to start with server-side development. Since you have already learnt Javascript during your frontend development, you can opt for NodeJS as your choice for backend programming. Along with that you should learn Express and MongoDB.

What is NodeJS?
NodeJS is actually not a language but it is an open-source cross-platform Javascript runtime environment. This basically means is, traditionally Javascript was made only to run and execute in the browsers, few developers got together and made a software via which Javascript can be executed outside of the browser as well.

What is Express?
As per the website, it is a fast, unopinionated, minimalist web framework for Node.js. Building backend applications in raw NodeJS can be tough. So, Express comes with some pre-built easy to understanding and implement features to write backend code for Web & Mobile applications.

What is MongoDB?
You have created a website, and written backend code for your website as well, but you need a place to store the data. That is a database. MongoDB is a NoSQL database.
NoSQL vs SQL Databases

MongoDB provides you with a MongoDB Atlas which is a database on the cloud and has a free tier to use for beginner developers.

Now, MongoDB can be integrated directly with your NodeJS application with a library called Mongoose.
Mongoose makes it easy to integrate MongoDB into your application.

Learn NodeJs, MongoDB

Now, this is only one way to become a backend developer. As you can see from the roadmap image there are different languages available to become a backend developer. But the pattern remains the same, you need a programming language to run on the server-side and you need to learn a database language and how to integrate it with your choice of server-side language.

Other Essentials to learn

Version Control Systems

Version control is the practice of managing and tracking changes in the code of your software. It is an essential practice during the development of your website as due to any mishappening you can lose all your code thus you need some kind of technology to maintain and sustain different versions of your website. That is where git comes in.

What is git?

Git is an open-source version control system to handle very small to large projects with speed and efficiency.

Once you learn git you need a platform where you can store and save the versions of your website and collaborate on your project with your team/organization thus we learn about the version control repository platform.

There are different platforms for hosting Version Control Repositories:

GitHub
Bitbucket
GitLab

What is GitHub?

GitHub is the most popular and used Version Control Repositories platform. According to Google: GitHub is a website for developers and programmers to collaboratively work on code. The primary benefit of GitHub is its version control system, which allows for seamless collaboration without compromising the integrity of the original project. The projects on GitHub are examples of open-source software.

Learn Git & Github in a single video

This is pretty much what you need to understand and learn to call yourself a Web Developer. Trust me, once you learn all the basic stuff and start coding your ideas into reality you'll automatically figure out advanced stuff. Do make sure that you do not go for learning advanced things in any of the technologies I mentioned as it can demotivate you as you will not be able to see results.

While learning it is very important you keep on building with whatever you learn after every few weeks otherwise you can feel that you do not remember anything done previously and you can go into a deep tutorial hell. Watch a tutorial, build something, if you are stuck don't fear asking someone in some community, your seniors or Googling your doubts. It's common for developers to Google even small problems, thus you'll find solutions to even the smallest problems and errors in your code.

Resources

You can definitely follow the Udemy links I mentioned with every section to learn that particular technology, but there are numerous videos and articles present freely on the web that can give you tons and tons of knowledge. If you are the one with discipline and can do things on your own, you need not go for paid courses as of now, as a beginner. You can refer to the following free resources:

YouTube is filled with free quality content and I am just mentioning a few of those

(https://www.youtube.com/c/Freecodecamp)
Freecodecamp's YouTube channel & website is a hub of top-quality content for free.

Bonus Tip

Once you learn Javascript and React you can easily shift to the development of cross-platform applications, that is write code once and you can build an application for Android, iOS, PC, Mac etc. using React Native.

Final Words

Being patient is the key to becoming a developer. It will take time and you cannot deny that fact. You only learn after making mistakes and don't fear making them. Do experiments, mix-match stuff and then only you'll learn how to achieve what you want to achieve.

My gadgets

Laptop (Macbook Air 2020 M1)

Keyboard and Mouse: https://amzn.to/3eTvFTP

External Display Monitor: https://amzn.to/3doZI5z

External SSD: https://amzn.to/3BrrSoD

USB Hub for Macbook Air: https://amzn.to/3ScC3E1

Headphones: https://amzn.to/3qR5yzP

(some of the above are affiliate links ie if you purchase any item using the links above I'll get a very small percentage of it and you'll get the product at the same price)

Different ways for User Authentication with NodeJS Part - 2 (JWT)

Lavish Goyal — Sun, 21 Nov 2021 04:46:47 +0000

So this is the part 2 of the User Authentication with NodeJS. You can check out the Part - 1 here. In this Part we talk about the modern solution for User Authentication which is much more feasible and scalable. Token Based Authentication.

Token Based Authentication

In token based authentication, when a user logins with correct credentials a token (a long string with random characters and numbers) is generated and sent back to the client's browser where it is stored (in localStorage, SessionStorage or cookie). Now every time a user will make a request to the server that token stored in browser will be sent back to the server and we will have some middleware function to verify the token and give back the required resources.
Let's implement it in code.

Create an empty NodeJS project and in terminal run the command

npm install express jsonwebtoken mongoose

express - For creating our server
mongoose - To Connect to our MongoDB Database
jsonwebtoken - Known as JWT, it is an open source npm package for generating access tokens securely

const express = require('express');
const app = express();
const mongoose = require('mongoose');
const jwt = require('jsonwebtoken');

await mongoose.connect('your_mongo_url', (err, db) => {
            console.log('MongoDB Connected....');
      });

app.get('/', (req,res)=>{
    res.send('<h1>Hello World!</h1>'); 
})

app.listen(5000, () => console.log(`Server 🔥🔥🔥 up on 5000`));

This block of code will make our server up and running on Port 5000. So if you now visit http://localhost:5000/ you will see the desired result.

app.post("/login", async (req, res) => {
  try {
    const { username, password } = req.body;
    const user = await User.findOne({ username });
    if (!user) {
      return res.json({ msg: "Please enter a valid username" });
    }
    const accessToken = jwt.sign(
        { username, id: user._id },
        JWT_SECRET,
        {
          expiresIn: process.env.NODE_ENV === "production" ? "6h" : "2 days",
        }
      );
      res.json({ msg: "User logged in!", accessToken });
  } catch (err) {
    console.log(err);
    res.status(503).json({ msg: "Server error!" });
  }
});

So above block of code is posting the login credentials and logging in the user. Let us understand the jwt.sign() functionality which is creating our access token.
JWT - Json Web Token has a method called sign() which is used to create a new web token which will contain user information in a hidden way. There are three parameters in jwt.sign() method. Let's talk about each of them.

First is the data to be stored in the token. It can be a string or a javascript object. In this example we stored username and id (mongodb unique generated id) in the access token.
Second parameter is the JWT_SECRET. It can be anything (a random string) and it is important not to display it in production. You should use environment variables for saving the JWT_SECRET. It'll be used later on to verify the JWT Token and authenticate the user.
Third parameter is optional properties that can be defined for the access token, like expiry date, httpOnly etc. You can check out more in detail about the optional parameters here

This function will return us a string of random characters which is called a jwt access token. Something like this:
eyJhbGciOiJIUzI1NiJ9.eyJpZCI6IjYwZndmNzA5N2ZmN2YwOTdmMDk5IiwidXNlcm5hbWUiOiJsYXZpc2hnb3lhbCJ9.kNPmoyim0KbrHw6Fl2NPdUWO3UdZ1cr3rFH4eZy9DIg
Now if you how this token contains information about user, open another tab in your browser and go to https://jwt.io/ and in the encoded input box paste the above access token and you'll receive the id and username as shown below

If you look closely there are two dots in the JWT Access token which divides the token string into three parts.

The first part is the algorithm for encoding the token, second part consists the user details we entered and third part is the JWT Secret used to verify the user later (which we'll do just now)

const authenticateToken = (req, res, next) => {
  const authHeader = req.headers["authorization"];
  const token = authHeader && authHeader.split(" ")[1];
  if (token === null) return res.status(401).json({ msg: "Not Authorized" });
  jwt.verify(token, JWT_SECRET, (err, user) => {
    if (err) return res.status(401).json({ msg: err });
    req.user = user;
    next();
  });
};

This block of code will verify the incoming JWT token and authenticate the user and we can proceed with further data processing. jwt.verify() takes in three parameters, first is the token which we'll receive from client. The token can be received either via cookie or in headers. Here the token is passed in the header Authorization Header. *Remember the JWT_SECRET should be the same among the whole project otherwise the jwt token will not be decoded and return an error of invalid token. *

Now the above authenticateToken middleware function can be used in all the protected routes to verify if the user is eligible for accessing data at that particular route for example:

app.get("/dashboard", authenticateToken, (req,res)=>{
   res.send('<h1>Welcome to dashboard</h1>')
})

So in the above code we used the authenticateToken as the middleware function and if the client's request contains a correct jwt token user will be shown Welcome to dashboard heading otherwise will be shown an error.

That was all folks. That was all about the authentication and authorization with NodeJS. There are much more complex and secure ways to do authentication but it was a beginner's tutorial so I kept it that way. Will cover more about it in next blogs. Until then share the post and tag me on twitter.
See Ya!

Different ways for User Authentication & Authorization with NodeJS Part - 1

Lavish Goyal — Sat, 20 Nov 2021 20:15:09 +0000

First let us get over with the debate of Authentication vs Authorization.

Authentication

It is the process to verify if the user is telling the truth. For example: when we log into our account with some username and password, the process of verifying those credentials with the stored information in database and knowing that the user is really whom he/she claims to be is called Authentication.

Authorization

It is a security process to know what information user has access to. Giving someone permission to download a particular file on a server or providing individual users with administrative access to an application are good examples of authorization.

In this article we are going to look into two different methods of User Authentication with NodeJS

Sesssion Based Authentication
Token Based Authentication

Prerequisites

NodeJS
MongoDB (You can use an Atlas account or local mongodb connection)

Setup a new NodeJS project using npm or yarn whatever you like.

Session Based Authentication

This image very simply summarizes the session based authentication. Let's implement it in code and understand better.

Execute the following line of code on your terminal within your project directory.

npm install express express-session mongoose connect-mongo

express - For creating our server
express-session - For creating our session based authentication
mongoose - To Connect to our MongoDB Database
connect-mongo - For storing our sessions in MongoDB Database

const express = require('express');
const app = express();
const mongoose = require('mongoose');
const MongoStore = require('connect-mongo');
const session = require('express-session');

await mongoose.connect('your_mongo_url', (err, db) => {
            console.log('MongoDB Connected....');
      });

app.get('/', (req,res)=>{
    res.send('<h1>Hello World!</h1>')  
})

app.listen(5000, () => console.log(`Server 🔥🔥🔥 up on 5000`));

This block of code will make our server up and running on Port 5000. So if you now visit http://localhost:5000/ you will see the desired result.

Now let us configure the MongoDB Store for session storage.

app.use(session({
    secret: 'fiwafhiwfwhvuwvu9hvvvwv', // Never ever share this secret in production, keep this in separate file on environmental variable
    resave: false,
    saveUninitialized: true,
    cookie: { maxAge: oneDay },
    store: MongoStore.create({
        mongoUrl: 'your_mongo_url'
    })
}));

This block of code used the express-session package to create an empty Session object for a request.
Refer to this link to understand about saveUninitialized and resave properties in the object.

So this will create a new empty session inside our mongodb database with a collection name sessions.

Let's create a login route for user

app.post('/login', async (req, res) => {
    const { username, password } = req.body;    
try {
        let user = await User.findOne({ email: username })
        req.session.userId = user.id;

        console.log(req.session);

        res.redirect('/dashboard')

    } catch (err) {
        console.log(err);
        res.json({ msg: 'Server Error! Please reload page' });
    }
})

Now this block of code is important. Now when the user logs into its account with username and password we send that request to our server and store the request in the session. req.session.userId is storing the unique _id of the user in the session and server creates a unique session id which is placed in the cookie which will be sent back to the client and stored in the client's browser as. Now whenever the client will make any request to the server the header will contain this cookie and we at server side are able to authenticate that particular user using that cookie in the header and obtaining the userId of the user.

module.exports.authentication = async (req, res, next) => {
    const userId = req.session.userId;
    if (!userId) {
        return res.redirect('/login?q=session-expired');
    }
    try {
        let user = await User.findById(userId);
        if (!user) {
            return res.redirect('/login?q=session-expired');
        }
        next();
    } catch (err) {
        console.log(err);
        res.json({ msg: 'Server error. Please reload page after sometime' })
    }
};

We can create this type of middleware function where for every request on protected routes like dashboard, booking history, payment routes etc we can authenticate the user and display the correct data according to the user.

Advantages of Session Based Authentication

Cookies are small-sized values, easy to use and implement and can revoke the validity of the cookies.

Disadvantages of Session Based Authentication

Sessions are stored in server/database and not on client side thus it makes it really difficult to scale the project when there is a huge number of requests simultaneously.

This is where token based authentication (a modern and scalable solution) comes in. It solves the biggest headache with the session authentication that tokens are stored in client's browser thus making it really simple to scale the application.
Stay Tuned for part 2 where we talk all about the Token Based Authentication.