DEV Community: saadnoor salehin

I Wore the Same Outfit for 1 year and Here is What I’ve Learned

saadnoor salehin — Sun, 23 Aug 2020 13:31:35 +0000

It started 365 days ago when I was maintaining a full-time job at Jeeon, a part-time job at Digitruck and another contractual job offered by Lex, who is a professor at Columbia University.

At Jeeon, I was doing a software engineering job, at digitruck, I was leading a team and taking care of their software infrastructure by doing the devOps related tasks and with Lex, I was helping him in his research on arsenic detection in Tube-wells, by developing some software tools and android app. And yes, I maintained all 3 jobs concurrently.

To be honest, it was very stressful for me. But I needed that, I was exploring myself, to maintain these 3 responsibilities properly, I needed to be efficient and productive. And at the top of that, I needed happiness. Soft and simple happiness.

I took one week break from all of my responsibilities and started to learn and seek happiness. I studied many theories, many stories. Among those, one simple concept has blown my mind, and that is minimalism. I will write details about my version of minimalism later, but today I want to focus on my outfit choice.

Some of the minimalism blogs I followed, almost everyone has this common. Wearing the same dress every day. At first, I found this funny. Funny and lame. Lame and pointless.

But still, so many people are following this, there can be a reason. So I decided to give it a try. I bought 13 different grey t-shirts, 5 black pants and 2 black shoes, initially I committed to a 30-day experiment.

I am writing this post after 365 days of this experiment, and I am still wearing the same dress every day. Here's why.

Motivation to be consistent

Consistency is key to achieve something, we know that. But being consistent isn’t so easy. At least for me. Wearing the same dress every day is a consistent process. By wearing the same dress, I can start my day by ‘being consistent’. It motivates me throughout the day to maintain the other consistent tasks I am doing to achieve my goals.

Comfort in decision making

It is the most popular theory. I read it before this experiment and didn’t give a shit back then. But after this experiment, I really felt that. At the end of 150 days, I made at least 300 fewer decisions. I didn’t have to bother about what I would wear for office and what for a date. It’s a simple grey shirt and a black pant, that’s it.

Less stress

I remember, during my first days of this experiment, I had to give a presentation at a conference at IUB. I was very confused at first - what to wear? Am I becoming more formal? or more casual? Do I look okay? Etc etc. Later I decided to give the presentation with my iconic dress and I didn’t feel anything about it at all. Having said that, the same outfit every day definitely reduces your stress because you are confident enough about this.

People actually don’t care

It was my greatest misconception, “people are thinking about my dress”. To be honest, everyone has their own problem to solve, as long as your dress is decent, people won’t notice this at all. And even if someone cares, I don’t have to impress him by my dress 😛
Not spending unnecessary money on clothing
Well, I didn’t think about this benefit at the beginning, but I found the discounts in the brand shops don’t attract me anymore. I don’t feel tempted to buy clothes anymore. That helps me practice minimalism easily.

Being More Organised

Before this experiment, I used to wear whatever I found in front of me. And most of the time I couldn’t get anything. It was too unorganised and messy back then. But now, I know where my 13 t-shirts are, I wash them in every 2 weeks, and keep them clean and organised. It adds a layer of satisfaction in my daily life.

There are many more benefits actually, I couldn’t express properly how this simple lifestyle added happiness and efficiency in my life. This is something you won’t understand unless you try it for at least 30 days.

GCC vs. Clang: How to use bits/stdc++ header in MacOS

saadnoor salehin — Tue, 18 Aug 2020 14:43:01 +0000

GCC vs CLANG: how to include bits/stdc++.h

For compiling c++, there are many compilers in the market, but 3 of them are very popular.

Visual C++
GNU Compiler Collection (GCC)
Clang

Among them, Visual C++ was developed by Microsoft, and they don’t support other platforms like Linux. (Typical Microsoft 😛).

GNU was a project, started by Richard Stallman in 1984, which eventually produced many popular open-source software tools like Make, Sed, Emacs. GCC was one of them. GCC was used by all UNIX based OS. Apple also used it for macOS. But over time, Apple wanted to add many features to C++ for their own requirements which weren’t accepted well by GNU developers. So Apple engineers made a separate branch for their own version of c++ compiler, which is eventually called CLANG.

And that’s why some features we get GCC but not in CLANG. Most competitive programmers, use include<bits/stdc++.h to include all possible header files that might be needed for writing that program. But if we are using macOS, it can’t recognise include<bits/stdc++.h.

To solve this problem,

open finder then click Go to folder
paste this address /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1/
Create a new folder name bits
inside bits create a new file named stdc++.h. To create a file open terminal and inside that folder and type touch stdc++.h
paste the code written below inside that file.

/** @file stdc++.h
 *  This is an implementation file for a precompiled header.
  */


using namespace std;


  // 17.4.1.2 Headers

  // C
  #ifndef _GLIBCXX_NO_ASSERT
  #include <cassert>
  #endif
  #include <cctype>
  #include <cerrno>
  #include <cfloat>
  #include <ciso646>
  #include <climits>
  #include <clocale>
  #include <cmath>
  #include <csetjmp>
  #include <csignal>
  #include <cstdarg>
  #include <cstddef>
  #include <cstdio>
  #include <cstdlib>
  #include <cstring>
  #include <ctime>

  #if __cplusplus >= 201103L
  #include <ccomplex>
  #include <cfenv>
  #include <cinttypes>
  #include <cstdbool>
  #include <cstdint>
  #include <ctgmath>
  #include <cwchar>
  #include <cwctype>
  #endif

  // C++
  #include <algorithm>
  #include <bitset>
  #include <complex>
  #include <deque>
  #include <exception>
  #include <fstream>
  #include <functional>
  #include <iomanip>
  #include <ios>
  #include <iosfwd>
  #include <iostream>
  #include <istream>
  #include <iterator>
  #include <limits>
  #include <list>
  #include <locale>
  #include <map>
  #include <memory>
  #include <new>
  #include <numeric>
  #include <ostream>
  #include <queue>
  #include <set>
  #include <sstream>
  #include <stack>
  #include <stdexcept>
  #include <streambuf>
  #include <string>
  #include <typeinfo>
  #include <utility>
  #include <valarray>
  #include <vector>

  #if __cplusplus >= 201103L
  #include <array>
  #include <atomic>
  #include <chrono>
  #include <condition_variable>
  #include <forward_list>
  #include <future>
  #include <initializer_list>
  #include <mutex>
  #include <random>
  #include <ratio>
  #include <regex>
  #include <scoped_allocator>
  #include <system_error>
  #include <thread>
  #include <tuple>
  #include <typeindex>
  #include <type_traits>
  #include <unordered_map>
  #include <unordered_set>
  #endif

save and exit. After that it will work fine.

originally published in https://saadnoor.com/gcc-vs-clang-how-to-include-bitsstdc-in-mac/

Coding Interview Question: Kadane algorithm(maximum subarray sum) explained in 3 min

saadnoor salehin — Tue, 11 Aug 2020 20:33:53 +0000

Problem: We have to find the maximum subarray sum.

Eg: Lets consider this array ⇒ [-10, 5, -9, 1, 3, -2, 3, 4, 7, 2, -9, 6, 3, 1, -5, -4], the answer for maximum subarray sum is 19. (1, 3, -2, 3, 4, 7, 2, -9, 6, 3, 1)

Solution ⇒ Naive approach, brute-force. Generate all the arrays and get the maximum sum.

From this, we can generate subarrays like,

-10

-10, 5

-10, 5, 9

-10, 5, 9, 1

-10, 5, 9, 1 , 3

...

5, 9

5, 9, 1

5, 9, 1, 3

5, 9, 1, 3, 2

...

We can generate all the subarrays and take the maximum sum, in that case, our code will look like

// n*n solution
#include <vector>
using namespace std;

int notKadanesAlgorithm(vector<int> array) {
    int n = array.size();
    vector<int> sum;
    int res = INT_MIN;

    //Cumulative Sum
    sum.push_back(array[0]);
    for(int i = 1; i < n; i++)sum.push_back(sum[i-1] + array[i]);

    // Generate every pair and take maximum.
    for(int i = 0; i < n; i++) {
        for(int j = i; j < n; j++  ) {
            res = max(res, sum[j]-sum[i - 1]);
        }
    }
  return res;
}

But this has a complexity of O(n^2) we can reduce it to O(n) if we use Kadane's algorithm. Which uses dynamic programming. While traversing the array, we can keep track of what was the maximum number, if the array was ended here.

for example, if our array is [-1, 2, 3, -4], we can generate another array which ith position will hold the maximum value if the array was ended here. We'll get [-1, 2, 5, 1 ]
. Let me explain how.

In any place, we have either 2 choices. Either we can add the current array item in our sum, or we can start a new array from here.

When i = 0, our maxEndingHere[0] = -1 ⇒ we don't have any option but taking the first element.

then i = 1, we get 2 as the current value of the array. Now we have 2 choices:

We can consider the subarray ends here (index 1, having value 2). The subarray is [-1, 2], in that case, we can get our maximum subarray sum -1+2=-1
We can consider a new subarray starts from here. The subarray is [2], resulting in maximum subarray sum = 2

as the second option results maximum value, we will go with it. So, maxEndingHere[1] = 2

After that when i = 2, we get the maximum subarray sum if we take 3, is 5, or we can start a subarray from here, which will give us 3. So our maxEndingHere[2] = 5

and finally, in the same procedure, we can get maxEndingHere[3] = 1( max( (5 -4), -4)))

So our resulted maxEndingHere array is ⇒ [-1, 2, 5, 1 ]

we can find the maximum number of this array, which is the result, for this example, 5.

Our code will look like this:

#include <vector>
using namespace std;

int kadanesAlgorithm(vector<int> array) {
    vector<int>maxEndHere;
    if(array.size()>0)maxEndHere.push_back(array[0]);

    for(int i = 1; i < array.size(); i++){
        int here = max(maxEndHere[i-1]+array[i], array[i]);
        maxEndHere.push_back(   here );
    }

// Finding the maximum array in this vector 
    return *max_element(maxEndHere.begin(), maxEndHere.end());
}

Now it runs on O(n) but space complexity is still O(n) which we can reduce to O(1) but not storing the whole array into maxEndHere. We can just declare an integer and keep the maximum value in it while traversing the array. But this task is for you to do. 😇

Server Side Rendering Visualized

saadnoor salehin — Tue, 28 Jul 2020 15:09:34 +0000

Lets take a look, nowadays, how a modern web app is displayed in browser. A typical response sent by an Angular app looks like this,

A bare , poor and sad HTML file

<!doctype html>
<html lang="en">
<head>
   <title>Angular</title>
   <base href="/">
   <meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
   <app-root></app-root>

<script type="text/javascript" src="inline.f481c2f5e1589433c6b6.bundle.js"></script>
<script type="text/javascript" src="polyfills.8135eb80f6191ae1578b.bundle.js"></script>
<script type="text/javascript" src="main.7dd036568b70b6284d5d.bundle.js"></script>    

</body>
</html>

A rich main.js file, which is the life for that app.

Browsers take this main.js file and parse and render our app, it makes that bare HTML meaningful. But what if, user disables Javascript on his browser?

Well, he will see this - an empty and dead page -

but wait? Seriously? Somebody will disable Javascript in their browser at 2020? Who is that dumb?

well, search engine crawlers are dumb. They will. When they want to index our webpage for search results, they will find a plain old HTML file who has nothing, and a big main.js file for which they don't have any time or respect. When they see that javascript file is too big to parse, they will ignore it. So our Angular app perform poorly in terms of SEO.

What's the solution?

we can use a quick 3rd party-based solution, prerender.io . It checks the person who requested your webpage, is a bot or human? If it's a human, it sends the regular response - a plain HTML with a main.js file. But if it's a bot, prerender.io opens a browser in itself, renders the app there and then sends the contentful html files.

So the SEO problem can be solved. But-

It's not a good way
There are more problems to solve, the first meaningful paint problem

First meaningful paint measures when the primary content of a page is visible to the user. In the picture bellow we can see user had to wait for 8 seconds to see anything meaningful.

A big portion of this 8 seconds time used to -

Download that main.js file, if the user's internet is slow - this time will increase.
Parse and render that main.js file.

And the user didn't see anything meaningful in the screen, recent study shows that user leaves any webpage that takes more than 3 seconds to load.

Server-side rendering solves both problems. Instead of sending the dead blank HTML file, it renders our app in the server ( blessings of Node.js) and sends the HTML to the browser. Now the user doesn't have to wait for downloading that big main.js file. It can show the server-rendered HTML immediately. So the user will able see some meaningful content very fast.

Now let's see how this SSR works:

The client makes a GET request to the server for the webpage
The server parses and renders a HTML file immediately
The client shows this HTML to the user, the user sees a meaningful content but app isn't ready yet
The server also sends the angular/react app (that main.js file)
Client downloads that file in and loads our app background
Once everything is ready client-side, it seamlessly switches from showing the server-rendered pages to the client-side app. The server gives control to the client when it's ready.

As meaningful HTML is served to the user immediately, So first meaningful paint time improves significantly with SSR.

In the next post, we will learn how to implement Server Side Rendering with Angular, stay tuned.

(This post was originally published at https://saadnoor.com/server-side-rendering-visualized/ )

Introduction To Unit Test in .NET Core Applications By Xunit And Moq

saadnoor salehin — Wed, 20 May 2020 05:40:10 +0000

Let’s assume, I have written some introductory sentences about what is unit testing and why it’s important. Let’s jump into main topic directly.

For writing unit test in .NET core applications we have some libraries like MSTest, NUnit , Xunit. In this post, I will be discussing about Xunit. For getting started, open your IDE and create a solution named HelloWorldUnitTest and add 2 projects, PrimeDetector and PrimeDetectorTest

Now, we’ll write a function first, and then write unit test by using xunit. Lets start by writing the function, Lets add a class in PrimeDetector project named PrimeDetectorModel.cs

    public class PrimeDetectorModel
    {
        public bool IsPrime(int n)
        {
            var isPrime = true;

            for (int i = 2; i < Math.Sqrt(n); i++)
            {
                if (n % i == 0) isPrime = false;
            }

            return isPrime;
        }

    }

Now we'll write unit test for the isPrime()method. Let's add a class named PrimeDetectorTest.cs in the PrimeDetectorTest project.

public class PrimeDetectorTest
{
    [Fact]
        public void Test_If_It_Can_Detect_A_Prime_Number()
        {
           // Arrange
            var primeDetector = new PrimeDetectorModel();

            // Act
            var isPrime = primeDetector.IsPrime(29);

            // Assert
            Assert.Equal(isPrime, true);
        } 
}

What's happening here?

With the [Fact]attribute, xUnit.net test runner identifies it's a unit test to execute. Here, we will test whether our isPrime() identify a prime number or not.
Every unit test has 3 parts:

Arrange: this portion will have code required to setup the test, in above example we need an instance of PrimeDetectorModel to call our isPrime() method.
Act: In this portion, we'll call the function which we want to test. Eg: here we called IsPrime() with a prime number
Assert: this portion will responsible to judge whether our expectations were met or not. Eg: here, we checked value of isPrime is true or not.

How can we run this test multiple times with different input?

The above example tests whether our isPrime()method works for 29 or not. Now we want to test it for more integers, let's say for 2, 5, 7, 19 and 23. Instead of copying and pasting the previous test function for 5 times, we can take advantage of [Theory] attribute. Our test function will now look like

    [Theory]
        [InlineData(2)]
        [InlineData(5)]
        [InlineData(19)]
        [InlineData(23)]
        public void Test_If_It_Can_Detect_Non_Prime_Numbers(int n)
        {


            // Arrange
            var primeDetector = new PrimeDetectorModel();

            // Act
            var isPrime = primeDetector.IsPrime(n);

            // Assert
            Assert.Equal(isPrime, true);
        }

If we run this test, we will see our test function ran 4 times with the values we have given with [InlineData(n)] attribute.

[Theory] attribute denotes a parameterised test, and by the help of the [InlineData] we provide the values for the parameter.

Summary: When we need to run the test once, we don't need any parameter to be passed through the test function, we'll use [Fact] attribute, otherwise we'll use [Theory] attribute.

There are some limitations with [InlineData] attribute, it works with only constants. What if we need to send an object as a parameter?

Let's add a PersonModel Class in PrimeDetector project.

 public class PersonModel
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

Now add HasPrimeId() method, bellow the isPrime() method. It will take an object of PersonModel and check whether the Id property is Prime or not.

        public bool HasPrimeId(PersonModel person)
        {
            return IsPrime(person.Id);
        }

Now, we'll write unit test for it. Go to the PrimeDetectorTest file and add this chunk of code.

    public static IEnumerable<object[]> GetTestData()
    {
        yield return new object[] { new PersonModel { Id = 5, Name = "Saadnoor" } };
        yield return new object[] { new PersonModel { Id = 7, Name = "Salehin" } };
    }

    [Theory]
    [MemberData(nameof(GetTestData))]
    public void Test_If_It_Can_Detect_Person_Has_Prime_Id_Or_Not(PersonModel person)
    {

        // Arrange
        var primeDetector = new PrimeDetectorModel();

        // Act
        var hasPrimeId = primeDetector.HasPrimeId(person);

        // Assert
        Assert.Equal(hasPrimeId, true);
    }

It will call the test function Test_If_It_Can_Detect_Person_Has_Prime_Id_Or_Not() two times with 2 different PersonModel object.

{ Id = 5, Name = "Saadnoor" }
{ Id = 7, Name = "Salehin" } Note that, we have to set the return type of the GetTestData() method as IEnumerable<object[]> otherwise xUnit will throw an error. If we need 2 or more parameters in our test function, we can do that by adding it to the object[] array.

We can provide data with [ClassData] attribute also, but I'm skipping it in this post, to keep the post short and simple.

Now what if we have some dependencies to initiate our PrimeDetectorModel? How will we test it?

Moq will save us here. Let's assume, to initiate PrimeDetectorModel we have a dependency of PositiveDetectorModel (which helps us to determine whether a number is positive or not).

Our PrimeDetectorModel class will now look like:

    public class PrimeDetectorModel
    {
        public PositiveDetector positiveDetector { get; set; }

        public PrimeDetectorModel(PositiveDetector positiveDetector)
        {
            this.positiveDetector = positiveDetector;
        }

        public bool IsPrime(int n)
        {
            if (!positiveDetector.IsNumberPositive(n)) throw new Exception("Invalid Input");

            var isPrime = true;

            for (int i = 2; i < Math.Sqrt(n); i++)
            {
                if (n % i == 0) isPrime = false;
            }

            return isPrime;
        }

        public bool HasPrimeId(PersonModel person)
        {
            return IsPrime(person.Id);
        }
    }

Now our isPrime() function checks whether the given number is positive or not, if the number isn't positive, it throws an Exception.
It takes help from IsNumberPositive method, which comes from PositiveDetector model.

Now, while writing the test, we will create a mock of PositiveDetectorModel, and we are not bothered with isNumberPositive() method of this class, as we are writing unit test for isPrime() method, we'll assume that, isNumberPositive works properly, we'll mock it's result too. Our test function is now looks like this.

        [Theory]
        [InlineData(2)]
        [InlineData(5)]
        [InlineData(19)]
        [InlineData(23)]
        public void Test_If_It_Can_Detect_Non_Prime_Numbers(int n)
        {
            // Arrange
            var positiveDetectorMock = new Mock<PositiveDetector>();

            var primeDetector = new PrimeDetectorModel(
            positiveDetectorMock.Object
            );

            positiveDetectorMock
            .Setup(pd => pd.IsNumberPositive(n)).Returns(true);

            // Act
            var isPrime = primeDetector.IsPrime(n);

            // Assert
            Assert.Equal(isPrime, true);
        }

Here, all the inputs (2, 5, 19, 23) are positive numbers, so we are mocking the isNumberPositive() function by returning true for these input.

 positiveDetectorMock
            .Setup(pd => pd.IsNumberPositive(n)).Returns(true);

That's pretty much covers the basic of writing unit tests with xUnit and Moq, for more details you can go to the resources of the reference section, unfortunately xUnit's documentation sucks. Let me know if you have any feedback regarding this post by comments.

All my codes used here will be found here - https://github.com/saadnoor/UnitTestWithXunit

References:

All You Need to Know About Browser's User Agent String

saadnoor salehin — Fri, 08 May 2020 04:45:31 +0000

At Cefalo, I needed to develop a feature which required me to detect browser first. I thought it was easy - I would get it from the user agent string. But from my current browser, Chrome, what I found was

Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_1) 
AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36

Wait wait wait. What the hell? I was expecting only Chrome but why these extra confusing words with chrome?

Mozilla: Immediately comes Mozilla Firefox on our mind. Mozilla is a software community that was founded by the members of Netscape, they now maintain Mozilla Firefox which is one of most popular browsers. But why it's here?

WebKit: The rendering engine which is used by Safari. Though Chrome started with Webkit, but they now uses Blink (which was built based on Webkit though), Where is Blink in this string?

KHTML: It was the rendering engine for Konqueror browser. Webkit was based on KHTML. Why it is even here?

Gecko: The rendering engine for Firefox. But why they have to write like Gecko? is it a joke?

Chrome: I can understand.

Safari: Again, what the hell?

To understand what's going on, lets start from what is browser's user agent?

It's a string to identify which browser is being used by client, which OS it is, which version etc. Generally this string passed by HTTP headers. Many websites customize their experience based on that. Eg: When you are going to download a software, based on your OS it gives you the correct software automatically.

Generally, it has a format like this.

Mozilla/[version] ([system and browser information]) [platform] ([platform details]) [extensions]

But at the early days, it was very simple, Mosaic/0.9, it is the user agent string for Mosaic, which is the first web browser. After some time, Netscape Navigator came into the field, they designed their user agent like Mozilla/2.02 [en] (WinNT; N) which means, Mozilla( interestingly the named it as "Mosaic Killer"!) version 2.02, having English language and Windows NT as a platform with No encryption.

But things started getting dirty after Internet Explorer entered in the community. When IE came to the market, Netscape was the dominant browser. At that time, many servers checked whether it's Netscape or not, before serving their contents. Most probably, they thought it would add some extra layer of security. But this created problem for Internet Explorer.

They are new to market, they have to compete with Netscape
If they can't give support for some websites (who checks whether it is Netscape or not first), then their adoption rate will be slower. Some people won't use it.

So they decided to trick the server. They designed their user agent like this

 Mozilla/2.0 (compatible; MSIE Version; Operating System)
//Example
 Mozilla/2.0 (compatible; MSIE 3.03; Windows 95

Above example indicates, Mozilla 2.0 compatible Microsoft Internet Explorer of version 3.03 in windows 95 platform.

So the websites that checked for Netscape (eg: Checking whether Mozilla is included in User Agent string, will also serve contents to Internet Explorer now. That's how keyword Mozilla is now present most of the browsers' user agent string.

And as new browsers came in the market, this dirty trick continued. That's why some user string has like Gecko to substring in it. Just to bypass the filter some popular website was using to serve their content to Gecko engines. Google Chrome just uses all the string for apple's safari + extra string for chrome version. So the servers serve content to Safari, will also serve content to Chrome.

Now how can we get the browser's user agent programmatically?

In angular, you can get user agent by

const userAgent = window.navigator.userAgent;
console.log(userAgent);
// Prints Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36

Now how to detect browser from this user agent? There is no clean way to do this. The bellow table collected from here gives us some idea how to do it with the help of regular expressions.

But obviously we'll not reinventing the wheel. There is a beautiful library, UAParser.js, that does this tedious work for us.

Just type npm i ua-parser-js and you will get the browser by getBrowser() method, as simple as that.

Does this post cover "all" about user agent string? Obviously no. I lied, just like Chrome lies to the servers.

References

Iterm2 Alternative for Windows

saadnoor salehin — Sun, 26 Apr 2020 19:55:30 +0000

For a long time, I used macOS for software development. I used Iterm2 as my terminal. The most important use case was to split my screen with multiple terminal windows.

But after shifting to windows again, I noticed that, split screen feature isn't available to windows terminal, powershell and git-bash. I started to use git-bash and was looking for other alternatives, which has this split screen feature. After some reseach I found Hyper and Cmder. Among them I liked Hyper more, because of it's interface design and more flexibility.

By default, it will use default termnial, but if you want to use git bash -

Download, Install and Open Hyper (https://hyper.is/)
Press Ctrl + ,, a text file will be opened in your default text-editor.
Update the value of shell by 'C:\\Program Files\\Git\\git-cmd.exe' and shellArgs by ['--command=usr/bin/bash.exe', '-l', '-i'] c After that it will look like:

shell: 'C:\\Program Files\\Git\\git-cmd.exe',
// for setting shell arguments (i.e. for using interactive shellArgs: `['-i']`)
// by default `['--login']` will be used
shellArgs: ['--command=usr/bin/bash.exe', '-l', '-i'],

Now save the configuration and open a new tab(Ctrl+Shift+D). You will see, new tab opened vertically.

DONE!

Enjoy your terminal!

Groovy 101: How To Create Custom Gradle Tasks In Android Studio

saadnoor salehin — Sat, 16 Nov 2019 18:41:31 +0000

For automating the build process, Android Studio uses Gradle, which is a build tool. Gradle uses Groovy-based DSL (Domain Specific Language) and Groovy is a powerful scripting language for Java platform.

Well, in summary, we need a little bit of familiarity with Groovy to work with Gradle. In this blog post, we will learn some hello world type Groovy, and then we will learn how to write custom tasks in Gradle with Groovy.

Variable Declaration:

def str = "hello world" yes, as simple as that.
Similarly we can declare lists and maps also,

def nameOfList = []
def nameOfMap = [:]

Loops

Loops are very interesting, start.upto(end), that’s it.

Eg:

1.upto(5) {
 println "$it"
}

Output:

For iterating through lists and map, we can use every keyword.
Eg:

nameOfList.each { item ->
    println element
}

Closures

In simple term, a block of code that acts like a function. This function can be assigned to a variable.

A closure in Groovy is an open, anonymous, block of code that can take arguments, return a value and be assigned to a variable.

We will understand closure by running an example. Lets open android studio to play with Groovy. After opening the android studio, go to tools -> groovy console.

Type this code:

void doSomething(Closure closure) {
    closure.call()
}

doSomething {
    print “DID SOMETHING”
}

Then run it, for running it click the green run button

Are these codes seems familiar? Your build.gradle file is full of these codes. Eg:

dataBinding {
    enabled = true
}
testOptions {
    animationsDisabled = true
}

Now we will write a task in our build.gradle file, the task is to make a list of 10 numbers, (from 1 to 10), then print the list.

At the end of your app/build.gradle file, add this code:

task myFirstTask { task ->
    def list = []
    doFirst {
        1.upto(10){ val->
            list.add(val)
        }
    }
    doLast {
        list.each { item ->
            println(item)
        }
    }
}

Code explains everything, still - myFirstTask is the task name, and into that we are defining our task.
doFirst and doLast is the syntax of Gradle to differentiate which portion will run first and which one will run last.

Now for executing this, in the terminal navigate to the project folder. and type:
./gradlew myFirstTask
If everything alright, you will see in your console:

> Task :app:myFirstTask
1
2
3
4
5
6
7
8
9
10
BUILD SUCCESSFUL in 4s
1 actionable task: 1 executed

Okay, pretty boring , right?
Now let's do some interesting stuffs. I don’t like the name “app-debug.apk" every-time I build the project, and I am too lazy to navigate some subfolders to get this apk file, I want it in my desktop folder. Here is how, I will write the task.

task getDebugAppInDesktopFolder(dependsOn: 'assembleDebug') {
    doLast{
        def destination = "/Users/saadnoorsalehin/Desktop"
        def desiredName = "my-given-name"
        ext.apk = file("build/outputs/apk/debug/app-debug.apk")

        if (ext.apk.exists()) {
            copy {
                from ext.apk.absolutePath
                into destination
                rename { desiredName }
            }
        }
    }
}

In the above code, the keyword dependsOn specify the dependencies tasks,
getDebugAppInDesktopFolder will require the execution of assembleDebug (the default task which will generate our debug apk) .

After running ./gradlew getDebugAppInDesktopFolder you will see your desired apk file in your desktop folder.

Thanks for reading, Groovy and Gradle both are very vast topic, it is impossible to make everything clear in a single blog post, but I hope you have gotten an idea how things work and how to play with them. If you have any query or feedback regarding this reach me at saadnoors9@gmail.com