DEV Community: Siwalik Mukherjee

I moved to Europe for a tech job, mid pandemic

Siwalik Mukherjee — Sun, 21 Aug 2022 19:29:34 +0000

I moved from India to Europe around one year back for a new job. In this post, I will share my experiences with relocating to a new country and why it might be the best thing you can do for yourself and your career.

Some background before we dive into the deeps

For some years now, every December, I would write in my Vision and Values journal about how I would want the next year to be and the best things that can happen for my career, well-being etc. For 2021, among others, I had a point about relocating outside India for a tech job and exploring new cultures. At least if not move, give my best shot at it.

Around March last year, it was officially one year since I permanently moved back to my parent's house (thanks to Covid). Arguably it was the best bonding time I had with them in years, and my heart was whole.

But also, I started looking for a job change as I felt overworked at my current work and wanted more challenges and exposure in my career. So I started applying to smaller Indian startups for practice as my interviewing skills were rusty. After attending many interviews for a month, it felt like the right time to apply for jobs abroad.

Why Germany or even Europe?

After much research, I was sure I wanted to explore Europe. For me EU seemed more lucrative than my second preference, US as Europe seemed to score better in what I was looking for.

To name a few,

Europe is known for better work-life balance
Health care was almost free in Europe compared to the States
Getting residence options for expats were more flexible in EU
Moving to an EU country would be a travel pass to the whole Europe

I was mainly interested in western European countries (except the UK, yeah due to Brexit). So I started looking at tech companies mainly in Germany, Netherlands and France in that order.

After few months of interviewing actively, I ended up with two offers in Germany. I decided to drop all other ongoing interviews in favour of one of the German offers as I vibed greatly with their company culture and energy.

There were a few more reasons which helped me choose Germany despite knowing you need to learn a new language to survive.

The position I chose was in Berlin. Berlin, the most racially and culturally diverse city in Germany(if not EU), had a significant English-speaking population. Moreover, learning german wasn't a criterion as the primary work language in tech would still be English.
The history, the art and the hipster vibe of Berlin seemed very, very palatable to my taste.
Germany has one of the best health and taxpayer benefits in Europe, smoother PR options, an ever-growing tech industry with most FAANG companies, and so many world-class tech startups.

After a year, was it worth it?

Before moving, I was clear about the best and worst-case scenarios. As people say, the grass is always greener on the other side; Germany looked like a vast green flag for this new chapter. But what if it was not?

Sometimes I wondered if I find it difficult to adjust in Germany or if the company wasn't a right fit.
I knew I was just one flight and at-max a few months of job search away from moving back and finding some work in India to be able to pay my bills. Reframing my thoughts and establishing a safety net or plan B helped me feel calm with anxieties and enjoy the migration process more.

Looking back a year later, I feel I could have missed out on so much life experience and learning if I had given in to the demons in my head. The ones who tell you maybe you're not prepared or not good enough to take such a giant leap.

If I could go back in time, 10/10, I'll retake the same chances.

Sailing solo and life outside work

It has been a roller coaster ride so far, but luckily, there are more ups than downs.

Work-life balance

Most European countries are very particular about work-life balance, which means you're done with your 8 hours of work by 5 pm and have the rest of the evening to yourself. That leaves you with ample time for yourself to be with friends, indulge in hobbies or maybe sit in the park and look at the river.

Quality me-time

I'll be honest, this experience has been like fresh air to me. Having enough time for myself let me be in better mental space and health. In the past months, I took a long break from social media and spent more times outdoors. Germany has beautiful parks, lakes and hiking trails where I'll often spend my lazy weekends. In other days, I would explore the city, or try out some cafes.

Inside my tiny studio, I started learning how to grow plants and not kill them for once. I also started a Twitch channel where I stream live coding sessions from time to time for fun. Also in this short span I travelled to two new countries, Hungary and Lithuania, with my budget savings.

Just in the last 12 months I realised I had read more books, walked more steps and played more hours of guitar than maybe the last decade, back home.

Take it easy - everything isn't rosy

bendmorris on Nov 9, 2016 @ HN | A man was walking along a river bank when he saw another man on the opposite side. "Hello!" he called out, "how do you get to the other side of the river?" The man called out in response, "you are on the other side of the river!"

Back in India, I had already stayed away from my hometown for university and job for nearly eight years. And being a decent cook and organised person(well, messy desks don't count), living solo as an expat was one of my most minor concerns. But I discounted the fact that you're in a country now and it can get pretty lonely sometimes.

Making friends as an adult is already hard. More so in Germany, as people are very private and respect their and others' personal spaces, making it a bit overwhelming for random talks and reaching out to someone new.

Sometimes when I go out for a walk or to the supermarket to grab some groceries, I would look around and get this alienated feeling, and all the good stuff would fade away in a moment. But then again, I learnt this was pretty normal as we are social animals, and we long for nothing more than our herd. Which I didn't have at that moment.

After the first few months, this started getting better. I joined some community of expats and got to meet some great people from Reddit groups like r/berlinsocialclub and on telegram. Absorbing a new culture, history and tradition can take years, so taking it easy is the only way.

Gratitude

I know for someone who has already done something, it's always easy to say, "well, that was very easy". But a lot of things played a crucial part in this journey.

For example, my university degree allowed me to apply to many jobs, which was a primary criterion for getting an EU BlueCard.

I'm looking at you, people of Twitter with hot takes like "don't go to college for a tech job". Well, if you are from a third-world country like me, going to college or not might be the thin line between getting a US/UE Visa or not.

Moreover, all the exposures I had from the previous high-pressure jobs I've complained about above gave me a lot of learning (and maybe reasons) which helped me prepare for this move.

Last but not the least, I feel very fortunate and grateful to be able to connect all the dots in my life so far, to travel half way around the world and live the kind of life I could only dream of a year back.

Would you like to read something more tech-focused on my preparations and move to Europe? Let me know on Twitter.

Async programming basics every JS developer should know

Siwalik Mukherjee — Thu, 14 Jun 2018 17:10:56 +0000

This article is aimed at people starting out with asynchronous coding in javascript so we would keep things simple by avoiding big words, arrow functions, template literals etc.

Callbacks are one of the most used concepts of modern functional javascript and if you've ever used jQuery, chances are you've already used callbacks without even knowing (we will get back to it in a minute).

What the Heck are Callback Functions?

A callback function in its simplest terms is a function that is passed to another function, as a parameter. The callback function then gets executed inside the function where it is passed and the final result is returned to the caller.

// I'm sure you've seen a JQuery code snippet like this at some point in your life!
// The parameter we're passing to the `click` method here is a callback function.

$("button").click(function() {
    alert('clicked on button`);
});

Simple right? Now let us implement a callback function to get scores on levelling up in an imaginary game.


    
// levelOne() is called a high-order function because
// it accepts another function as its parameter.
function levelOne(value, callback) {
    var newScore = value + 5;
    callback(newScore);
}

// Please note that it is not mandatory to reference the callback function (line #3) as callback, it is named so just for better understanding.

function startGame() {
    var currentScore = 5;
    console.log('Game Started! Current score is ' + currentScore);
        // Here the second parameter we're passing to levelOne is the
        // callback function, i.e., a function that gets passed as a parameter.
        levelOne(currentScore, function (levelOneReturnedValue) {
            console.log('Level One reached! New score is ' + levelOneReturnedValue);
        });
}

startGame();

Once inside startGame() function, we call the levelOne() function with parameters as currentScore and our callback function().

When we call levelOne() inside startGame() function's scope, in an asynchronous way, javascript executes the function levelOne() and the main thread keeps on going ahead with the remaining part of our code.

This means we can do all kind of operations like fetching data from an API, doing some math etc., everything which can be time-consuming and hence we won't be blocking our main thread for it. Once the function(levelOne()) has done with its operations, it can execute the callback function we passed earlier.

This is an immensely useful feature of functional programming as callbacks lets us handle code asynchronously without us have to wait for a response. For example, you can make an ajax call to a slow server with a callback func. and completely forget about it and continue with your remaining code. Once that ajax call gets resolved, the callback function gets executed automatically.

But Callbacks can get nasty if there are multiple levels of callbacks to be executed in a chain. Let's take the above example and add a few more levels to our game.


    
function levelOne(value, callback) {
    var newScore = value + 5;
    callback(newScore);
}

function levelTwo(value, callback) {
    var newScore = value + 10;
    callback(newScore);
}

function levelThree(value, callback) {
    var newScore = value + 30;
    callback(newScore);
}

// Note that it is not needed to reference the callback function as callback when we call levelOne(), levelTwo() or levelThree(), it can be named anything.

function startGame() {
    var currentScore = 5;
    console.log('Game Started! Current score is ' + currentScore);
    levelOne(currentScore, function (levelOneReturnedValue) {
        console.log('Level One reached! New score is ' + levelOneReturnedValue);
        levelTwo(levelOneReturnedValue, function (levelTwoReturnedValue) {
            console.log('Level Two reached! New score is ' + levelTwoReturnedValue);
            levelThree(levelTwoReturnedValue, function (levelThreeReturnedValue) {
                console.log('Level Three reached! New score is ' + levelThreeReturnedValue);
            });
        });
    });

}

startGame();

Wait, what just happened? We added two new functions for level logic, levelTwo() and levelThree(). Inside levelOne's callback(line #22), called levelTwo() function with a callback func. and levelOne's callback's result. And repeat the same thing for levelThree() function again.

Now just imagine what this code will become if we had to implement the same logic for another 10 levels. Are you already panicking? Well, I am! As the number of nested callback functions increases, it becomes tougher to read your code and even harder to debug.

This is often affectionately known as a callback hell. Is there a way out of this callback hell?

I Promise there's a better way

Javascript started supporting Promises from ES6. Promises are basically objects representing the eventual completion (or failure) of an asynchronous operation, and its resulting value.

// This is how a sample promise declaration looks like. The promise constructor
// takes one argument which is a callback with two parameters, `resolve` and
// `reject`. Do something within the callback, then call resolve if everything
// worked, otherwise call reject.

var promise = new Promise(function(resolve, reject) {
  // do a thing or twenty
  if (/* everything turned out fine */) {
    resolve("Stuff worked!");
  }
  else {
    reject(Error("It broke"));
  }
});

Let us try to rewrite our callback hell example with promises now.


    
function levelOne(value) {
    var promise, newScore = value + 5;
    return promise = new Promise(function(resolve) {
        resolve(newScore);
    });
}

function levelTwo(value) {
    var promise, newScore = value + 10;
    return promise = new Promise(function(resolve) {
        resolve(newScore);
    });
}

function levelThree(value) {
    var promise, newScore = value + 30;
    return promise = new Promise(function(resolve) {
        resolve(newScore);
    });
}

var startGame = new Promise(function (resolve, reject) {
    var currentScore = 5;
    console.log('Game Started! Current score is ' + currentScore);
    resolve(currentScore);
});

// The response from startGame is automatically passed on to the function inside the subsequent then
startGame.then(levelOne)
.then(function (result) {
    // the value of result is the returned promise from levelOne function
    console.log('You have reached Level One! New score is ' + result);
    return result;
})
.then(levelTwo).then(function (result) {
    console.log('You have reached Level Two! New score is ' + result);
    return result;
})
.then(levelThree).then(function (result) {
    console.log('You have reached Level Three! New score is ' + result);
});

We have re-wrote our level(One/Two/Three) functions to remove callbacks from the function param and instead of calling the callback function inside them, replaced with promises.

Once startGame is resolved, we can simply call a .then() method on it and handle the result. We can chain multiple promises one after another with .then() chaining.

This makes the whole code much more readable and easier to understand in terms of what is happening, and then what happens next and so on.

The deep reason why promises are often better is that they're more composable, which roughly means that combining multiple promises "just works" while combining multiple callbacks often doesn't.

Also when we have a single callback versus a single promise, it's true there's no significant difference. It's when you have a zillion callbacks versus a zillion promises that the promise-based code tends to look much nicer.

Okay, we've escaped successfully from the callback hell and made our code much readable with promises. But what if I told you there's a way to make it cleaner and more readable?

(a)Wait for it

Async- await is being supported in javascript since ECMA2017. They allow you to write promise-based code as if it were synchronous code, but without blocking the main thread. They make your asynchronous code less "clever" and more readable.

To be honest, async-awaits are nothing but syntactic sugar on top of promises but it makes asynchronous code look and behaves a little more like synchronous code, that's precisely where it's power lies.

If you use the async keyword before a function definition, you can then use await within the function. When you await a promise, the function is paused in a non-blocking way until the promise settles. If the promise fulfils, you get the value back. If the promise rejects, the rejected value is thrown.

Let us see now how our game logic looks once we rewrite it with async-awaits!


    
function levelOne(value) {
    var promise, newScore = value + 5;
    return promise = new Promise(function(resolve) {
        resolve(newScore);
    });
}

function levelTwo(value) {
    var promise, newScore = value + 10;
    return promise = new Promise(function(resolve) {
        resolve(newScore);
    });
}

function levelThree(value) {
    var promise, newScore = value + 30;
    return promise = new Promise(function(resolve) {
        resolve(newScore);
    });
}

// the async keyword tells the javascript engine that any function inside this function having the keyword await, should be treated as asynchronous code and should continue executing only once that function resolves or fails.
async function startGame() {
    var currentScore = 5;
    console.log('Game Started! Current score is ' + currentScore);
    currentScore = await levelOne(currentScore);
    console.log('You have reached Level One! New score is ' + currentScore);
    currentScore = await levelTwo(currentScore);
    console.log('You have reached Level Two! New score is ' + currentScore);
    currentScore = await levelThree(currentScore);
    console.log('You have reached Level Three! New score is ' + currentScore);
}

startGame();

Immediately our code becomes much more readable but there's more to Async-await.

Error handling is one of the top features of Async-await which stands out. Finally we can handle both synchronous and asynchronous errors with the same construct with try and catches which was a pain with promises without duplicating try-catch blocks.

The next best improvement from good old promise world is code debugging. When we write arrow function based promises, we can't set breakpoints inside our arrow functions so debugging is tough at times. But with async-awaits, debugging is just like how you would do a synchronous piece of code.

I'm sure that by now you have a better understanding of asynchronous programming in javascript. If you have a question, let me know below. If you found this helpful, give me a shoutout on Twitter!

Happy Coding! ✌️

Mastering Full-stack with Javascript's Superpowers

Siwalik Mukherjee — Sun, 18 Mar 2018 16:30:53 +0000

When I used to freelance as a full stack developer during my college, often I would find myself stuck between context switching in terms of practices and different syntaxes in javascript and php. Although I was making some good side cash and had a bunch of happy clients, the code I was writing was not great as it seemed tough to expertise on every aspect of web development at the same time.

Being a hardcore JS fan and ardent lover of interfaces, I decided to focus solely on frontend and after freelancing for a few more months, I join a startup as a frontend developer. I was content with my learnings and adventures in the frontend land... until I came across this yesterday ~

The roles required to design and develop a web solution require a deep
skill set and vast experience in the area of visual design, UI/interaction design, front-end development and back-end development.
Any person who can fill one or more of these 4 roles at a professional
level is an extremely rare commodity.

However, given that JavaScript has infiltrated all layers of a
technology stack (e.g. React, node.js, express, couchDB, gulp.js
etc...) finding a full-stack JS developer who can code the front-end
and back-end is becoming less mythical. -Frontend Handbook
'18

So I started wondering, why not? I already know frontend, I also manage to write some (crappy but) working backend code in php for my side projects, why not harness my javascript knowledge and become a full stack javascript developer, just by connecting the dots and a bit of learning?

When it comes to learning, the reason majority of our plans fail is because we don't have an action plan. And any resolution or goal without a proper plan is bound to fail! So I started there, with the planning.
[fun fact: that's the same reason why our new year resolution's fail!]

I spent the next day researching on topics and resources one needs to learn in course of this journey to be a full stack developer just by harnessing the superpowers of Javascript. So I created a to-do list which starts at the very basics of javascript and build its way up to the more advance concepts, covering all the tech stacks.

If you're a front-end developer looking forward to up your game or maybe you're already a full-stack developer and want to brush up your skills for an interview or for your next side project, I'm certain, this will be helpful to you.

I posted the list on Github which you can check it out here.

In order to stay motivated and track your progress, fork my todo list from Github and commit to your repo with crossed out items, as you progress.

git clone https://github.com/siwalikm/Prep-for-Full-Stack-JS.git

P.S. Remember: The key is to stay motivated.

If possible, start learning along with a friend and maybe build something together along the process. If you're learning alone, reach out to people if you get stuck and try to document your learnings.

You can tweet me (at @siwalik) about your learnings and adventures on this journey or just to say 'Hi'!

Best of luck to you!

What the heck is JWT anyway?

Siwalik Mukherjee — Sun, 04 Mar 2018 17:28:37 +0000

In this article we will learn the fundamentals of a JWT token is and how we can benefit from it for authenticating communications between two parties, all of this using vanilla NodeJS and javascript.

JWT is an abbreviation for JSON Web Token, which is a compact URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object that is digitally signed using JSON Web Signature (JWS). ~ IETF

Urggh! What?

Simply put, JWT token is a string we pass in the header or url while making a network request to pass data safely and make sure it hasn't been tampered with.

Example: www.example.com/private/?token=xxxxx.yyyyy.zzzzz

You might be wondering what's with the token format! JWT tokens consists of three parts separated by dots

( . )

which are:

header.payload.signature

Let's see the differents parts of a JWT token in details.

1. Header
The header typically consists of two parts: the type of the token, which is JWT, and the hashing algorithm being used, such as HMAC SHA256 or RSA.

{
   "alg": "HS256",
   "typ": "JWT"
}

Then, this JSON is Base64Url encoded to form the first part of the JWT.

'use strict';

var header = { "alg": "HS256", "typ": "JWT" };
var enc_header = Buffer.from(JSON.stringify(header)).toString('base64');
// ► "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"

2. Payload

The second part of the token is the payload, which contains the claims. Claims are predefined keys and their values. There are three types of claims: registered, public, and private claims.

Registered claims: These are a set of predefined keys which are not mandatory but recommended. Some of them are iss (issuer), exp (expiration time) etc.
Public claims: These can be defined at will by those using JWTs. But to avoid collisions they should be defined in the IANA JSON Web Token Registry or be defined as a URI that contains a collision resistant namespace.
Private claims: These are the custom key value pairs created to share information between parties that agree on using them and are neither registered or public claims.

{
   "exp": "2019-02-14",
   "message": "roses are red"
}

The payload is then Base64Url encoded to form the second part of the JSON Web Token.

'use strict';

var payload = { "exp": "2019-02-14", "message": "roses are red" };
var enc_payload = Buffer.from(JSON.stringify(payload)).toString('base64');
// ► eyJleHAiOiIyMDE5LTAyLTE0IiwibmFtZSI6IkpvaG4gRG9lIn0

3. Signature

To create the signature part you have to take the encoded header, the encoded payload, a secret, the algorithm specified in the header, and sign that. Too good for us that NodeJS comes with the immensely powerful Crypto library out of the box which we will use in our example.

'use strict';
const crypto = require('crypto');
var jwt_secret = "secret";
// enc_header and enc_payload are computed earlier
var signature = crypto.createHmac('sha256', jwt_secret).update(enc_header +"."+ enc_payload).digest('base64');
// ► 6C46KAaZGp6RjbSqGllfdQF7g8vXCp02NTSrz-PzeoI

The signature is used to verify that the sender of the JWT is who it says it is and to ensure that the message wasn't changed along the way.

The final JWT token looks like this

var token = `${enc_header}.${enc_payload}.${signature}`;
// ► eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOiIyMDE5LTAyLTE0IiwibWVzc2FnZSI6InJvc2VzIGFyZSByZWQifQ.0u-mkgLo5479CPjJJ4mXCwn2RW4dFT12fiYiopRWsZw

Something important to remember here is that JWT tokens are used for authentication and not encryption, so even without knowing the secret key, someone can read your header and payload data.

But upon receiving the token you can sign the header and payload again with your secret key and compare it with the received signature to detect tampering of token or the message.

A good place to start will be by going to this online JWT debugger at jwt.io and play around with the the token we just generated above.

Hi! I'm @Siwalik! If you liked this article, follow me on twitter to know about my latest tech expeditions and side projects! 🙌