Demystifying Thunks and Currying — some of the most important functional programming concepts in JavaScript!

I’m quite sure the first time you heard of terms like thunks or currying in programming, your reaction would have been something similar to this:

Well, don’t worry, I felt the same way when I heard about these terms the first time, especially from the programming aspect, until I realized how useful they are!

Before we start, this blog post assumes that you have a basic knowledge of JavaScript and asynchronous programming using Promises and callbacks. Some knowledge about functional programming in JavaScript would also be quite helpful to understand both these concepts better. Thunks, along with currying, are quite useful concepts when it comes to functional programming in JavaScript.

Let’s dive deeper into these concepts and understand what they are, and how we can use them!

All about thunks in JavaScript

We have been using callbacks in JavaScript almost everywhere for various use cases like asynchronous programming, listening to events, handling errors, and much more. Thunks basically extend the capabilities of callbacks and are quite useful when it comes to async programming in JavaScript, though they are still quite useful in certain scenarios involving synchronous programming.

What is a thunk?

A thunk is just a function that delays the computation of a value or some logic.

The word “thunk” is a programming term that means “a piece of code that does some delayed work”.

Rather than executing some logic now, we can write a function body or code that can be used to perform the work later. Many of you working with React probably know an awesome and plain simple library called redux-thunk which, as the name suggests, is based on thunks, and is useful while doing state management using Redux.

There are two perspectives in which you can use thunks: synchronous, and asynchronous.

Synchronous way of using thunks

Let’s talk about how you can use a synchronous thunk,

const power = (base, exponent) => {
  return Math.pow(base, exponent);
};

// `power` function is evaluated
// and the result is returned immediately
console.log(power(99, 9)); // 913517247483640800

// This is a thunk
const powerThunk = () => {
  return power(99, 9);
};

// Returns the same result as calling the `power` function
console.log(powerThunk()); // 913517247483640800

The above code snippet power is a simple function that calculates the power of a number and returns the calculated value immediately. powerThunk is a synchronous thunk that delays this result until we call it. As you might have noticed, powerThunk uses the power function internally to calculate and return the calculated value.

The important part is that this thunk has become a wrapper around some particular state. In this case, it is a result of a potentially expensive operation. This pattern allows us to hide the internal details of the computation similar to the principle of Encapsulation of the Object-Oriented Programming paradigm.

Now let’s talk about how you can use thunks from the async programming perspective.

Async thunks

So how can we describe an async thunk? It’s just a simple function that doesn’t need any additional parameters except for a callback function. In the case of async thunks, we can introduce a delay to process a synchronous function like the power function from the previous example or use it to handle asynchronous API calls.

Let’s have a look at both cases. We can modify the previous example for synchronous thunk to understand this better.

const powerAsync = (base, exponent, callback) => {
  return setTimeout(() => callback(Math.pow(base, exponent)), 1000);
};

// This is an async thunk
const powerAsyncThunk = (callback) => {
  return function () {
    powerAsync(99, 9, callback);
  };
};

// This async thunk now returns a function that 
// can be called later on to calculate power.
const calculatePower = powerAsyncThunk((result) => console.log(result));
calculatePower();

In the above code snippet, we modified the power function to powerAsync function that fakes an asynchronous function using setTimeout and takes an additional parameter callback. Now, our async thunk powerAsyncThunk delays the execution of powerAsync function by returning a function. This makes it really useful as we can now just call this function returned by powerAsyncThunk whenever we want in our code later on.

Now, let’s talk about how we can deal with asynchronous API calls using async thunks.

const fetchCurrenciesData = (callback) => {
  fetch("https://cdn.jsdelivr.net/gh/fawazahmed0/currency-api@1/latest/currencies.json")
  .then(res => res.json())
  .then(res => callback(res));
}

// This is an async thunk
const asyncThunk = (callback) => {
  return function () {
    fetchCurrenciesData(callback);
  }
}

// This async thunk now returns a function that 
// can be called later on to fetch data from the API.
const fetchCurrencies = asyncThunk((res) => console.log(res));
fetchCurrencies();

The fetchCurrenciesData function makes an API call to fetch all the currencies of different countries and also takes a callback function as a parameter. The async thunk asyncThunk returns a function that can be called later on to fetch the data from the API whenever we want in our code.

The data after calling fetchCurrencies function looks something like this:

{
aave: "Aave"
ada: "Cardano"
aed: "United Arab Emirates Dirham"
afn: "Afghan afghani"
algo: "Algorand"
doge: "Dogecoin"
dop: "Dominican peso"
dot: "Dotcoin"
dzd: "Algerian dinar"
egld: "Elrond"
egp: "Egyptian pound"
enj: "Enjin Coin"
eos: "EOS"
ern: "Eritrean nakfa"
etb: "Ethiopian birr"
ils: "Israeli New Shekel"
imp: "CoinIMP"
inj: "Injective"
inr: "Indian rupee"
iqd: "Iraqi dinar"
irr: "Iranian rial"
isk: "Icelandic króna"
jep: "Jersey Pound"
jmd: "Jamaican dollar"
jod: "Jordanian dinar"
jpy: "Japanese yen"
kava: "Kava"
kcs: "Kucoin"
kda: "Kadena"
kes: "Kenyan shilling"
...
} 

Where exactly are thunks used? 💡

Now that you have learned quite a lot about thunks, you might be wondering where exactly are thunks used.

• Promises in JavaScript are based on the concept of thunks and under the hood, it uses thunks. Have a look at this video which talks about how thunks can be used to sequence async function calls.
• The redux-thunk middleware widely uses thunks internally. This enables us to use thunks with async logic inside, that can interact with a Redux store’s dispatch and getState methods for React apps using Redux for state management.

All about Currying in JavaScript

Let’s look at another quite useful concept within functional programming in JavaScript.

Currying is an advanced technique for working with functions. It’s used not only in JavaScript but in other languages as well!

What is Currying?

Currying is a transformation of functions that converts a function from callable as f(a, b, c) into callable as f(a)(b)(c).

We are transforming the function by breaking it down in such a way that it can be called in a step-by-step manner instead of calling it with all the arguments immediately. This technique is very useful, particularly when you don’t have access to all the required parameters at an instant to be able to execute the logic inside your function.

Let’s look at an example to understand this better. Suppose, we create a simple function multiplyTwoNos that multiplies two nos and returns the calculated value.

const multiplyTwoNos = (no1, no2) => {
  return no1 * no2;
};

console.log(multiplyTwoNos(3, 5)); // 15

// A curried function to multiple two nos
const curriedMultiplyTwoNos = function (no1) {
  return function (no2) {
    return no1 * no2;
  };
};

console.log(curriedMultiplyTwoNos(3)(5)); // 15

In the above code snippet, curriedMultiplyTwoNos is a function that uses currying to transform multiplyTwoNos(3, 5) function call into a function call something like this - curriedMultiplyTwoNos(3)(5). The output is basically the same, but currying gives us more flexibility to calculate the multiplication of two numbers whenever we have access to both numbers.

Advanced Currying Implementation

Now, let’s have a look at a bit more advanced implementation of currying for multi-argument functions. We’ll first create a generic currying function and then use the above example of multiplying some numbers and getting the calculated value.

// A function that takes a callback function `func` 
// that defines the kind of operation that will be curried.

const curry = function (func) {
  return function curried (...args) {
    // Ensure that we apply the operation defined by `func` 
    // with the max number of arguments supported by `func`.

    if(args.length >= func.length) {
      return func.apply(this, args);
    } else {
      // If number of parameters are insufficient to call `func` to 
      // perform the operation, recursively call `curried` with previously passed
      // parameters as well as new parameters. 
      return function (...args2) {
        return curried.apply(this, args.concat(args2));
      }
    }
  }
}

There are a lot of things happening in the above code! 😅

But, don’t get overwhelmed by seeing the above code, it’s actually quite straightforward! Let’s see how it works with an example and then we’ll understand it properly.

const multiplyThreeNos = (no1, no2, no3) => {
  return no1 * no2 * no3;
};

let curriedMultiplication = curry(multiplyThreeNos);

console.log(curriedMultiplication(4, 5, 6)); // 120, still callable normally
console.log(curriedMultiplication(4)(5, 6)); // 120, currying of 1st arg
console.log(curriedMultiplication(4)(5)(6)); // 120, full currying

The result of curry(func) call is the wrapper curried that looks like this:

function curried(...args) {
    // Ensure that we apply the operation defined by `func`
    // with the max number of arguments supported by `func`.

    if (args.length >= func.length) {
      return func.apply(this, args);
    } else {
      // If number of parameters are insufficient to call `func` to
      // perform the operation, recursively call `curried` with previously passed
      // parameters as well as new parameters.
      return function (...args2) {
        return curried.apply(this, args.concat(args2));
      };
    }
  };

In the above code, we are using some of the concepts like rest parameters, Recursions, and .apply().

There are basically two branches of code out of which one of them could get executed within the curried function because of the if statement.

• If the number of arguments passed to curried is greater than or equal to the no of arguments defined for func, then just pass the call to func.apply(this, args); which will execute ignore the extra arguments passed if any.
• Else if the no of arguments passed to curried is less, then we recursively call curried with previously passed arguments as well as the new arguments by using the .concat() method until the number of arguments for curried is not sufficient as per the definition of func.

Note: Currying requires the function to have a fixed number of arguments. A function that uses rest parameters, such as f(...args), can't be curried this way as implemented above.

When and Why to use Currying? 💡

Currying can be useful for:

• Currying can be used when you want to create a function that will receive only single arguments or will receive arguments later on in your code.
• It can be used to trigger event listeners.

Let’s look at some of the reasons why you may need to use Currying:

• Currying provides a way to make sure that your function receives all the arguments before you proceed with executing the core logic of your function.
• It divides your function into multiple smaller functions that can handle one responsibility. This makes your function pure and less prone to errors and side effects.
• It is used in the functional programming paradigm to create higher-order functions.

Conclusion

In this blog, we learned about thunks and currying, some of the most useful yet a bit advanced concepts of functional programming in JavaScript. We talked about thunks in detail like what are thunks, how can you use them, when to use them, and where are they used. Similarly, we learned about currying, how to implement currying, advanced implementation of currying, and when to use it.

That’s it from me folks, thank you so much for reading this blog! 🙌
I hope this blog was helpful and gave you an insight about thunks and currying and how you could use these very useful concepts of the functional programming paradigm in your JavaScript apps. 😄

Before we end,

Feel free to reach out to me:
Twitter
Linkedin
GitHub

More content at PlainEnglish.io. Sign up for our free weekly newsletter. Follow us on Twitter and LinkedIn. Check out our Community Discord and join our Talent Collective.

What the Heck is a ‘Thunk’ and What’s ‘Currying’ in JavaScript? was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

A simple guide to optimizing your React Apps performance using Debouncing & Throttling.

Well, hello there! 👋 I see you have come here to learn more about how to make your React apps performant and optimize them using Debouncing and Throttling, which is great because that means you really do care about your app’s performance. Kudos for that! 👏

Do note that this blog assumes that you have a basic understanding of how React works and that you are familiar with React Hooks.

Before we jump in, let’s understand why would you want to optimize your React app’s performance?

Suppose you have a very simple React app with an input bar to search cities like the below,

As you can see, this app is super laggy and the UX of this app is 💩. We are just making a very simple search that filters cities from a list of cities based on user input.

PS:- You can give it a try if you want (Please do it at your own risk, you don’t wanna hang your computer!) — codesandbox.io/s/debouncing-example-demo-0d..

Now, you might ask why’s this React app so laggy?

If you would have noticed carefully from the above demo of the app, we are filtering the cities from the list of cities that we have on every keystroke made by the user (notice the keystrokes on the Virtual keyboard in the demo).

See now, that’s not a performant app at all and needs to be optimized to provide a better user experience.

Let’s have a look at two ways to optimize such apps and make them better!

What is Debouncing & Throttling?

There are many scenarios that make your app less performant like making API calls on each user keystroke on an input search bar, performing compute-heavy operations on button clicks, window resizing, or frequent scrolls on a scrollbar.

Basically, any scenario in which you are making expensive (in terms of computing or execution time) function calls on events or user actions that can hamper the performance of your apps.

Now, let’s understand Debouncing & Throttling.

Debouncing: In debouncing, we try to reduce the number of expensive function calls by calling them only if the time difference between two consecutive event triggers (user actions) is greater than or equal to a specified delay. This delay can be adjusted depending on the use case or the kind of user experience you are trying to design for your app.

Throttling: In throttling, we try to rate-limit the number of expensive function calls by calling them every time only after a certain time limit has passed from the last function call. Again, this time limit can be adjusted depending on your use case.

Debouncing & Throttling can be very useful to handle rate-limit errors caused by rate-limiting on certain APIs that your apps might be consuming, as we are trying to reduce the number of such expensive function calls using these optimizations.

Now that you have some idea about Debouncing & Throttling, let’s dive deeper into each concept using a simple example that illustrates some of their common use cases.

Optimizing apps using Debouncing

Let’s go back to the very first example that we saw, where we had a simple search bar that filters the cities from a list of cities based on the user input.

We can use debouncing in this case to reduce the number of function calls to filter the cities from the list.

But first, let’s look at the initial code from the demo.

Initial Code -

import "./styles.css";
import React, { useState } from "react";
import cities from "cities-list";
import { v4 as uuidv4 } from "uuid";

// An array of city names
const citiesArray = Object.keys(cities);

export default function App() {
  const [cityInput, setCityInput] = useState("");
  const [filteredCities, setFilteredCities] = useState([]);

  // Function that filters cities from the list based on user input
  const cityFilter = (query) => {
    console.log(query);
    if (!query) return setFilteredCities([]);

    setFilteredCities(
      citiesArray.filter((city) =>
        city.toLowerCase().includes(query.toLowerCase())
      )
    );
  };

  return (
    <div className="App">
      <h1 className="app-header">Find cities</h1>
      <div className="city-input">
        <input
          type="text"
          value={cityInput}
          onChange={(e) => {
            setCityInput(e.target.value);
            cityFilter(e.target.value);
          }}
        />
      </div>
      <div>
        {filteredCities.map((city) => {
          return <div key={uuidv4()}>{city}</div>;
        })}
      </div>
    </div>
  );
}

The above code snippet represents a simple React component with an input search bar and a container that displays the filtered cities.

// Function that filters cities from the list based on user input
  const cityFilter = (query) => {
    console.log(query);
    if (!query) return setFilteredCities([]);

    setFilteredCities(
      citiesArray.filter((city) =>
        city.toLowerCase().includes(query.toLowerCase())
      )
    );
  };

The function cityFilter takes a user search query as an input parameter and filters the cities from a list of cities (fetched from an npm package called cities-list). Currently, this function runs on every single keystroke made by the user on the search bar.

Now, let’s write a debounced version of the above cityFilter function to make it more optimal. We will be using setTimeout in JavaScript to achieve this.

// `timer` to help while clearing setTimeout 
// inside `debouncedCityFilter` function
let timer;

// Debounced version of the `cityFilter` func to filter cities 
// based on user search query
  const debouncedCityFilter = (query) => {
    clearTimeout(timer);
    if (!query) return setFilteredCities([]);

    timer = setTimeout(() => {
      console.log(query);

      setFilteredCities(
        citiesArray.filter((city) =>
          city.toLowerCase().includes(query.toLowerCase())
        )
      );
    }, 500);
  };

According to the concept of debouncing, we make function calls only if the time difference between two consecutive event triggers (user actions) is greater than or equal to a specified delay.

In the above code snippet, we set the state to get the filtered cities using setFilteredCities() which is called inside a setTimeout with a delay of 500ms(this delay can be adjusted according to the use case). So whenever a user keystroke is recorded on the input search bar, the debouncedCityFilter function is called which triggers setTimeout and sets the state using setFilteredCities() after 500ms.

However, if another keystroke made by the user is recorded just within this time delay of 500ms, the previous setTimeout needs to be cleared to avoid filtering the cities and setting the state. For this, we use clearTimeout that takes the id returned by the setTimeout function.

Now, this id needs to be preserved so that it is available whenever we need to use clearTimeout to clear the timer. We use a quite popular concept called Closures in JavaScript to be able to access this id inside the debouncedCityFilter function. Hence, if you'd have noticed we have defined a timer variable outside the debouncedCityFilter function for use inside this function.

By simply debouncing the cityFilter function, we are able to reduce the number of function calls and hence able to improve the performance significantly of our React app.

Let’s have a look at what our React component code looks like after making these changes.

Final Code -

import "./styles.css";
import React, { useState } from "react";
import cities from "cities-list";
import { v4 as uuidv4 } from "uuid";

// An array of city names
const citiesArray = Object.keys(cities);

// `timer` to help while clearing setTimeout 
// inside `debouncedCityFilter` function
let timer;

export default function App() {
  const [cityInput, setCityInput] = useState("");
  const [filteredCities, setFilteredCities] = useState([]);

  // Function that filters cities from the list based on user input
  const cityFilter = (query) => {
    console.log(query);
    if (!query) return setFilteredCities([]);

    setFilteredCities(
      citiesArray.filter((city) =>
        city.toLowerCase().includes(query.toLowerCase())
      )
    );
  };

  // Debounced version of the `cityFilter` func to filter 
  // cities based on user search query
  const debouncedCityFilter = (query) => {
    clearTimeout(timer);
    if (!query) return setFilteredCities([]);

    timer = setTimeout(() => {
      console.log(query);

      setFilteredCities(
        citiesArray.filter((city) =>
          city.toLowerCase().includes(query.toLowerCase())
        )
      );
    }, 500);
  };

  return (
    <div className="App">
      <h1 className="app-header">Find cities</h1>
      <div className="city-input">
        <input
          type="text"
          value={cityInput}
          onChange={(e) => {
            setCityInput(e.target.value);
            debouncedCityFilter(e.target.value);
          }}
        />
      </div>
      <div>
        {filteredCities.map((city) => {
          return <div key={uuidv4()}>{city}</div>;
        })}
      </div>
    </div>
  );
}

Now, have a look at how debouncing has improved the performance of this component significantly! 🚀

If you want to handle more edge cases for debouncing such functions, then you can check out Lodash which has a debounce method that covers most of the edge cases involved to make such functions more optimal.

Now, let’s look at a simple example that uses Throttling to make it more performant.

Optimizing apps using Throttling

Let’s suppose, you have a simple React component consisting of a button that on clicking calls an API to fetch some data related to all the currencies of different countries.

Initial Code -

import "./styles.css";
import React, { useState } from "react";
import axios from "axios";
import { v4 as uuid } from "uuid";

export default function App() {
  const [currencyData, setCurrencyData] = useState({});
  const [clickCounter, setClickCounter] = useState(0);

  const getCurrencyData = async () => {
    console.log("Fetching data ....");

    const { data } = await axios.get(
      "https://cdn.jsdelivr.net/gh/fawazahmed0/currency-api@1/latest/currencies.json"
    );

    // Fetching only 15 currencies for now
    const countryCurrencies = {};
    const currencyObjKeys = Object.keys(data).slice(0, 15);

    currencyObjKeys.forEach((key) => {
      countryCurrencies[key] = data[key];
    });

    setCurrencyData({ ...countryCurrencies });
  };

  return (
    <div className="App">
      <h1>Currencies of different Countries</h1>
      <button
        className="currency-btn"
        onClick={() => {
          setClickCounter((clickCount) => clickCount + 1);
          getCurrencyData();
        }}
      >
        Click to get all currencies
      </button>
      <span>Btn clicked - {clickCounter} times</span>
      <div className="currencies">
        {Object.keys(currencyData).map((currency) => {
          return (
            <div key={uuid()}>
              {currency}: {currencyData[currency]}
            </div>
          );
        })}
      </div>
    </div>
  );
}

The code snippet above is our simple component with two states — currencyData & clickCounter. On button click, we update the clickCounter state to reflect the total number of button clicks made so far and also call the getCurrencyData() function to make an API call to fetch the currency data.

Let’s look at what this component looks like!

As you might have noticed above, each button click triggers an API call. Now, imagine that your app was used by hundreds or thousands of users, the number of API calls would be humongous! Your Back-End servers could face a huge pool of requests coming from each user due to so many clicks. Also, if you are consuming any external paid API or service, then the endpoints might start throwing errors because of rate-limiting on the API endpoints.

Even if say you were not making any API calls on such button clicks but rather performing some compute-heavy operation, it would hamper your app’s performance severely!

Now, that’s a bit of a problem 😅

Let’s try and solve this problem using Throttling! ✨

We will throttle the getCurrencyData function that makes an API call on each button click.

Currently, the code for getCurrencyData looks like this,

const getCurrencyData = async () => {
    console.log("Fetching data ....");

    const { data } = await axios.get(
      "https://cdn.jsdelivr.net/gh/fawazahmed0/currency-api@1/latest/currencies.json"
    );

    // Fetching only 15 currencies for now
    const countryCurrencies = {};
    const currencyObjKeys = Object.keys(data).slice(0, 15);

    currencyObjKeys.forEach((key) => {
      countryCurrencies[key] = data[key];
    });

    setCurrencyData({ ...countryCurrencies });
  };

Now, we will write a function throttledGetCurrencyData that will throttle and use the getCurrencyData function to reduce the number of calls made to it.

// A flag to control the function calls to the `getCurrencyData` function
let shouldFuncBeCalled = true;

const throttledGetCurrencyData = async () => {
    if (shouldFuncBeCalled) {
      await getCurrencyData();
      shouldFuncBeCalled = false;

      setTimeout(() => {
        shouldFuncBeCalled = true;
      }, 500);
    }
  };

The throttledGetCurrencyData function calls the getCurrencyData function only if the shouldFuncBeCalled flag is set to true. Once this function is called, we delay the next function call to the getCurrencyData function by using setTimeout with some specific delay (This delay limit can be adjusted as per your use case).

This way we only allow function calls to happen after a certain amount of time has passed from the last function call. This way we can avoid making the UI slow or crossing the rate limits defined for any API that your app might be consuming.

Let’s look at how the app is working now.

As you can see from the console, the number of API calls has been reduced quite significantly even after clicking the button so many times!

Check out the CodeSandbox below to see what the code for our component looks like after using Throttling.

If you want to handle more edge cases for throttling such functions, then you can check out Lodash which has a throttle method that covers most of the edge cases involved to make such functions more optimal.

Debouncing vs Throttling, when to use which?

Now that we understand how Debouncing and Throttling work, let’s understand some of the differences and when to use Debouncing or Throttling.

Throttling enforces that a function must be called every time after a certain amount of time (or delay) has passed from the last function call.

Whereas, Debouncing enforces that a function must only be called if a certain amount of time (or delay) has passed without it being called. If this time has not been passed the debounce timer keeps resetting and the function call is avoided.

When to use what?

• Search bar: Use debouncing to avoid searching every time a user hits a keystroke. Throttling is not convenient here to use in this scenario, as you don’t want to make your user wait too long for fetching the search results (in the worst case if the previous function call was made just when the user stops typing).
• Shooting game: Use throttling on mouse click as shooting a pistol takes a few secs to register and it helps in avoiding the user to shoot until the previous shot has been registered. Debouncing will not shoot a bullet until a certain amount of time has passed when the pistol was not fired.

You can also check out this amazing Stackoverflow post to understand the differences between Debouncing & Throttling and when to use what.

Conclusion

Debouncing & Throttling are just a few ways you can make your React apps more performant & each technique has its own set of pros and cons depending on the use cases. In this blog, we first talked about Why should we care about our React app’s performance, then we understood how we can use Debouncing & Throttling to optimize our app’s performance, and finally saw a major difference between the two techniques and when we to use which technique.

That’s it from me folks, thank you so much for reading this blog! 🙌 I hope this blog was helpful and gave you an insight on how you can make your React apps more performant. Now, go ahead and make your apps even more amazing! 🚀

Feel free to reach out to me:
Twitter
Linkedin
GitHub
You can also reach out to me over mail: devansuyadav@gmail.com

More content at PlainEnglish.io. Sign up for our free weekly newsletter. Follow us on Twitter and LinkedIn. Check out our Community Discord and join our Talent Collective.

Make Your React Apps More Performant using Debouncing & Throttling 🔥🚀 was originally published in JavaScript in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this article, I will be sharing my experience so far contributing to the CheckStyle Project.

I will be talking a little bit about what I have learned + what I am working on right now and how I started getting involved in the community. I will also be sharing how you can get involved and start contributing to the Project.

First of all, let me introduce you to the CheckStyle Project, what is it all about, how it works, and what technology stack is being used in the Project.

Intro to the CheckStyle Open Source tool

Checkstyle is a development tool to help programmers write Java code that adheres to a coding standard. It automates the process of checking Java code to spare humans of this boring (but important) task.

Checkstyle is also highly configurable and can be used to support any coding style(for Java).

I believe that style of code becomes significantly important when it comes to working on a team project.

Checkstyle helps maintain consistent and proper code style for projects build in Java by providing different Checks for layout, code formatting, class design, method design, type checking. So, if the source code is not following a proper style or has incorrect syntax, then this tool shows violations on specific lines in those files which you can then easily rectify.

You can explore the project repository on Github. You can check out the documentation of the Project here to learn more about these checks.

Tech Stack

Checkstyle is mainly built in Java and it uses Maven/Gradle as a build tool, JUnit framework for testing, ANTLR for grammar, and parsing of Java code as AST(Abstract Syntax Tree), and many other tools/utilities that make up this amazing tool.
You can know more about the Project dependencies here.

My Open Source Journey

If I talk about my Open Source journey, I started exploring Open Source a few months back and I made a few contributions by participating in a University level Open Source program(was one of the top 50 contributors) and I really started enjoying it.

I realized that I can literally learn a lot of different technologies by contributing and get hands-on experience too!!

Currently, I am also participating in Girlscript Summer Of Code 2021 which is a 3-month Open Source Program held in India to promote Open Source culture amongst young programmers. I am contributing to different projects related to web development in Python and some projects using Java.

My Experience and Learnings

I came to know about the Checkstyle project just a few months back, while looking for organizations on the GSoC 2020(Google Summer Of Code) website. I was mostly looking for projects/organizations using Java since I had been learning Java and was more comfortable with it.

I found the Checkstyle organization’s website and I really loved the idea of this project and how it can a very useful tool while working on projects in a team since it becomes really easy to maintain code quality.

I soon started exploring this tool and started getting involved in the community’s mailing list and Gitter channel(You can find these on the official GSoC website here). I also started contributing to beginner-friendly issues.

My First Contribution

Talking about my first contribution, it was to update the example of AST(Abstract Syntax Tree) in the Javadoc documentation.
Don’t worry, it might seem a little overwhelming at first, but you will get a little familiarized with the codebase!

I worked on a couple of these issues and it helped me understand how to use CheckStyle on any project from the CLI. It helped me understand the Project structure and I also learned about ASTs(Abstract Syntax Tree).

An AST is a tree representation of the syntax of the source code in a programming language. You can learn more about them here.

Next, I went a level-up and worked on some of the GSoC second issues.
Now, Checkstyle is a very well-tested tool with Unit Tests, pitests, regression checking written for each check and CI tests (used to analyze its source code by running Checkstyle itself!).

As I had mentioned previously, CheckStyle has different checks implemented (like indentation, header, import, block checks, type checks, etc) for checking the source code(written in Java) of any project.

So, for this issue, I had to update a specific Test for a check to have it use unique input files(these files are used to test each of the check’s functionality) for every method in the Test.

What I learned after resolving these issues

By resolving this issue, I learned a little bit about Unit testing and TDD using the JUnit framework.

I learned that in TDD, we write tests to test the functionality of code(for eg:- an instance method) and compare the expected and actual cases of output to determine whether the code does what it should do in the first place.

I also learned about different properties and configurations based on which the checks actually verify source code and report violations.

What am I working on right now/current learnings?

Currently, I have started working on different variety of issues and getting a little deeper understanding of this tool, the different checks that Checkstyle provides, and also how to properly test your code for different edge cases.

I am currently learning about the different tools used in the Project like XPath(syntax used to navigate XML elements/nodes), pitests, Unit testing with JUnit.

So, pitests are basically mutation tests used to check how good the test coverage is, and it creates mutations in the code (deliberately break the code).

By doing this, we ensure that all tests cover our code completely and that certain redundant cases could be removed to keep the source code clean and precise.

This might seem a little overwhelming but trust me it gets very interesting as you deeply explore the project. I am also learning about how I could configure this tool and use it in my own projects.

Currently, I am looking to get a deeper understanding of what each check does, understand their code, and resolve bugs related to specific checks(like indentation, Javadoc, block checks, etc). I will also be looking to add tests while resolving these bugs.

How you can get involved and start contributing to Checkstyle?

1. Before getting started, you should first set up your development environment and clone the Project locally. You can follow this documentation. You can clone the project from the Github repository. Also, join the community channel on Gitter and the mailing list, as you can ask for help if you face issues while contributing.
2. After you set up the project, I would suggest you either install the jar file for Checkstyle from here or you can install the Checkstyle extension for your IDE(check this out).
   If you install the jar file then you can play around with this Project using the CLI(which is easier)or if you installed the IDE extension then you can use it in your IDE.
3. Read the documentation(to know more about the tool and also you can get answers to your questions/doubts there most of the time) and go through some beginner-friendly issues by filtering issues according to issue labels on Github.
4. Keep contributing and exploring the tool by picking up different types of issues.
5. Checkstyle has a number of CI tests that run tests on your PR branch. So, if some of these tests fail, you can have a look at the logs that are generated or you can also ask for help on the Gitter channel.

Another thing that I would suggest is to look up similar issues to what you are working on and have a look at the PRs for those issues. This would help you a lot to understand what you have to do in those issues. The mentors/maintainers of the organization are super helpful and supportive and have been maintaining this Project actively.

You can also watch this video, to understand more about how to get started and contribute to Checkstyle.

This was all about my journey so far contributing to Checkstyle and I am going to share more about it as I keep contributing and learning different stuff, in the next part of this blog post.

So stay tuned for this!!

Thanks for reading and feel free to share this post with others if they want to get started contributing to Open-source.

Feel free to reach out to me:
Twitter
Linkedin
Github
Student Ambassador Profile
Or if you feel more comfy to mail, I am glad you can write here too
Devansu.Yadav@studentambassadors.com

Python has a lot of built-in libraries which we use so frequently.

According to me, the best thing about Python is that it is built as an Open Source Software and many of the Python libraries/packages are also Open source, which means anyone can view the source code and contribute to these libraries.

What if you wanted to contribute your Python Package so that everyone can use it?

Well, it’s simple and that’s what I am going to share with you in this Blog.

First of all,

What is PyPI?

The Python Package Index (PyPI) is a repository of software for the Python programming language. PyPI helps you find and install software developed and shared by the Python community.

You might be familiar with the ‘pip’ command in Python. It is basically used to install different libraries created by the community from PyPI, which you can use in your Python apps.

For Eg:-

pip install tensorflow

What is a Package in Python?

A Package in Python is nothing but a Library consisting of different modules (files) and other sub-packages.

Now let’s look at the steps for publishing your Python Package on PyPI -

STEP 1: Creating all the files for your Package

In this blog, I am going to take my Package ‘turtle_conics’ as an example.

First, we will have to create a folder (You can create one anywhere but here I have created it on Desktop for my convenience) (for Windows/Mac/Linux distros) with the same name as you want for your Package. So for me, it’s ‘turtle_conics’. Next, create a folder inside this folder with the exact same name that you gave to the Folder created just now.

List of Files required to be created:

1) __init__.py file
2) Source Code Files
3) setup.py file
4) License.txt file
5) README.md

Project structure for my Package

turtle_conics/
│
├── turtle_conics/
│   ├── __init__.py
│   ├── all_curves.py
│
├── LICENSE.txt
├── README.md
└── setup.py

1) __init__.py file:

The __init__.py file is required to make Python treat directories with this file as a Package.

So now inside the folder that we just created inside my Desktop folder(for you it can be in a different location), we need to put the __init__.py file. You can keep this file empty as I did.

2) Source Code files:

Now inside the same folder where we placed our __init__.py file, we can place all the source code files (Python Files).

3) setup.py file:

The setup.py file contains information about your package that PyPi needs, like its name, a description, the current version, etc. We will look directly into a real simple setup.py here:

import setuptools


with open("README.md", "r") as fh:

    long_description = fh.read()


setuptools.setup(

    name="Your Package name", # Replace with your package name

    version="version_no",

    author="Your name",

    author_email="Your email id",

    description="Description of your Python package",

    long_description=long_description,

    long_description_content_type="text/markdown",

    url="Link to your Github repo for your Package",

    packages=setuptools.find_packages(),

    classifiers=[

        "Programming Language :: Python :: 3",

        "License :: OSI Approved :: MIT License",

        "Operating System :: OS Independent",

    ],

    python_requires='>=3.6',

)

Most of the options are self-explainable, you can just copy the content of setup.py above and modify it as you need.

Please remember to list all dependencies of your package in a list and place it below ‘classifiers’ [just like there is the requirement for Python version there] or click here, so that these requirements can be installed automatically while your package is being installed.

4) License File

A License File is highly recommended for any Open source project so you can choose any License according to you and save the file as License.txt.

For licenses check here.

5) README.md File

Almost every Open-source Project has a README.md file explaining the Package/Project. Hence this file is highly recommended if you want other people to understand your Project. It can be used to describe all the features/functionalities or implementation of your Project.

This is how the README for my package looks like on PyPI -

NOTE:- Save the file as README.md and not as .txt.

For creating this file you can use text editors like Visual Studio Code or you can use other Online text editors.

Now after you are ready with the License.txt file, README.md, and setup.py file, place all the three files inside the Desktop folder(for you it may be some other folder).

Step 2. Create a PyPi account

If you already have a PyPi account (and still remember your username/password, of course), you can skip this step. Otherwise, please go to the PyPi homepage and register a new account instantly (for free, of course).

STEP 3: Time to upload your Package on PyPI

Generating Distribution archives(wheel file): These are archives to be uploaded on PyPI for uploading the Package.

Make sure you have the latest versions of setuptools and wheel installed:

python3 -m pip install — user — upgrade setuptools wheel

Now for Windows OS open the Folder for your Package and click on the Top address bar and type cmd. This will open the Windows Command Prompt at that Folder path.

If you are on Mac/Linux just open the Desktop folder for the Package and Right-click and Select -> New Terminal at Folder or just open your Terminal on Mac/Linux and using cd provide the path to this folder.

Now, if you are on Windows, type the following command on cmd :-

python setup.py sdist bdist_wheel

Else if you are on Mac/Linux, type the following command:-

python3 setup.py sdist bdist_wheel

This command should output a lot of text and once completed should generate two files in the dist directory, among others in build and *.egg-info folder:

Note:- Make sure that the correct version of python “py3” is mentioned in this line in the output when you run python setup.py sdist bdist_wheel (for Windows) or python3 setup.py sdist bdist_wheel (for Mac/Linux distros). If it's “py2” then the module will install only in python2.x and not in python3.x.

Uploading Distribution archives:

Now it’s time to upload the distribution archives that we generated in the previous step.

For this open cmd(For Windows) and Terminal(for Mac/Linux) at the same Folder path as we did in the previous step and type the following command:-

twine upload dist/*

NOTE:-Make sure to install twine using pip install twine , as we will be uploading our package distribution archives using this tool.

Then enter the username and then password, the password will not show as you type. so just type it and hit enter,

Great!👏 Now we have uploaded the Package on PyPI so now go to the website and under your projects check your Package.

Installing your package:

Now that we have uploaded our package on PyPI, let’s try to install it using pip just like we do for installing other modules/packages.

pip install <your package name>

**Replace <your package name> with the name of the Python package that you just uploaded.

Updating your Package

If you want to release a new version for your package where you may have made some changes to your code, then first change the version for your package in the setup.py file. Now your setup.py file should look like this:-

import setuptools


with open("README.md", "r") as fh:

    long_description = fh.read()


setuptools.setup(

    name="Your Package name", # Replace with your package name

    version="latest_version_no", <- #Enter latest version no

    author="Your name",

    author_email="Your email id",

    description="Description of your Python package",

    long_description=long_description,

    long_description_content_type="text/markdown",

    url="Link to your Github repo for your Package",

    packages=setuptools.find_packages(),

    classifiers=[

        "Programming Language :: Python :: 3",

        "License :: OSI Approved :: MIT License",

        "Operating System :: OS Independent",

    ],

    python_requires='>=3.6',

)

Now recreate the wheel file by:

For Windows:-

python setup.py sdist bdist_wheel

For Mac/Linux:-

python3 setup.py sdist bdist_wheel

And then type the following command:

twine upload --skip-existing dist/*

And that’s it!! I hope this was helpful and be sure to ask in the comments if you have any doubts.

You can check out my Python Package here.

Also, I would love to hear about your suggestions on my blog posts or any improvements that I can make.

Feel free to reach out to me:
Twitter
Linkedin
Github
Student Ambassador Profile
Or if you feel more comfy to mail, I am glad you can write here too
Devansu.Yadav@studentambassadors.com

Happy Coding :)

Don’t forget to follow The Lean Programmer Publication for more such articles, and subscribe to our newsletter tinyletter.com/TheLeanProgrammer

A Simple Guide to Publishing and maintaining a Python Package on PyPI was originally published in TheLeanProgrammer on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you have just started to learn Technology, then you might have heard this from a lot of developers:

Learn by Doing! Build what you learn! Build projects/ make an Open Source contribution!

And it's absolutely true! Learning without practicing or without implementing can only give you some theoretical knowledge and you would not gain practical knowledge which is very crucial if you want to become a Developer👨‍💻!

Let me share with you something about myself:-

I am a CS Undergrad and I am really interested in Web and Mobile Development. I have worked with Python(absolutely ❤ it ) and built projects using Python.

Since I was looking to learn different technologies that are used for Web development I came across this amazing program called “Crio Winter of Doing” organized by Crio.do. I got really excited about this opportunity and decided to register for this program.

It is India’s largest Tech Externship Program for developers!
It is a one-of-a-kind program focussed onbringing together budding engineering talent to work on challenging projects for the most exciting startups in the country.

This program has 3 stages: Warm-Up, Preparation, and Externship
You can check out more about this program here.

Recently, we completed the 1st stage of this program: Warm-Up.
Since this was the first stage we started learning about the pre-requisites needed for Web Development like HTTP, some basic understanding of REST APIs. We also learned about essential Linux commands, Version Control using Git, and hosting websites/applications on AWS through hands-on learning modules called “Bytes” which were provided to us by Crio.

Let me share with you some of the things that I learned in Stage-1!

1. HTTP

We know that HTTP stands for HyperText Transfer Protocol.
But what exactly is HTTP? It is a set of rules for querying the web🤓.
Next up, we learned about what are HTTP requests.

HTTP requests are requests made by our browser to access web pages or to fetch some content like images, text(content on a web page). So when you enter a website URL, the browser creates an HTTP Request on your behalf and sends it to the server on which the website is hosted.

The HTTP response from the server is read by the browser and rendered for us beautifully as web pages instead of the raw HTML returned.

Here’s an example:-

1. Visit a website using its URL and Open the Chrome Developer Tools(Right-click and Inspect/Ctrl + Shift + i).
2. Now select the Network tab and refresh the web page to start recording Network activity for that page.

As you can see these are some of the HTTP requests that your browser makes for fetching the content of a website.

Now, when you click on one of these requests, you can see different parts of that HTTP request like Request URL, Request and Response Headers, HTTP method for the request.

Some of the HTTP methods that we learned:-

GET:- GET requests are used to “get” resources from a server and not modify any data on the server.
POST:- POST requests are used to send some data to the server. For eg: Submitting a form, making a post on Linkedin/Facebook.
PUT:- PUT requests are used to update data on the server-side. For eg: Updating profile data on Linkedin/Twitter.
DELETE:- DELETE requests are used to delete some data on servers. For eg: Deleting a post/comment.

HTTP Status Codes:-
HTTP Status codes are a part of the HTTP Response. It helps the client(browser) understand what happened to the request.

Some of the HTTP status codes include:-

2xx family:- The status codes 200–299 signifies the HTTP request was successfully received & understood by the server. For eg:- 200 (Successful request)
3xx family:- This family of status codes denotes that further action must be taken to complete the HTTP request made.
4xx family:- This family of status codes tell us that there was an error in the HTTP request sent by the browser(client).

curl and Postman:-

curl is like a web-browser, but for the command line. Using curl we can make HTTP requests just like our browser does! You can also get information about the HTTP requests just like how we use the Chrome Developer Tools.

Postman is an awesome tool used to test or build your APIs/HTTP requests. At the end of the HTTP module, we created a simple HTTP request over a TCP connection(using Telnet).

2. REST API

First of all, what is an API?
- API stands for Application Programming Interface.
- APIs are basically some functionality/data/feature that you want in your application/code that you have built. For this, you make an API call/request to fetch that data/use that functionality/feature in your code.

A REST API is an API that follows the REST architecture and follows a client-server model. (You can read more about the REST architecture here.)

The various components of a REST API request include the Request URL(using which the browser makes the request), Request Method(like GET, POST, PUT), Request Headers(eg:- accept, accept-encoding), Request Body.

Now, after completing this Byte, we learned how to make an API request and I actually made a tweet on Twitter using my Linux Terminal by making an API request to Twitter’s API (which was super awesome!). (Here’s a link to the tweet I made using the terminal!)

3. LINUX

Linux runs almost everything these days from smartwatches, laptops, Cars to servers in Cloud, anything, you name it.

The Linux Terminal is a really powerful and productive tool for a developer if you are working with different files, navigating files/CRUD operations, data analysis, running/creating scripts for different tasks like automation, working with curl, and much more!

In this byte, we learned about the power of Linux by learning about different Linux commands to navigate, create, copy, rename, read, write, update and delete files and directories in Linux.

We also learned about some utility commands like “grep”, “awk” and different operators like the Pipe operator “|”, the redirection operator “>”.

We also learned about “cron” jobs which are used to schedule the execution of a script. I also learned about Bash scripts and created a simple Bash script to analyze data from the logs generated by an app through a Fun activity which was conducted during this program by Crio.

4. AWS and Git

The Amazon Web Service or AWS is a cloud hosting platform for hosting websites or apps using a virtual private server.

We learned how to host an app on AWS by hosting a Food delivery app(QEATS) on the AWS ec2 server by creating an ec2 instance, deploying the backend server for the app, and then connecting it to the ec2 instance. (You can check out AWS here.)

Git is a Local Version Control System used to manage/track files while working on a project. (You can check out my Blog on different Git commands here)

Next up, we learned about cloning a Git repo, adding changes, pushing, and pulling changes using different Git commands.

We also learned about merge conflicts that occur when you are trying to push changes to a branch that is not in sync with your forked repo. We learned about how to handle these conflicts as well!

5. HTML and CSS

HTML, CSS, and Javascript are the key components for building the Front-End or the UI of any website.

The content that you see on any webpage is displayed using HTML and is styled using CSS to make a webpage look beautiful and attractive!
Javascript is used to make webpages responsive and dynamic by accessing HTML elements and rendering them in a specific way.

In the HTML byte, we learned about basic HTML tags like <head>, <body>, <p>, <i>, <a>.

Next up, we learned how to style HTML elements using CSS.

We also learned about the CSS Box model which is how we visualize an HTML element as a rectangular region and different properties like margin, padding, border, height, and width for that element.

We can automatically arrange HTML elements according to the screen size(for mobile or desktop) using CSS Flexbox. We make an element a “flex container” and then set different properties like “flex-wrap”, “flex-direction”, “justify-content” for arranging elements in a specific manner.

We also learned how to position elements in CSS using the “position” property.

After completing these Bytes we also got to experience Full-stack web development by working on a guided project where we got to learn different aspects of a Full-stack web application like Front-End, Back-End, deploying each component on different platforms like Netlify and Heroku, and then connecting the two components i.e Front-End and Back-End.

I got to learn a lot about these different technologies by implementing the knowledge in the 1st stage of this program. I thoroughly enjoyed the “learn by doing” approach and I am really excited about the 2nd stage of this program!

Do follow me on Medium where I will be talking about Mobile and Web Development, Machine Learning, Computer Vision, and much more!

You can connect with me:- Linkedin or Twitter
Check out my projects on - Github

It’s almost that time of the year when Open Source enthusiasts, Developers, and Tech enthusiasts from different communities from all over the world participate in a month-long Open Source Fest. Yes I am talking about the Hacktoberfest 🤩

The Hacktoberfest is an amazing platform for everyone, whether you are a Developer, an Open Source Enthusiast, or if you are a Beginner who wants to begin his Open Source journey👨‍💻.

Now if you are looking to contribute to Open Source😍 then you must have some working knowledge about Git/Github.

You might have heard about Git but if you haven’t it is a Version Control System that is used to manage/track your files in a Project that you are working on or if you are contributing to one.

So using Git and Github we can easily manage files, track changes to different files, manage workflows in a Project, and much more. That’s why they are such an important tool when working on Open Source Projects.

Setting up our Git Repository

Let’s make a Git Repository and learn about some useful Git commands😀.

Let’s start by creating a folder where we can have different files like a text file, an Excel Database file, a Markdown File, a Folder consisting of Source Code files(An actual Project may have many different files).

But right now for simplicity's sake let’s keep these files empty.

We can use Git Bash to write Git commands or we can also use VS Code which has built-in support for Git. You can install Git here or you can check out this link to know how to work with Git in Vs Code. If you are using Git for the first time do check this out to know how to set up Git Bash.

Now let’s open Git Bash by Right-clicking and selecting “Git Bash here”.

1. Initializing our Git Repository

Here we are initializing our Git Repository or you can say we are making our directory a Git Repository.

NOTE:-If you already have made a Git Repository then don’t use this command again else all the changes that you have made to this Repository will get re-initialized.

2. Staging Files Initially

We are staging these files initially so that now we can now track them using Git.

3. Creating Initial Commit

Let’s make our Initial Commit to our Repository.

Now let’s take a look at some of the useful Git commands for merging branches, forking a Repository, Renaming, and Deleting files using the command line, and much more.

Git Commands

1. git diff

We had already staged our files initially above and made our initial commit.

Now suppose I modify a file say “Test.txt” and save it.

Let’s run the “git status” command.

As you can see it shows that we have modified that file. Now let’s run the “git diff ” command and see what happens.

Here using the “git diff ” command we are actually comparing this file “Test.txt”(modified file) which is in our current working directory with the same file which we had staged earlier(i.e in the Staging Area).

So using this command we can come to know what modifications did we do in any file in our current Working Directory with the same file in Staging Area.

Here as you can see the ‘+’ symbol denotes the changes that we made in that file(in our Working Directory) and ‘-’ denotes the content in the file in the Staging Area.

This command is not just limited to comparing two files, we can compare two branches as well.

2. git diff — staged

This command is used to know the difference between the files in the previous commit and the current Staging Area.

To understand this in detail let’s modify a few files.

Now let’s stage these files and run the “git diff — staged ” command.

As you can see it shows us the difference between these files in the previous commit and the changed version of these files in the staging area(currently staged but committed).

This can be helpful to review the previous commit and make necessary changes to any file.

3. Renaming and Deleting any file using Git Bash

Deleting/Renaming files can be a bit confusing and sometimes tedious especially if your Git Repository has a lot of files and folders because you would have to then stage all the files as well😥.

A cleaner and efficient way 😊to do this would be to use the following Git commands:-

Renaming a File

git mv <filename> <newfilename>
# <filename> is name of your file you want to rename.
# <newfilename> is name you want to give to your file.

Deleting a file

git rm <filename>

Using these commands we can easily Rename/Delete any file in our Repository and the changes would also be staged automatically by Git so you wouldn’t have to worry about staging these changes😍.

4. Syncing Forks in Git and Github

The World of Open Source Development is really active because so many developers contribute to different Open Source Projects.

So if you are contributing to an Open Source Project then Syncing your forked Repository with the Original Repository becomes really important.

Suppose you already have a Forked Repository(on Github) which you want to sync with the Original Repository(from which you forked).

If you haven’t cloned the Forked Repo on your Local machine then just use the following command:-

git clone https://github.com/<Username>/<Repository-name>.git <filename>
# filename: It is the name of file/folder for the Cloned Repository on your Local Machine.

Now we will add the Original repository as a remote repository(upstream):-

git remote add upstream https://github.com/<Owner>/<Repository>.git
# add the original repository as remote repository called "upstream"

Now we will fetch the changes from the upstream repository:-

git fetch upstream
# Fetch the branches and their respective commits from the upstream repository.

We will now switch to the master branch of the fork’s local repo and merge the changes in the upstream repo to the local repo’s master branch:-

git checkout master
# switch to the master branch of your fork's local repo

git merge upstream/master
# Merge the changes from upstream/master into your local master branch.

This brings your fork’s local repo in sync with the Original repository😄.

However, if you also want to update the forked repo on Github then you would have to push the master branch (or the branch in which you merged the changes of the upstream repo).

git push origin master
# origin: forked repository on Github

And boom!! Your Forked Repo on Github is also now synced with the Original Repo😄.

That’s it from me guys, hope I was able to make it simple for everyone😃 and be sure to ask in the comments if you have any doubt. I’d love to answer them!😊

Do share the post if you like it👍

Feel free to reach me out!

LinkedIn
GitHub

Happy Coding!!😊

All the Best for the Hacktoberfest👍

Useful Git Commands that can help you in your Open Source Journey👨‍💻 was originally published in TechPhantoms on Medium, where people are continuing the conversation by highlighting and responding to this story.