DEV Community: The Ninja Programmer

Take your localhost API to be accessible from WWW

The Ninja Programmer — Tue, 13 Apr 2021 13:19:51 +0000

In this post, we will tell you how you can take the API on your machine to be accessible from WWW by using a powerful and free tool called ngrok.

The Problem

Many times we developers develop APIs for our apps. But when we are working in a team and you need to give access to your API to other team members, you just have one option, upload it to a server. This process is very time-consuming.

The Solution

Wouldn't it be easy to simply take the API from localhost to WWW so that anyone could access it? Well, that's exactly what NGrok does for you.

How does it help?

Suppose, I am developing an API that gives me the list of food items. As I am developing it on my machine, the URL to access this would be

Now, I would like my colleague to access this endpoint. So, to do that, I will use ngrok.

Step 1:

Simply visit https://ngrok.com/ and download the ngrok.

Step 2:

Now before using ngrok you have to first set the auth token. So simply go to the ngrok site and get the auth token by creating the account. Now run the below command with your auth token.

Step 3:

Lastly, just run the below command by specifying the port no on which you want to receive the request from WWW.

In My case, it is 80 because my xampp is running on port 80.

Result

Now you will get a random WWW URL from NGROK.

By using this URL anyone can access your localhost API.

Thank you for reading!

Things you should consider while using StackOverflow!

The Ninja Programmer — Mon, 12 Apr 2021 14:20:12 +0000

We developers love StackOverflow. Life as a developer would have been so hard without it. I know it has saved you many times as it has saved me over the years.

But, be a bit careful while using the solutions from stack overflow directly.

Take the following points into consideration while using solutions from it.

1. The time when the question was answered

Being in tech, things change at a drastic rate. The time when the question was answered is very important because the solution might have been the best back in say, 2015 according to the tech stack at that time.

But maybe in 2020 or 2021, a better solution could exist with improvements in the tech stack and new versions. The solution in 2015 and 2020 or 2021 could be significantly different.

2. Accepted answers are not always the best ones

Don't think that the accepted answer is the best one. No, it does work that way. Maybe, the unaccepted answer could be more good and optimal. This could happen because the better answer was posted after the accepted answer.
So, the next time you are on StackOverflow, don't just copy the accepted answer.
Spend time scrolling through all the answers.

3. Some comments are GOLD

Some comments just below the answers tell you more than the answer itself. It could be right from correcting the answer to pointing out why we should not use it. Sometimes, the comments explain the code better than the original author. Look out for such comments, they are life-saving.

4. Do not downvote, if you did not understand the answer

Don't just downvote someone because a lot of other people have. It's very easy to put someone down. Only downvote if you understand the shortcomings of the code or if you know the potential side effects it could have.

5. Be responsible while answering

Don't blindly answer questions! You need to be responsible enough to tell the good points, bad points, better solutions (if exists), and justify why you are giving this as an answer.

Thank you for reading.
Let us know your thoughts in the comments below.

Things only bad developers do

The Ninja Programmer — Sat, 10 Apr 2021 15:26:44 +0000

As a developer, our job is not only limited to wring the code. There are a few more things that we must do apart from writing code.

Today, we will tell you a few points that you should not do as a developer.

1. Writing Over Optimized Code

It's always good to write optimized code, but it's also important to make sure that we don't over-optimize it. Let's say, you are working in a team and you are assigned to write a function that does something. Suppose, you come up with a solution that does that job in 2 or 3 lines, but it's over-optimized and not very easily readable.

If other team members are trying to understand this function, they will hardly understand what your code is doing and how is it working, because it's hardly readable due to being over-optimized.

Always write optimized code, but not at the cost of readability and ease of understanding.

2. Pushing untested code into production

No matter how much sure you are about your code and its working, pushing it directly to production without testing it, is a BAD decision.

You might feel like doing this when you have made a really small change and not feel like testing it.

But, there could be chances that that change might not be implemented as you wanted.

3. Pushing commented code in production

This is very dangerous. You might think what harm it might do? But, when code comes under maintenance or updations and some other dev starts working with the code, there are always chances that he might uncomment it and screw up the entire application. Also, it might create unnecessary confusion.

4. Not considering the bad scenarios

Your code will not always run in an ideal scenario or your users will not always use the app as you want them to use. So, ignoring all the basic bad scenarios is the worst thing to do. If you do that, your code will horribly fail.

As a developer, always consider, manage all the bad scenarios. Make sure your code is ready to face the worst of conditions.

Thanks for reading.
Let us know your thoughts in the comments below

Some tips for your first job as a developer

The Ninja Programmer — Sat, 10 Apr 2021 07:15:42 +0000

Be honest

Never lie if you don't know something. Let your manager know about it.

No showing off!

No Manager likes a newbie telling him/her how they should go about the business.

Be Motivated!

You have to justify your selection in the company and prove you have all that it takes.

Learn from your teammates

Always learn from your seniors and their experiences.

Maintain a good rapport with your managers

Apart from working hard and adding value to your organization, it's very important to be on good terms with your managers. It will help you in growing in the organization.

Let us know your thoughts in the comments below 👇

A LIFE-SAVING GitHub Feature that you need to know RIGHT NOW!

The Ninja Programmer — Mon, 15 Feb 2021 15:32:02 +0000

Ever browsed a Github repository and felt the pain of not being able to view the code without having to download the entire repository?

It's huge pain, especially when you simply want to look through the code.

Wouldn't it be great if we could simply view the code while browsing without having to download the entire repo?

Well, this problem has been solved! A great tool that will help you to view the code on the go, that too, in one of our favorites and powerful code editor, VS Code!

Wondering how to do it?

You can do this in just 3 steps:

Step 1 - Go to any GitHub repository
For Example: 
https://github.com/iamrohitsuthar/quizller

Step2 - Just put 1s in the between of Github and .com in the address bar and see the magic happen.

Step 3 - Wow! The repository opens in an online VS Code editor!

Isn't it time-saving for devs?

Let us know your thoughts in the comments below

Importance of Writing Clean Code

The Ninja Programmer — Fri, 12 Feb 2021 14:23:11 +0000

Writing clean code is very important, especially in apps that are big in size and where multiple teams are working.

1. Extension becomes easy
Following proper architecture and writing clean code makes it easy to extend the functionalities of your application.

2. A new developer will find it less difficult to understand your code
Whenever a new dev gets added to the team, he/she will find it less complicated to read the code and understand what has been written. In contrast to that, the unclean code will require a lot of time and effort to understand.

3. Making changes becomes easy
A clean code will allow you to make changes more efficiently. Like, changing one thing in a part will not break the other features. If you have experienced this, you know how bad it can become.

4. Testing and Debugging the Code becomes much more simple
Finding bugs in an unclean and the code that is all over the place is a big ask. There are also chances that some bugs might be caused due to the non-neat code itself!

How to write clean code ?

It's not that difficult. Following best architectural patterns, naming conventions, wring self descriptive code will do the job for you.