Forem: Sharafat Ahmed Sabir

Working in a startup

Sharafat Ahmed Sabir — Mon, 13 Jul 2020 20:16:21 +0000

I am a software engineer. I am lucky to have worked in 3 different types of companies already in my career. I joined Orion Informatics Ltd. in 2017. It is one of the oldest software companies in Bangladesh. Then I joined a startup named Apploye at very early stage of the company. And now I am working at WPDeveloper which is a bootstrapped company.

The Journey

After two years of work in Orion Informatics Ltd., I needed a change. I was working on a financial web application written in Java Spring Framework at Orion. Although I was contributing to the project, still I was working on a small part of a big project. I wanted to learn more. So, I made a decision to leave my low stress good paying job to join Apploye to make a much bigger impact.

I had to document and design APIs, choose technology stacks, and also manage the servers for my new company besides my regular development tasks. Was I ready for these new challenges? To be fair, No. I was not. I never did these tasks in my previous company. The closest thing I ever did was at University level projects. I did not even know how the cloud works.

We always had tight deadlines in our startup. We wanted to release the product as soon as possible and gather feedback from customers. Also, if you raise investment, there will always be deadline related pressure. Investors will always want to see returns on their investments as soon as possible.

This pressure of deadlines was stressful. But, I was learning at a much faster rate than ever. I even stayed at the office at night for about a month even though my house was 3-4 kilometers away from my office. Then I rented a house which was less than 50 meters away from my office.

I had to do so many things that were not in my job description like reviewing the company privacy policy and terms of services, reviewing the presentation of salespeople, etc. This may not be common for every startup or every employee. But, you should be open to any type of work when you are in a startup.

It is true that when you are engaged in so many things, it is hard to be expert in a specific framework or language. But, you also get to see the whole image of the product. Also, you will be responsible for more things. So, it will be a good opportunity if you want to form a company yourself in the future. From raising investment to earning a modest MRR (Monthly Recurring Revenue), a startup faces many highs and lows. Working in a startup will help you to understand business a bit more.

Not all startups are the same. Some startups raised millions of dollars. Also, some startups are not well funded. Some offer good financial packages and some do not. So, my experience might not be similar to others. I will try to explain why you should join a startup and why you should not from my understandings.

Why you should join a startup

You will learn a lot.
You will have a broader view of the software. You will learn different parts of the whole product.
It is a great opportunity to observe a business closely if you want to start your own business in the future.
You will have more opportunities and responsibilities.
And probably, your work will be more appreciated.

Why you should not join a startup

Salary will most likely be below par than market leaders.
Most startups fail within 3 years.. Although we like to believe we will stand out, most of the time, it is not the case.
You will have to work a lot.
You do not like to switch tasks frequently.
Everyone will be so busy that you are less likely to find good mentorship in your team.

This is not a complete list. There are both pros and cons of joining startups. Also, the experience differs from person to person. Till now, I have not regretted my decision of joining Apploye. But, try to gather some information before joining any startup. Those are:

The financial state of the startup.
Get to know the team if you can.
Properly analyze your gains and losses.

JavaScript: Learn to filter array

Sharafat Ahmed Sabir — Mon, 18 May 2020 11:59:38 +0000

In my previous blog I wrote about JavaScript array map method. In this article, I will write about filter method.

filter is a non-mutating method. Filter does not affect (modify) the original array if we use this method correctly. This (does not affect) does not mean that after applying filter, the resulting array and original array elements will be the same. The resulting array will be a completely new array with different reference to the original array. The new array elements can be different than the original array. But, original array elements and reference will be unchanged.

filter

Like the map method, the filter method creates a new array with the same length from the original array. But, instead of creating an array with the same length as map, the filter method can create a new array with the same length or a smaller size array based on a condition.

filter structure:

const resultingArray = oldArray.filter((currentValue, index, oldArr) => {
  // return true or false
}, this);

filter expects two parameters.

callback function. This does the main job. We have to return true to keep the element in resultingArray and false to exclude the element. We can use traditional function. Or ES6 arrow function. In our case, (currentValue, index, oldArr) => { // return true or false } this is the callback function.
this argument. You can use it as this value in the callback function. It is optional and rarely used.

Now, callback function accepts 3 arguments. These arguments are optional. But, the first two arguments are frequently used.

currentValue. This is the element or value being processed in every loop iteration.
index. This represents the index of currentValue in the original array.
array. This is a rarely used argument. This represents the original array on which the filter method was applied.

After processing, filter returns a new array. In our case, that array is resultingArray. filter creates this new array without modifying oldArray. The resultingArray contains elements for which callback function returned true.

Example:

const persons = [
  { name: "Jane", age: 19 },
  { name: "John", age: 21 },
  { name: "Rick", age: 17 },
  { name: "David", age: 22 },
];

const names = persons.filter(() => true);

// ES5 function syntax:
// const names = persons.filter(function () {
//   return true;
// });


console.log(names);
// output: 
// [
//   { name: 'Jane', age: 19 },
//   { name: 'John', age: 21 },
//   { name: 'Rick', age: 17 },
//   { name: 'David', age: 22 }
// ]

In this example, we have created an exact copy of the original array. In the filter method, I am passing a function that returns true in every iteration. As it returns true for every element in the original array, every element is present in the new array. If we return false for every element, then the new array would be empty.

If we wanted an array which will only contain those elements where person is more than 20 years old, then we could do the following:

const persons = [
  { name: "Jane", age: 19 },
  { name: "John", age: 21 },
  { name: "Rick", age: 17 },
  { name: "David", age: 22 },
];

const newPersons = persons.filter((person) => {
  return person.age > 20;
});

// ES5 function syntax:
// const newPersons = persons.filter(function (person) {
//   return person.age > 20;
// });

console.log(newPersons);

/* output: [ { name: 'John', age: 21 }, { name: 'David', age: 22 } ]

In this example, we have created a new array containing persons who are more than 20 years old. In the filter method, I am passing a function which takes a person and returns true if that person's age is more than 20 and otherwise returns false. So, the filter method will iterate the persons' array. When we return true, the element in that iteration will be in the new array and when we return false, the element in that iteration will not be in the new array.

Now in the first example, I used shorthand syntax to return true and in the second example, I returned true and false explicitly.

We can use normal callback function instead of ES6 arrow function. But, arrow functions are more readable.

I will now share another example with index and array in callback function:

const persons = [
  { name: "Jane", age: 19 },
  { name: "John", age: 21 },
  { name: "Rick", age: 17 },
  { name: "David", age: 22 },
];

const newPersons = persons.filter(
  (person, index, array) => person.age > 20 && index < array.length / 2
);

// ES5 function syntax:
// const newPersons = persons.filter(function (person, index, array) {
//   return person.age > 20 && index < array.length / 2;
// });

console.log(newPersons);

// Output: [ { name: 'John', age: 21 } ]

In this example, I am creating a new array with only persons who are more than 20 years old and are in the first half of the array. So, David is not in the resulting array despite being more than 20 years old as he is in the second half of the array.

All modern browsers support filter. You can find complere reference here

When not to use the filter method

When you need to modify an array, filter will not be able to do the job in that case. filter returns the same element for which callback function returns true.

So, when you need to modify the array elements, you can use map.

You should learn about all array methods to use them appropriately in your codebase.

Why filter is more readable

Suppose, you are creating a new array of persons who are more than 20 years old like our second example with traditional for loop. Then, the code should be like this:

let newPersons = [];
for (let i = 0; i < persons.length; i++) {
  if(persons[i].age > 20){
    newPersons.push(persons[i]);
  }
}

You need to go through the whole code to understand that I am creating a new array with persons who are more than 20 years old. You will also have to check if I have written a break or continue statement to skip any particular value or not. You will also have to check if I am modifying the elements of the array or not.

But, in my filter example, as soon as you see a filter method, you know that I am creating a new array with the same type of elements as the original array. You will be sure that in the resulting array, elements structure or type is not modified. Also, the main logic of elements which will be in the resulting array is very easy to find.

const newPersons = persons.filter(person => {
  return person.age > 20;
});

When we use filter, we can focus more on logic cause it's purpose is defined.

Conclusion

The filter method has a specific purpose. That purpose is: creating a new array with elements that pass a specific condition. Whenever we need this functionality in our code, we should be using filter for better readability and maintainability.

Write more readable code in JavaScript using map array method

Sharafat Ahmed Sabir — Sat, 09 May 2020 09:35:39 +0000

The array is one of the most common data types in JavaScript. There are many useful methods associated with arrays like map, filter, reduce, find, some, forEach, push, pop, etc. In this article, I am gonna talk about map method.

map is a non-mutating method. So, if you do things right, the main array elements will not be affected (modified).

Map

map method creates a new array with the same length from the original array. It is very helpful when you need to create a new array from the original array and you also want to do some operations on each item in the array.

map structure:

const resultingArray = oldArray.map((currentValue, index, oldArr) => {
  // return an element
}, this);

map expects two arguments.

callback function. This does the main job. We can use traditional function. Or ES6 arrow function. In our case, (currentValue, index, oldArr) => { // return an element } this is the callback function.
this argument. You can use it as this value in the callback function. It is optional and rarely used.

Now, callback function has 3 arguments.

currentValue. This is the element or value being processed in every loop iteration.
index. This is optional. This represents the index of currentValue.
array. This is also an optional and rarely used argument. This represents the original array on which map method was applied.

After processing, map returns the resultingArray without modifying oldArray.

Example:

const persons = [
  { name: "Jane", age: 19 },
  { name: "John", age: 21 },
  { name: "Rick", age: 17 },
  { name: "David", age: 22 },
];

const names = persons.map(person => person.name);
/*
* ES5 function syntax:
* const names = persons.map(function (person) {
*   return person.name;
* });
*/

console.log(names);
// output: ['Jane', 'John', 'Rick', 'David']

In this example, we have created a new array containing only names. In the map function, I am passing a function which takes a person and returns that person's name. So, it loops through the array, for every element in that array, it returns only the name property hence creates a new array with only names.

If we wanted an array containing name and a flag to determine if the person is 20 plus aged, then we could do the following:

const persons = [
  { name: "Jane", age: 19 },
  { name: "John", age: 21 },
  { name: "Rick", age: 17 },
  { name: "David", age: 22 },
];

const newPersons = persons.map(person => {
  return { name: person.name, twentyPlus: person.age > 20 };
});

/*
* ES5 function syntax: 
* const newPersons = persons.map(function (person) {
*   return { name: person.name, twentyPlus: person.age > 20 };
* });
*/

console.log(newPersons);
/* output:
* [
*   { name: 'Jane', twentyPlus: false },
*   { name: 'John', twentyPlus: true },
*   { name: 'Rick', twentyPlus: false },
*   { name: 'David', twentyPlus: true }
* ]
*/

In this example, we have created a new array containing names and a flag to determine if the person's age is more than twenty or not. In the map function, I am passing a function which takes a person and returns a new object. That object contains the person's name and a flag to determine if the person's age is more than twenty or not. So, it loops through the array, for every element in that array, it returns the name property and that boolean value wrapped in an object hence creates a new array with names and twentyPlus flag.

Now in the first example, I used shorthand syntax to return name and in the second example, I returned the new object explicitly.

We can use normal callback function instead of ES6 arrow function. But, arrow functions are more readable.

I will now share another example with index and array in callback function:

const persons = [
  { name: "Jane", age: 19 },
  { name: "John", age: 21 },
  { name: "Rick", age: 17 },
  { name: "David", age: 22 },
];

// index will add 0, 1, 2, 3 respectively and array.length will
// add 4 for every new item's modifiedAge property
const newPersons = persons.map((person, index, array) => {
  return { name: person.name, modifiedAge: person.age + index + array.length };
});

// ES5 function syntax:
// const newPersons = persons.map(function (person, index, array) {
//   return { name: person.name, modifiedAge: person.age + index + array.length };
// });

console.log(newPersons);
// Output:
// [
//   { name: 'Jane', modifiedAge: 23 },
//   { name: 'John', modifiedAge: 26 },
//   { name: 'Rick', modifiedAge: 23 },
//   { name: 'David', modifiedAge: 29 }
// ]

All modern browsers support map. You can find complere reference here

When not to use map

map is not for every situations. When you do not want or need to return value or create new array with the same length, map should not be used. forEach or other array methods should be more suitable on those situations.

Why map is more readable

Suppose, you are creating a new array of persons with name and twentyPlus boolean flag like our second example with traditional for loop. Then, the code should be like this:

let newPersons = [];
for (let i = 0; i < persons.length; i++) {
  let person = {
    name: persons[i].name,
    twentyPlus: persons[i].age > 20,
  };
  newPersons.push(person);
}

You have to go through the whole code to understand that I am creating a new array. And the main logic of creating that array resides inside person object creation part inside the for loop. You will also have to check if I have written a break or continue statement to skip any particular value or not.

On the other hand, as soon as you see a map method, you know that I am creating a new array of the same length. As new array must be of the same length, I cannot use break or continue to skip values.

const newPersons = persons.map(person => {
  return { name: person.name, twentyPlus: person.age > 20 };
});

When we use map, we can focus more on logic cause it's purpose is defined.

Conclusion

map is a very handy array method. It has a specific purpose. That purpose is: creating a new (modified) array with the same length. Whenever we need this functionality in our code, we should be using map for better readability and maintainability.

Authentication Best Practices in REST and GraphQL APIs

Sharafat Ahmed Sabir — Thu, 16 Apr 2020 13:06:56 +0000

This was originally posted in here

You want to let only selected users to use certain features of your product? You need proper authentication and authorization process. These two are different. Authentication is the process of identifying if the user is valid. And authorization is the process which checks and grants access to different features or resources.

Both REST and GraphQL are not opinionated. So, you can put in place authentication anyway you like. But, as it is a very sensitive feature, you should always keep security in mind.

In this article, I will be talking about the authentication and authorization process of web applications which are built on top of REST or GraphQL APIs. I will be pointing out some best practices you should follow.

Always use HTTPS

HTTP and HTTPS are both protocols for networks. HTTP means Hypertext Transfer Protocol and HTTPS means Hypertext Transfer Secure.

We can even tell by the name that HTTPS is more secure. So, any website working with user data, credentials, etc. must use HTTPS protocol for transferring data.

How is HTTPS secure? Well, in this protocol, data is first encrypted and then sent to the server. Wondering how this encryption is going to help you?

Assume you want to use a web service where you have to sign in using your username and password. If that website is using HTTP protocol, then any outsider can sniff packets which are being sent to your server including your password in plain text. Payload (username, password, etc.) is encrypted in websites using HTTPS. So, if the attacker wants to know the password, he will have to know the private key of your SSL certificate.

So, HTTPS is a must if you are building any website which will be working with user data. Also, redirect to HTTPS if anyone types HTTP to enter your website.

Saving Hashed Password

Imagine you have the best talents around the world at your disposal. But, if you are saving user passwords in plain text, you are putting your users at risk. Hackers attacked and stole passwords, credit cards, etc. data of millions of users by attacking popular sites like Sony, Adobe, Yahoo, etc. So, even if you have the best engineers in the world, you need to have the basics right. Please do not save the passwords in plain text.

Now you might wonder, if I do not save password, how can I know if one who is trying to sign in, is the correct user?

The answer is:

Use Hash

Anyway, do not get confused with "Hashtag". ;)

Hash is a function which transforms one data into another in a very fast manner. Hashed data is not reversible. So, hash the password and save it in the database. Next time someone tries to sign in, hash password provided by him/her and check against the database.

Now we have secured everything. Right?

No. Attackers can use rainbow tables to reverse the hashed data to plain text.

Now what?

Well, you should add salt to your hashing process. Beware, salt is not the silver bullet. Imagine your servers have been attacked and attackers have got access to your database. They will probably find your salt and hashing algorithm in no time. Then they will use brute force to generate a rainbow table with your salt and hashing algorithm to find out user passwords.

So, here we cannot do much. Popular hashing algorithms are very fast. We need to slow attackers down. So we should use bycrypt as our hashing algorithm. It is very slow. But, in this case, we want to slow down the process. A user won't care much if the hashing algorithm needed .2-.3 seconds extra while signing in. But, it will make attackers life hell.

Never Pass the Hash with the Request

Now you might be thinking, how would I know if the user is correct in every REST or GraphQL request?

First of all, never send the hash of password back from the server. It's the number one rule.

If you are passing around the hash, it will eventually end up in wrong hands.

So, what should we do? What are the best practices for letting the server know if the user is valid or not?

Instead of passing hash of password to front end to use that in subsequent queries, generate session-id or token and pass that. In the below section, I will discuss about session-id and tokens.

Session or Token?

You can use either session-id or token for REST or GraphQL APIs. What is the best approach?

First, you have to understand HTTP/HTTPS, REST and GraphQL. HTTP/HTTPS is stateless. It does not store data from previous requests. Apart from Websockets and Subscriptions, REST and GraphQL are also stateless. A server does not normally remembers requests. It just serves the API calls it received.

We need to to check state sometimes. Sometimes the server needs to know if the user is authenticated. Session-id and tokens solve the problem differently.

In session-id, the server generates a session-id when user sign in. It stores the session-id. If you have multiple servers to serve high traffic, you need to store that id in a shared or distributed database. In the case of a shared database, it can create a bottleneck.

Now in token-based systems, the server creates a token which contains some necessary information. Generally, this contains user_id, role, expiration date, etc. info. This token is not stored in servers. The server sents token to the front end. When the front end needs data from authenticated APIs, it sends the token to the server along with other data. Server checks the information written in it. And then process the request.

Tokens are stateless. Server does not have to remember token. We need to know if token has been tempered. Otherwise, attackers can generate tokens to attack services.

For making scalable service, tokens are always better. It is becoming de-facto day by day.

JWT

In the previous section, I have stated tokens are better for scalable services. But, we also need to make sure tokens are not tempered.

JWT is the answer. In a JWT token, there are 3 parts. Header, Payload and Signature. First two parts are base64Url encoded JSON data separated by a dot.

Header

Typically header consists of two parts. alg and type. alg defines the name of the algorithm used. type is the type of token i.e JWT.

Payload

It contains the important information. User id, expiration time of token, issuer, subject, etc. are stored here. Server checks different data from here.

Signature

It is the most important part. Encoded header, payload, and a secret is used to create a signature. Server has the secret. So, it can verify payload using this secret. So, the server can be sure, nobody tempered the payload.

JWT is a very popular implementation of token-based authentication system. It is widely used. OpenID connect, Auth0, etc. also uses JWT as their token.

Cookies or Session or Local Storages?

We must store the JWT token returned by the server. We need to store it in a way that can persist a long time. Users should not be signed out after closing browser. We also have to store it securely.

Session storage is short-lived. Closing tab/browser wipes out session storage.

Local storage persists even after we close browser. So, it is a very popular choice to store token. But, it is not the most secure place to store JWT tokens. Articles like this, this and this explains problem with local storage. It is succeptible to XSS (Cross Site Scripting) attacks.

Cookies are relatively smaller storage. It has some attributes like expiration date. Cookies are also vulnerable to various attacks. But, we can set the HttpOnly flag to true to disable reading cookies by javascript. This will help us to mitigate XSS problems in cookies.

What about CSRF?

CSRF or Cross-Site Request Forgery is the final piece of the puzzle. Attackers can use cookies to carry out CSRF. Cookies are sent with every request to the server.

Imagine you are signed in to your bank's online portal and you are browsing as usual.

Now, you clicked on a link that contained an invisible form that will be sent to that bank API without even any button click.

If this happens, cookies related to bank service will be sent to that server. So, the bank will think you called the API. And it will transfer money according to the form data.

There are two remedies for this problem. One is, setting SameSite attribute in cookies. Another is to use CSRF tokens.

SameSite Attribute

It is a relatively new concept. Not every browser supports this attribute.

You can set one of three values in this attribute. Strict, Lax and None.
Strict means, no cookie will be sent to the server if the front end and server domain are different. Lax will let you send cookies from different sites when the HTTP method is GET. And, None is the default behavior (Attack prone).

We should remember, GraphQL uses POST requests for every API call. So, using Lax in GraphQL will make no sense.

CSRF Tokens

These are random unique ID generated by the server. You should save the CSRF token in local storage and JWT token in a cookie. We should set HttpOnly flag to true. SameSite flag to Strict and Secure flag to true.

We need to send CSRF token in the API request body. Now even if an old browser does not support SameSite attribute, CSRF tokens will help us against attacks.

One has to do CSRF attack on an old browser and also an XSS attack to find out the CSRF token at the same time for a successful attack. So, by this method, we have reduced attack probability.

tl;dr

Use HTTPS
Use bycrypt and salt to generate hash
Use JWT tokens for authentication and authorization
Set JWT token in Cookies. Set HttpOnly and secure flag to true and SameSite flag to Strict.
Use CSRF tokens and save that CSRF token in local storage.

Case Study: A Covid19 comparison website in less than 50 working hours

Sharafat Ahmed Sabir — Fri, 10 Apr 2020 12:10:21 +0000

The world has been hit by novel coronavirus pretty badly. Cities around the world have been locked down to prevent the spreading of novel coronavirus. Covid19 is the disease created by this novel coronavirus.

I have created a website where people can compare historical data of covid19 situations among different countries.

Summary

Website link: https://covid19comparison.iamsabir.com

Source Code: Covid19CountryComparison Github Repo

Framework used: GatsbyJs

Hosting Solution: Zeit

Expectation about Covid19 Comparison Website

I wanted to show covid19 related data of countries visually. Also, an important target was to let people compare data of different countries in the same timeline.

Challenges

I faced some challenges in my journey. Here I am explaining those.

Data

The first problem was data. Data is the most important thing. There are lots of different APIs where you can get various types of data. Some APIs are open for all. Some are not.

I searched for open and free APIs which will serve my purpose. Pomber JSON time-series data, corona.lmao.ninja and Covid19 API helped me a lot to build the website.

Choosing the Right Technology

We now have a very sweet problem in the software industry. There are too many programming languages, frameworks and libraries out there. We now have to choose technology very carefully considering our skills and desired work.

I wanted this website to be either server-side rendered website or a static one. These types of websites perform better in the case of SEO.

I will be explaining my choice more in the next section.

Technological Options

I am comfortable working with Java ecosystem and ReactJs ecosystem. So, NextJs and GatsbyJs are two very good and convenient options for me. I have worked extensively with both frameworks.

NextJs supports both static site generation per page and also server-side rendering. With its 9.3 version release, NextJs has gone to a different level. New methods like getStaticProps, getServerSideProps etc. are helping NextJs to become a true hybrid framework.

GatsbyJs, on the other hand, is a Static Site Generator. GatsbyJs also allows us to make API calls on the fly. It is a great framework packed with various out of the box plugins. It utilizes modern technologies like GraphQl, React, etc.

Now, for hosting option, I wanted to use a serverless hosting solution. This would help me to worry less about managing servers. There are a lot of serverless hosting solutions like Zeit, Netlify, Firebase etc.

Solution

I have a full-time job. And after office hours, I spend a lot of time with family. So, I needed a way to build this website fast without affecting my normal routine.

I choose GatsbyJs for creating the website. Although NextJs has some pretty good static site generation options, GatsbyJs is built for Static sites. You can deploy GatsbyJs in almost any kind of servers and hosting services. NextJs can be deployed in Zeit's serverless hosting solution. But, GatsbyJs has far more alternatives.

Also, GatsbyJs has a vast array of plugins and starters. This plugins and starters help you to build website fast.

For hosting solution, Zeit was an obvious solution for me. For personal projects, Zeit maybe has the most generous free tier. They literally offer unlimited bandwidth, build time, custom domains and projects for personal websites. With the help of webhooks and their CLI, deployment is something, you do not need to even worry about with Zeit. So, I did not much time to setup domain, CI/CD and other deployment-related works.

In the Challenges section, I listed 3 sources from where I fetched data. I needed to modify JSON output from those APIs. I chose Google Cloud Platform's Cloud Functions for this task. For small jobs like this, GCP functions, AWS lambda, etc. could be a very fast and convenient option.

And for the visual representations, I chose ChartJs. ChartJs is very easy and straight forward. So, to complete the website in a minimum time possible, I used ChartJs.

Choose between wget.blog or [myName].[TLD] for personal blog

Sharafat Ahmed Sabir — Sun, 02 Feb 2020 02:07:59 +0000

I am currently using https://www.wget.blog as the domain name. I am planning to write more regularly. I want to focus on react, redux, gatsby, Java and SQL related contents. What do you think? Should I stick to wget.blog or should I buy [myName].[TLD] type of domain?

Technical skills software engineers must have

Sharafat Ahmed Sabir — Wed, 25 Dec 2019 05:29:47 +0000

Software engineering is one of the hottest types of jobs in the market right now. One of the beauties of software engineering is, you can be a successful software engineer without a formal degree. Skill is all that matters in software engineering.

A good software engineer needs various types of skills. But, technical skills are by far the most important ones. These are the skills that help you to get your tasks done in the workplace.

In this blog, I am gonna talk about tech skills which are must-have for software engineers.

Disclaimer: If you are fresher who is trying to land a job, this article is not for you. You do not need to learn everything mentioned here to land a job. You need to read the book: 'Cracking the coding interview'. Practice on Hackerrank, Leetcode, Geeks for Geeks, etc.

Data Structure (For every software engineer)

Data Structure is one of the most important subjects for software engineers. Data structures are some specific formats for storing data. Each data structure is efficient in some cases and inefficient in other cases. So, as a software engineer, you must have the skill to pick the right data structure.

The following data structures are a must for every software engineer:

Array
Linked List
Trees
Trie
Stack
Queue
Map
Graph
Hash Tables

If you want to learn more about data structures, you can visit Geeks for Geeks.

Algorithm (For every software engineer)

A software engineer's main job is to solve problems. Algorithms are step-to-step instructions to solve a problem. So, algorithm is a must-have skill for every software engineer. Good knowledge of algorithms helps him/her to solve problems.

Here are some important and basic algorithms:

BigO Notation
Depth-first Search
Breadth-first Search
Dijkstra's Algorithm
Searching
Sorting
Divide and Conquer
String Matching
Pattern
Greedy

You can learn algorithms in Khan Academy, Geeks for Geeks and many other places.

OS (For DevOps Engineers)

Every program runs on an operating system (OS). So, knowing the underlying OS will help software engineers to write more efficient and better code.

Here are some fundamental concepts a software engineer should know:

Process
Memory Management
Thread and Concurrency
Scheduling
I/O Management
Inter-Process Communication
Virtualization

After learning these fundamentals, learn about distributed systems and cloud.

Networking and Communication (For DevOps Engineers)

Most of the software engineers work on web technologies. And you should have a good understanding of networking and communication to excel at web technologies. Especially if you are interested in DevOps, networking and data communication is very important.

The followings topics are must for software engineers:

IP
Private/Public Network
Router
Switches
LAN/WAN
OSI Model
Protocols
P2P communications
Mesh, Ring, Star, etc.

If you want to be a DevOps engineer, this can be a starting ground for you.

Programming Language (For every software engineer)

As a good software engineer, you need to learn at least one programming language very deeply. Also, I recommend software engineers to try new programming languages frequently. This helps us to learn about good things about that language. This also helps us to learn new technologies and languages quickly.

Learn at least one of the following languages deeply:

C
C++
Java
Python
JavaScript
C#
PHP

Also try to learn at least one scripting language like JavaScript, PHP, Python, etc.

OOP (For every software engineer)

Object-oriented programming is one of the most used paradigms in the software industry. a software engineer should know the following concepts:

Encapsulation
Polymorphism
Inheritance
Abstraction
Association
Aggregation
Composition

Database (For back-end engineers)

Software engineers have to deal with data every day. Structured data are stored in Databases. So, you should have a good understanding of databases.

You should learn at least basic CRUD operations, joining, grouping, etc.

Learn at least one of the following databases:

PostgreSQL
MySQL
Maria DB
Oracle DB
MS SQL Server
MongoDB
Cassandra
Neo4j

Git (For every software engineer)

Version controlling is very important in software engineering. This helps us to collaborate with others. It also enables us to roll back to any previous version easily.

Git is the most popular version controlling system now. You should learn at least the basics of git.

Learn how git works. Also, learn basic commands like add, commit, push, pull, fetch, merge, etc.

IDEs and Editors (For every software engineer)

IDE stands for Integrated Developer Environment. IDEs give suggestions while coding, check for errors before even compiling code and do a lot of other things. IDEs like Intellij Idea, Eclipse, Visual Studio, PyCharm, etc. are capable of doing a lot and saves a lot of time and energy of developers. Editors are simpler. But, editors like VS Code, Sublime Text, Atom have changed the game. They are capable of doing much more than editing nowadays. You have to know your IDEs and editors to unlock these potentials which can help you to be more productive.

Mentality (For every software engineer)

This part is not purely technical. But, I want to add it anyway. To acquire these technical skills, you have to be prepared. If you find things complex, do not lose hope and keep on trying. You do not have to be a genius to acquire these skills. You just need to work hard. I have seen several students who thought they could not be good at programming contests. But, after going through a rigorous training program at university, those who did not drop out of the training program, excelled at competitive programming. Some of my colleagues thought they would not be able to keep up with all these new technologies. But, those who worked hard, excelled in this industry where a new technology is being introduced every fortnight.

Conclusion

In this article, I have talked about the basic skills that software engineers must-have. These are starting ground. For your specific task, you will need to learn topics beyond this article.

N.B: If you think I missed something or if you have any opinion about this article, leave a comment below.

This article was originally written in Wget Blog

How to reach more people via tech blogs

Sharafat Ahmed Sabir — Mon, 16 Dec 2019 04:13:43 +0000

I am building a tech blog. But, I am not sure how to reach more and more people with my blogs.

My first blog reached a lot of people. But, I do not have a constant flow of visitors.

Forem: Sharafat Ahmed Sabir

Working in a startup

The Journey

Why you should join a startup

Why you should not join a startup

JavaScript: Learn to filter array

filter

When not to use the filter method

Why filter is more readable

Conclusion

Write more readable code in JavaScript using map array method

Map

When not to use map

Why map is more readable

Conclusion

Authentication Best Practices in REST and GraphQL APIs

Table of Contents:

Always use HTTPS

Saving Hashed Password

Never Pass the Hash with the Request

Session or Token?

JWT

Header

Payload

Signature

Cookies or Session or Local Storages?

What about CSRF?

SameSite Attribute

CSRF Tokens

tl;dr

Case Study: A Covid19 comparison website in less than 50 working hours

Summary

Expectation about Covid19 Comparison Website

Challenges

Data

Choosing the Right Technology

Technological Options

Solution

Choose between wget.blog or [myName].[TLD] for personal blog

Technical skills software engineers must have

Data Structure (For every software engineer)

Algorithm (For every software engineer)

OS (For DevOps Engineers)

Networking and Communication (For DevOps Engineers)

Programming Language (For every software engineer)

OOP (For every software engineer)

Database (For back-end engineers)

Git (For every software engineer)

IDEs and Editors (For every software engineer)

Mentality (For every software engineer)

Conclusion

How to reach more people via tech blogs