In this article, we will try to understand its basics while diving deep enough so that you will be able to start working with Docker as a software engineering professional.

Installing Docker

Before we dive into Docker, we need to install it on our system. Docker provides installation packages for various operating systems, including Windows, macOS, and Linux. You can download the appropriate package for your OS from the official Docker website.

Once Docker is installed, open a terminal or command prompt and run the following command to verify the installation:

docker --version

If you see the Docker version information like the below image, you're ready to move on to the next steps.

Running Your First Docker Container

Let's start by running a simple Docker container. Docker containers are instances of Docker images, which are pre-packaged, portable environments. We'll use the official Docker image for the "hello-world" application.

Open your terminal and run the following command:

docker run hello-world

Docker will download the "hello-world" image if it's not already available and run it. You'll see a message indicating that your installation appears to be working correctly.

In the above image, you'll see that since hello-world Docker image was not present locally, Docker downloaded it and displayed additional information on what happened behind the scenes.

Note: See Docker daemon, search for this on the internet, doing so, you will get to learn about the internals of Docker as a bonus.

Understanding Docker Images

Docker images are the building blocks of containers. They contain everything needed to run an application, including the code, runtime, libraries, and system tools. Images are stored in a Docker registry, which is like a repository for Docker images.

You can search for Docker images on the Docker Hub (Docker Registry) or create your own custom images. Let's create a simple Java application and package it into a Docker image.

Note: For some developers, this may seem like a lot of information. Try to code along with the article at your own pace and whenever in doubt, just search it over the internet!

// HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Docker!");
    }
}

To create a Docker image for this Java application, create a Dockerfile in the same directory with the following content:

Note: To create a Dockerfile, if you are a terminal enthusiast then you can do something like touch Dockerfile. Make sure you are in the same directory as HelloWorld.java file.

# Use an official Java runtime as a parent image
FROM openjdk:8-jdk

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Compile the Java code
RUN javac HelloWorld.java

# Run the application
CMD ["java", "HelloWorld"]

Now, build the Docker image using the docker build command:

docker build -t hello-java .

The -t flag allows you to tag the image with a name ("hello-java" in this case). You can replace "hello-java" with any name you prefer.

Note: I have added comments in Dockerfile itself, it is pretty straight forward, just give it some time and you'll understand it easily. Note the COPY command, you need to copy the files inside your Dockerfile. When you use docker build ., then the current directory files are available to you as context but they are not inside image.

Running Your Custom Docker Image

Now that we have created a custom Docker image, let's run it as a container:

docker run hello-java

The "Hello, Docker!" message is printed in the terminal, indicating that the Java application is running inside the Docker container.

Docker Containers Are Stateless

One important concept to understand is that Docker containers are stateless by default. This means that any changes made inside a container are ephemeral and do not persist after the container exits. To demonstrate this, let's modify our Java application to accept user input and see how the container behaves.

// HelloWorld.java (Updated)
import java.util.Scanner;

public class HelloWorld {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter your name: ");
        String name = scanner.nextLine();
        System.out.println("Hello, " + name + "!");
    }
}

Now, rebuild the Docker image and run it again:

docker build -t hello-java .
docker run -it hello-java

You'll notice that the container stops after taking user input and displaying the message. This is because containers are designed to be disposable and do not retain state between runs.

You can see the result below:

Docker Volumes for Data Persistence

To persist data between container runs, you can use Docker volumes. Volumes are a way to share data between the host system and containers or between containers. Let's modify our Java application to write user input to a file and use a Docker volume to persist the data.

// HelloWorld.java (Updated)
import java.io.FileWriter;
import java.io.IOException;
import java.util.Scanner;

public class HelloWorld {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter your name: ");
        String name = scanner.nextLine();

        try {
            FileWriter writer = new FileWriter("/app/output.txt");
            writer.write("Hello, " + name + "!");
            writer.close();
            System.out.println("Data written to output.txt");
        } catch (IOException e) {
            System.err.println("Error writing to file: " + e.getMessage());
        }
    }
}

Rebuild the Docker image and run it, this time with a Docker volume:

docker build -t hello-java .
docker run -it -v $(pwd)/data:/app/data hello-java

The -v flag is used to mount a host directory (./data) as a volume inside the container. Now, the data is written to output.txt will be persisted on your host system in the ./data directory.

That's a lot of information! Let's move on to something more fun.

Dockerizing a Java Web Application

Docker is not limited to running simple command-line applications. It can also containerize web applications. Let's take a Java-based web application as an example. We'll use Spring Boot, a popular Java framework, to create a simple REST API.

Example Java Web Application (HelloAPI.java):

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class HelloAPI {
    @GetMapping("/")
    public String hello() {
        return "Hello, Dockerized API!";
    }

    public static void main(String[] args) {
        SpringApplication.run(HelloAPI.class, args);
    }
}

To Dockerize this application, create a Dockerfile similar to the one we used earlier but with a few modifications:

Dockerfile for Java Web Application:

# Use an official OpenJDK runtime as a parent image
FROM openjdk:8-jdk

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Build the Java application
RUN ./mvnw package -DskipTests

# Expose port 8080 for the Spring Boot application
EXPOSE 8080

# Run the Spring Boot application
CMD ["java", "-jar", "target/demo-0.0.1-SNAPSHOT.jar"]

Now, build the Docker image for your Java web application using the same docker build command as before:

docker build -t hello-api .

Once the image is built, you can run a container from it, and your Spring Boot application will be accessible at http://localhost:8080 in your web browser.

Docker Registry and Pushing Images

So far, we've been working with local Docker images. You can use Docker registries to share your Docker images with others or deploy them to remote servers. Docker Hub is a popular public registry, but you can also set up your private registry.

To push your custom Docker image to Docker Hub, follow these steps:

1. Log in to Docker Hub using the docker login command.

docker login

1. Tag your image with your Docker Hub username and repository name.

docker tag hello-java <your-docker-hub-username>/hello-java

1. Push the image to Docker Hub.

docker push <your-docker-hub-username>/hello-java

Now, your custom Docker image is available on Docker Hub and can be pulled by others.

Container Orchestration with Docker Swarm and Kubernetes

Docker can be used for container orchestration, which manages multiple containers across a cluster of machines. Two popular tools for container orchestration are Docker Swarm and Kubernetes.

• Docker Swarm: Docker Swarm is a built-in orchestration solution for Docker. It allows you to create and manage a swarm of Docker nodes (machines) and deploy services to them. Docker Swarm is easy to set up and is suitable for smaller deployments.

• Kubernetes: Kubernetes is a powerful and widely adopted container orchestration platform. It provides advanced features for managing containerized applications at scale. Kubernetes has a steeper learning curve than Docker Swarm but offers more flexibility and scalability.

To get started with Docker Swarm or Kubernetes, you can refer to their official documentation and tutorials.

Takeaways

Docker is a powerful tool that simplifies application development, deployment, and scaling by using containers. In this article, we've covered the essential steps to get started with Docker, with these fundamental concepts and practical examples, you can begin harnessing the full potential of Docker for your Java development projects. Docker's ability to create consistent and isolated environments will streamline your development process and make your applications more portable and maintainable. Happy Dockerizing!

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Data Structures & Algorithms to more fun topics like Computer Vision.

• Want to ++ your GitHub Profile README? Check out Quote - README

• Starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to make a simple and awesome game from scratch? Check out PongPong

Till next time!

Namaste 🙏

Some sorting algorithms ensure that the relative order of equal elements remains unchanged after sorting, while others make no such guarantee. This distinction gives rise to the concepts of stable and unstable sorting algorithms. These categories may seem subtle, but they can have significant implications for various applications.

Note: Equality of elements will depend on their data types, for primary types - their face values - and for secondary types i.e. objects - their custom-defined comparable methods - will act as the equality differentiator.

In this article, we will delve into the significance of stable and unstable sorting, exploring their differences and discussing scenarios where their distinctions matter.

Understanding Stable and Unstable Sorting

Stability in sorting algorithms refers to the preservation of the relative order of elements with equal keys. In other words, if two elements have equal keys, and one appears before the other in the original sequence, a stable sorting algorithm will maintain that order in the sorted output. On the other hand, an unstable sorting algorithm makes no such promise. When two elements have equal keys, their relative positions in the sorted output may not match their original relative positions.

To illustrate this concept, consider a scenario where you have a list of student records, each containing a name and a score. You want to sort the records first by score in ascending order and then by name. A stable sorting algorithm will ensure that if two students have the same score, their names will remain in the same order as in the initial list. An unstable sorting algorithm, however, might rearrange the names of these students, leading to a different order.

Let's delve into some code examples to showcase stable and unstable sorting algorithms!

Code Example In Python

Consider the following example in Python using the sorted() function, which employs a stable sorting algorithm:

data = [(3, "apple"), (1, "banana"), (3, "orange"), (2, "grape")]

sorted_data = sorted(data)

print(sorted_data)

The output will be:

[(1, 'banana'), (2, 'grape'), (3, 'apple'), (3, 'orange')]

Notice that the two elements with the key 3 appear in the same order as they did in the original list.

Note: sorted function when not given any key will take the first element of the inner tuples to perform the sorting in ascending order by default.

Note: Python internally uses different sorting algorithms to perform sorting. In certain scenarios, its interpreter could use the quick sort algorithm which would result in an unstable sort. Read more about why the quick sort is unstable here.

Code Examples In Java

Stable Sorting

Java provides a built-in sorting method using the Arrays class, which uses a stable sorting algorithm. Here's how you can use it:

import java.util.Arrays;
import java.util.Comparator;

class Student {
    String name;
    int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }
}

public class StableSortingExample {
    public static void main(String[] args) {
        Student[] students = {
            new Student("Alice", 85),
            new Student("Bob", 90),
            new Student("Carol", 85),
            new Student("David", 78)
        };

        // First, sort by score, then by name
        Arrays.sort(students, Comparator.comparingInt((Student s) -> s.score)
                                       .thenComparing(s -> s.name));

        for (Student student : students) {
            System.out.println(student.name + ": " + student.score);
        }
    }
}

The output will be:

David: 78
Alice: 85
Carol: 85
Bob: 90

In this example, the Arrays.sort method first sorts the students by their scores. Since both Alice and Carol have the same score, their original order is preserved due to the stability of the sorting algorithm.

Unstable Sorting

To demonstrate an unstable sorting algorithm, we can use the Collections class, which provides a method to sort lists:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class UnstableSortingExample {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 85));
        students.add(new Student("Bob", 90));
        students.add(new Student("Carol", 85));
        students.add(new Student("David", 78));

        // Sort by score using an unstable sorting algorithm
        Collections.sort(students, Comparator.comparingInt((Student s) -> s.score));

        for (Student student : students) {
            System.out.println(student.name + ": " + student.score);
        }
    }
}

The output could be:

David: 78
Carol: 85
Alice: 85
Bob: 90

In this example, the Collections.sort method sorts the students by their scores. However, unlike the stable sorting example, the original order of students with the same score (e.g., Alice and Carol) might not be preserved in the sorted output.

Why Stability Matters

The stability of sorting algorithms might seem like a subtle distinction, but it can have significant implications in various applications.

Consider a situation where you have a dataset of individuals of the same age, and you want to sort them by their names. A stable sorting algorithm would ensure that if two people share the same age, their names remain in the same order as they were initially. This could be essential, especially when dealing with historical data or maintaining user preferences.

Here are a few scenarios where stability matters:

1. Multi-level Sorting: In cases where you need to sort data by multiple criteria, using a stable sorting algorithm ensures that the order of previous sorts is maintained. This is particularly useful in scenarios like the student records example shown earlier in the article.

2. Preserving Initial Order: Stable sorting is crucial when dealing with data that already has a meaningful order. For instance, when sorting log entries by timestamp, you'd want to maintain the original order of entries that occurred at the same time.

3. Algorithm Composition: Stable sorting is often used as a building block in more complex algorithms. If intermediate steps require sorted data, the stability of the sorting algorithm can impact the correctness of the overall process.

Note: An unstable sorting algorithm might be more efficient in terms of time or memory usage. Algorithms like Quicksort and Heapsort are often unstable, but they can offer better performance in certain scenarios. For instance, if stability is not a concern and you're dealing with large datasets, an unstable sorting algorithm might be preferred due to its speed and memory efficiency.

Takeaway

1. Sorting is not just about arranging elements; it's about maintaining the integrity of the data and respecting the original order when necessary. Stable and unstable sorting algorithms provide different approaches to achieving this goal.

2. When maintaining the initial order of equal elements is vital, a stable sorting algorithm is the way to go. However, if performance is a priority and stability is not a concern, an unstable sorting algorithm might offer better efficiency.

3. At last, it all comes down to an individual choice and the problem a developer is trying to solve. As a developer, understanding stable and unstable sorting empowers you to choose the right sorting algorithm for the task at hand, ensuring the accuracy and reliability of your applications.

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Data Structures & Algorithms to more fun topics like Computer Vision.

• Want to ++ your GitHub Profile README? Check out Quote - README

• Starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to make a simple and awesome game from scratch? Check out PongPong

Till next time!

Namaste 🙏

But, any way I took, which looked daunting at first, the task of learning Java! And I am not going to lie, Java is the most user-friendly programming language for anyone who works with Object Oriented Programming almost every day. Heck, if you love Functional Programming, Java got you covered (but I am a little biased towards Scala Programming Language).

Being a Python Developer since college and now learning Java, I wanted to highlight some of the many things that I learned during this transition, which might help you decide whether you should go ahead and over that intimidation to learn Java or not.

Don't Be Afraid Of Java Hello World Program

I have seen people disliking Java immediately after seeing the code of Hello World written in Java (I was one of them). They start comparing it with Python's syntax of Hello World program and get intimidated and leave before even trying to understand why its syntax is like that.

So, Java is almost a complete Object-Oriented Programming (OOP) language and as we all know, in OOP we deal with classes/objects and when we talk about classes or objects, we need to understand that the code written might be big but it is guaranteed to be human-readable and understandable and highly manageable.

If you don't know, almost everything that Python offers is actually an object of some type behind the scenes. It is abstracting it all out so that we write less code and can focus on delivering fast. But, it comes at a cost of speed (which now with many enhancements is improving).

Note: You can start learning Scala to write less code and be as fast as Java here.

So, before starting to learn Java, you should know that classes will be defined, objects will be created, methods will be called and all will be in accordance with OOP, and you will learn OOP either as a beginner or as a professional from the get-go through Java.

Don't be afraid of that Hello World program anymore.

Java Works With Primitive Data Types

Java is not 100% OOP language in nature, it also works with primitive data types.

Well, after learning that the Java Hello World program deals with OOP concepts and now getting to know that Java is not 100% OOP language, I felt relieved, because you know, C++ works with primitive data types and even though Python is dynamically typed, behind the scenes it works with primitive data types, then it means that learning curve would be same for anyone learning a new programming language.

But, Java aims to be 100% OOP language and to cover primitive data types, it offers wrappers around primitive types. So, for each primitive type, there is a corresponding class we can rather use.

int i = 0;
// is same as
Integer i = 0;

Taking the above example, int is a primitive data type and Integer is a wrapper class around it.

Then, how can it directly assign an Integer type variable to a primitive value when we know that it is a wrapper class? It is accomplished using autoboxing. Similarly, we can directly use the Integer type value or any other wrapper class value using unboxing whenever needed within the program.

Both autoboxing and unboxing are done by JVM behind the scenes and can also be done explicitly, so you do not need to worry about it much. Also, this article is not intended to help you learn auto/unboxing, but it's better to know the inner workings and I would recommend you to check the link provided.

A Lot Of Similarities

After spending a lot of time learning Java, I figured that it is not much different from Python when it comes to programming language concepts. As they say, learning another programming language is easy when you know one already.

• Python provides conditional statements so does Java.
• Python has looping constructs like for and while, and so does Java. Only they differ in syntax.
• Python provides exception handling using try-catch and so does Java.
• Python can be used for OOP, guess what, Java is OOP.
• Python can be used for functional programming, and so does Java.
• Python provides list, set and dict and Java have ArrayList, HashSet and HashMap.
• Python is used for competitive programming (CP), and Java is 2nd most used programming language for CP after C++.
• A big community of developers to help each other out.

So, with all these similarities we can be less worried about learning Java.

Not Everything Is Similar

Even though Java and Python are a lot similar in many concepts, there are some things that Java differs on and these are some of them:

• Java have access modifiers. public, private, protected and package-private.
• Java works with interfaces. Java defines interfaces to provide the ability of a can relationship between classes, similar to what an abstract class defines, is a relationship.
• Inner classes in Java are handled very differently than in Python.
• static members in a class can be defined. Although, Python have @classmethod and @staticmethod, but as Zen of Python says, we are all adults here!
• Generic classes. One step closer to being dynamically typed classes!
• 2 IO packages, java.io and java.nio. java.io has similarities to traditional input/output programmes that we are used to. But, java.nio is something else completely. It uses channels/buffers and sometimes selectors to perform the reading/writing of data.
• Serializable interface, helps when we need to output classes to streams.
• It provides the java.sql package as an out of the box library to directly connect with databases in a very OOP way using JDBC drivers.

There are many more dissimilarities, but now we get a general idea that both Python and Java are similar and dissimilar on many points giving different advantages.

An Ocean Of Opportunities

When Java gets used with frameworks like spring, it becomes a beast of a language, providing almost all the capabilities that we need in general to develop fully functional end-to-end applications.

I am still learning a lot in the Java tech space and will continue to do so, you can also start learning it or any other technology that you feel intimated by and you will soon realize that it's not that difficult and easy to apply in your daily dev tasks.

At the end of this article I just want to say that - when you stop learning and experimenting, you start ignoring those opportunities that lie in front of you.

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala to Java.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

With the year coming to an end, when I look back at how it started and how it is going to end, I think I can proudly say that this year was much more exciting, inspiring and full of learnings.

I ended the year 2020 with no books to show, but with the start of the year 2021, I made sure to read at least a book per month. And, here I am bringing you the list of 13 books that I read this year and which you can include in your reading list for the next year.

Without further ado, let's dive into the books I read!

The Alchemist

The Alchemist is a novel by Paulo Coelho, a Brazilian author who first published it in 1988. It was originally written in Portuguese and became an international bestseller after being widely translated.

I started the year with none other than "The Alchemist". This was a re-read for me, also my first book I read as non-fiction.

The Alchemist stands out as a love story that rejects the notion that romantic love must be at the centre of people's lives. Each person has a unique destiny that is unaffected by the actions of others. It's the thing you'd do or be if you had all the love and money in the world.

It doesn't matter if you enjoy reading novels or not; there are those that everyone should read, and "The Alchemist" is one of them. It instils faith in love, dreams, and oneself. The finest thing you can do is follow your dreams.

If you have not read it already, then start next year this motivational impetus.

Dharmayoddha Kalki: Avatar of Vishnu

A work of fiction that takes inspiration from the life of Kalki, the idea of Kaliyug and other Mahabharata and Ramayan references. Written by Kevin Missal.

This is part 1 of an awe-inspiring trilogy that I re-read this year and is also my first read on mythological fiction.

The premise is intriguing, as it includes characters from prior Vishnu Avataras such as Parshuram, Ram, and Krishna. As you progress through the book, you'll notice that all of the parts are falling into place in accordance with certain old myths while also establishing some new ones.

I liked how the author strives to give us a full description of weapons and manoeuvres throughout fight scenarios. I would not recommend this book to extremely young readers because there is a lot of violence in this cruel society setup.

Satyayoddha Kalki: Eye of Brahma

This is part 2 in the trilogy, it continues with a cliff-hanger from part 1 (read part 1 to know the cliff-hanger 😉).

When compared to Dharmayoddha, the storytelling in Satyayoddha has clearly improved, owing to the fact that the premise is now more recognisable to the readers, and they have a better notion of what the characters are like. Kalki channels a few more Avatars in this book and both Narasimha and Varaha are quite impressive with their different philosophical takes on their actions.

There is a lot of action in this book, so the dialogues are short and interchanges are quick, funny and sarcastic at times. The characters might live in Illavarti of unknown times, but they speak like us!

Mahayoddha Kalki: Sword of Shiva

This is the last part of the trilogy, here, when we left the numerous characters of this world at end of Satyayoddha Kalki, the threat of war was imminent with so many factions moving against one another. While the personal battles of the main characters were also reaching turning points.

Mahayoddha Kalki takes us back to the multiple stories including Kalki’s journey towards Bhargav Ram‘s abode, Manasa‘s quest for revenge against Kali and the inner struggles for kingship at Illavarti.

Kalki, remains the adorable, good incarnate, a strong warrior who braves all odds and deals with the conspiracies that mark his way throughout the journey to finally become the Avatar of this Yuga.

You should definitely include this in your reading list.

The Richest Man in Babylon

The Richest Man in Babylon is a 1926 book by George S. Clason that dispenses financial advice through a collection of parables set 4,000 years ago in ancient Babylon. The book remains in print almost a century after the parables were originally published, and is regarded as a classic of personal financial advice.

This is the book I read for the first time this year and also my first read on personal finance.

How often is that we seek advice on personal finance from experienced people? How often do we implement that advice? And, how exactly are they able to give such solid advice? The Richest Man in Babylon, is the book that asks these questions, considers several scenarios (that are still valid to this date given that the book was first published in 1926), gives a proper plan to personal finance that could lead a person to become rich and have enough in his pocket so that he could enjoy his retirement!

I have done a review on the same book, you can check that out here and please include this to your reading list, it is a must for everyone in my honest opinion.

Rogue Lawyer

Rogue Lawyer is a novel by John Grisham. It is a legal thriller about unconventional street lawyer Sebastian Rudd.

The plot follows Rudd's (protagonist) involvement in a number of seemingly "unwinnable" cases, as well as the steps he takes to improve his client's chances. All of the narratives are intricately linked to Rudd's personal life and are loosely connected. This has an incredibly intrusive and objective look at a court and gets right into the heart of the realities of trying cases, with a remarkably refreshing perspective.

It was really a thrilling read of how a lawyer (kind of honest but rogue) fights against the system at every turn shown through a collection of criminal cases and how he tackles his day-to-day life, especially the encounters with his wife.

The Immortals of Meluha

The Immortals of Meluha is the first book of Amish Tripathi, the first book of Amishverse, and also the first book of Shiva Trilogy. The story is set in the land of Meluha and starts with the arrival of the Shiva. The Meluhans believe that Shiva is their fabled saviour Neelkanth.

The story is a perfect blend of modern-day technologies and Hindu mythological legends. Every character is described well and in an informative manner. Whether it is a war sequence or a simple conversation, Amish's writing hooked the readers. The narrations are explicit, as well as the language.

Amish creates a world of fantasy in his book, including corruption, caste system, unnecessary laws, and enters the readers' hearts. I definitely recommend this book; if you're a mythological fan, don't miss out on this book.

The Secret Of The Nagas

In the second part of the Shiva trilogy, the hunt is on. The sinister Naga warrior has killed his friend and now stalks his wife. Shiva, who is the prophesied destroyer of evil, will not rest till he finds his demonic adversary. His vengeance and the path to evil will lead him to the door of the Nagas, the serpent people. Of that he is certain. In a journey that will take him across the length and breadth of ancient India, Shiva searches for the truth in a land of deadly mysteries – only to find that nothing is what it seems.

This book is full of turns and will have you skipping pages like never before.

The Oath of the Vayuputras

In the last part, everything is explained ideally so that readers don't have any loose ends. This book is all about the equilibrium between virtue and vice. It portrays that whenever darkness rises, it will be destroyed by the light. However, the people chosen by God will build a new path despite the loss they have to endure. The battle demanded sacrifices, and in this story, it took everything from Shiva. Even his reason to smile and live.

I Will Teach You to Be Rich: No Guilt. No Excuses. No BS. Just a 6-Week Program That Works

I Will Teach You To Be Rich is a 2009 personal finance book by Ramit Sethi who writes a blog of the same name.

I Will Teach You to Be Rich is aimed at 20-to-35-year-olds, and it’s essentially a guide to getting your finances on track. The book covers a six-week program that automates saving and jump-starts investing — with more than a little information on banking, budgeting and entrepreneurship along the way.

This was a very fun read that has a crazy perspective on how to spend money. It is not like any other personal finance book out there, it gives you the required framework so that you can enjoy your life and have enough saved to enjoy your retirement also.

Think and Grow Rich

Think and Grow Rich is a book written by Napoleon Hill in 1937 and promoted as a personal development and self-improvement book.

This book tries to explain why some people amass great fortunes while others fail to make ends meet. In one of the chapters on "Desire", Napoleon Hill tells us the story of his child, born deaf-mute. Seeing him, he says to himself “I want my son to hear and speak, I want him to have a normal life.”

The book discusses the concepts of dominant thinking, desire, faith, subconscious auto-suggestion, imagination, taking action, making decisions, having a mastermind group, power of sex transmutation and how to defeat the six ghosts of fear.

It is again a must-read, give a lot of time while reading this book, don't skip-read this, try to understand what each line is trying to tell and the meaning it contains.

Skipping Christmas: Christmas with The Kranks

Skipping Christmas is a comedic novel by John Grisham. It was published by Doubleday on November 6, 2001, and reached #1 on The New York Times Best-Seller List on December 9 that year.

While it stresses giving back to the community, like most other secular offerings throughout the Christmas season, it's a reasonably clean, enjoyable read for the holidays. If you can get beyond that stumbling block, though, this could be a delightful way to spend your holiday break.

The festive outline of the book is not limited to Christmas, it can have parallels with other festivities, but it is a good read for the winter season without a doubt.

The Girl on the Train

The Girl on the Train is a 2015 psychological thriller novel by British author Paula Hawkins that gives narratives from three different women about relationship troubles and, for the main protagonist, alcoholism.

It is a fantastic read, Hawkins does a great job with both the mystery elements, the character development and with great attention to detail, it is a tight, suspenseful chiller with a dubious narrator, who tries to solve the mystery of a woman's disappearance.

I recently finished this book and my god, you will definitely love every page of this book. Don't wait and grab a copy of yours today.

Winding Up

With the year coming to an end, I am taking a week break from reading books. I am linking all the books below for you to purchase or you can directly purchase them from your nearest retail outlet.

Enjoy your holidays and a happy new year 🎉🎉🎉

Links

1. The Alchemist
2. Dharmayoddha Kalki: Avatar of Vishnu
3. Satyayoddha Kalki: Eye of Brahma
4. Mahayoddha Kalki: Sword of Shiva
5. The Richest Man in Babylon
6. Rogue Lawyer
7. The Immortals of Meluha
8. The Secret Of The Nagas
9. The Oath of the Vayuputras
10. I Will Teach You to Be Rich: No Guilt. No Excuses. No BS. Just a 6-Week Program That Works
11. Think and Grow Rich
12. Skipping Christmas: Christmas with The Kranks
13. The Girl on the Train

Till next time!

Namaste 🙏

This article is divided into 4 sections, 1^st section is about blockchain fundamentals, 2^nd section deals with the key features of building a blockchain mobile app, 3^rd section dives into cryptocurrency wallets available for us to use and 4^th section outlines how the opensource is driving the blockchain revolution.

You can jump onto any section you like to read, the order of reading these sections are not related.

Blockchain Fundamentals

Blockchain technology is a constantly evolving, secure and shared record-keeping system in which each user has a copy of the data, which can only be modified if all parties involved in a transaction agree. This section examines the fundamentals of blockchain technology.

A Blockchain Transaction

To understand the fundamentals of the blockchain, we need to understand how a transaction can be added to the existing blockchain. This can be done by going through a few important steps, as illustrated in the below figure.

1. Assume that user 1 wants to send X amount of digital bitcoins to user 2. User 1 then initiates the transaction.
2. A transaction is initiated by user 1's node by first making it and then digitally signing it with its private key. A transaction in a blockchain can reflect a range of actions.
3. A peer-to-peer (P2P) network broadcasts the desired transaction to each individual computer (or node).
4. Individual nodes receive the request and attempt to validate the transaction using cryptographic techniques. The miner node is the final node in the validation chain. These miner nodes are compensated in Bitcoin.
5. The verified blocks are now added to the blockchain network. Hashing is used to connect these nodes.
6. The approved transactions are then recorded in a public ledger. Transactions are completed and the ledger is updated after the block is added to an existing chain.

Cryptography Techniques Used in Blockchain

Hashing, public-private key mechanisms, and digital signatures are the key cryptographic techniques used by the blockchain community. In this case, a hash feature is implemented to offer each user the opportunity to view the blockchain in its entirety. Blockchain characteristically uses the SHA-256 hashing algorithm. Public-private key pairs are used to gain access to the information and allow transactions. Digital signatures are also used for multi-signature contracts and digital wallets on the blockchain, as well as to ratify transactions by signing them securely (offline).

Working of A Blockchain Network

In a blockchain network, each node holds a complete copy of the distributed ledger. The four fields of a block in this network are the block number, the data field, the hash value, and the nonce. Miners adjust the value of nonce to make it a suitable number for hashing the value of a block. A nonce is a random whole number that is a 32-bit (4-byte) field that is changed by miners to make it an acceptable number for hashing the value of a block. In addition, the chain of blocks is generated by applying the hash of the previous block to the current block. The previous block's hash is stored in the field prior.

Four zeros are used to begin the hash value. This determines whether or not a block is valid. Each new hash value is created by combining the old hash value, the new transaction block, and a nonce. The hash cash difficulty factor is determined by the number of leading zeroes required in the hash output. The difficulty is tweaked so that block production stays consistent at about one block per ten minutes. The more difficult it is to alter the blockchain, the tougher it is to overwrite the blockchain and double-spend coins.

Winding Up

Blockchain technology is widely accepted by a variety of businesses. It has opened up a plethora of opportunities in the areas of healthcare, finance, accountancy and the online marketplace. The adoption of blockchain technology is expected to grow manifold in the coming years, offering quite a wide range of jobs for young aspirants.

Basics of Building a Blockchain App

A blockchain stores data in such a way that it is almost impossible to alter or hack it. In this section, we will go through the key features of the blockchain, look at blockchain development platforms, and view the steps in the blockchain mobile app development process.

Some Blockchain Apps

While blockchain development began with cryptocurrencies, it is no longer limited to them. Blockchain applications have now gone beyond cryptocurrency and into a variety of other sectors. As we all know, the main benefit of blockchain technology is that it ensures maximum data transparency and security, helping businesses and organisations save a significant amount of money on standard security methods.

The following are some useful blockchain apps.

1. Filament: This is an excellent example of a blockchain-based IoT app that uses blockchain data ledger systems to manage data processed by software and microchip hardware. Several linked devices can communicate information over the blockchain and keep in sync with the help of the app.

2. KYC-chain: For many firms, completing Know Your Customer (KYC) documentation is a must. This simple and effective blockchain-based program streamlines the entire process of handling client documentation across administrative and criminal databases in many nations.

3. BurstIQ: BurstIQ is healthcare software that uses Big Data and blockchain technology to allow patients and doctors to share and collaborate on vital medical information.

Development Platforms

There are more than two dozen blockchain development platforms. A few of them are described below.

1. Multichain: With this powerful platform, developers can create and deploy private blockchains that can be used by a variety of businesses.

2. Hyperledger: This distributed ledger technology is used to govern the connected ecosystem of things and supply chains. This advanced blockchain platform has received a lot of acclaims.

3. Ethereum: A versatile opensource blockchain technology, Ethereum is commonly used for decentralised apps, smart contracts and initial coin offerings (ICOs).

4. EOS: The EOS platform’s goal is to create a reliable smart contract function. It’s also appropriate for modern businesses’ need for highly scalable and decentralised storage and hosting.

Blockchain systems are available in a wide range of sizes and shapes. Determining which platform is better and more suitable for one's application needs might be confusing. The solution is contingent on the desired capabilities and use-cases.

Choosing the most appropriate platform: The key to your project’s success lies in determining the platform’s character. Platforms based on cryptocurrencies as well as those based on smart contracts are available.

Decide whether you need smart contracts or not: You need to determine if your app needs smart contracts or not.

Selecting the consensus protocol: The consensus protocol ensures that every new block added to the blockchain is the only version of the truth that all nodes in the blockchain agree on, such as proof of stake, proof of work, proof of elapsed time, and so on.

Choosing the cryptocurrency: Another challenge is determining whether or not a cryptocurrency is required.

Selecting between a public and private network: Based on the requirement, you need to decide whether a public or a private network is needed.

Process of Blockchain Mobile App Development

There are mainly five stages in the blockchain app development process.

1. Identify the problem that the blockchain is required to solve: To begin, thoroughly examine the problem description and create a full report on it. Consider whether you need to create a new app from scratch or if you can just integrate the blockchain into an existing one.

2. Select the best platform for the app: Select the most appropriate platform for your project. Determine if you need a smart contract app or a crypto-transaction app, as well as the type of network and consensus protocol you'll need.

3. Requirement analysis: Begin by doing the requirement analysis and evaluating the app idea’s requirements. Do more brainstorming around the idea and, if possible, fine-tune it.

4. Create a blueprint of the idea: Try to develop the proof of concept that will put the entire app concept into a visual structure.

5. Development of the application: Develop the application employing best practices. Ensure to build a robust blockchain app.

Winding Up

We’ve covered the basics of blockchain in this essay — its main characteristics, as well as several development platforms and stages for developing blockchain applications. If you find the subject interesting, you can delve deeper into it. There are a variety of resources available on the Internet.

Cryptocurrency Wallets

Cryptocurrencies are getting entrenched in the global financial system slowly and steadily, with certain companies using these to pay their employees too. Hesitancy with respect to their use is slowly ebbing, and you may run the risk of being behind the times if you don’t stay updated on the latest trends in this domain. This section lists the exchanges and wallets you should be aware of in case you want to buy or trade-in cryptocurrencies.

Trends in Cryptocurrencies

Due to the high potential for profit, cryptocurrency trading is considered extremely lucrative, particularly among the younger population. Traditional stock market trading has a lot of restrictions and rules. There are no such limitations in the case of cryptocurrencies, and big profits can be produced immediately. The 'crypto market,' in which 'crypto users' trade various types of cryptocurrencies, is also known as the cryptocurrency industry.

The price of a BitCoin (BTC) was less than one US dollar around 10 years back when it was launched. Today, its price is more than US$ 30,000. A few months ago, its price touched around US$ 60,000, proving it is a very attractive form of investment.

The market capitalisation of cryptocurrencies is around 338 million US dollars, with 13,951 BitCoin ATMs located in different parts of the world, as per a report from Statista.

Wallets and Exchanges

Currently, there are a number of exchanges in the world that offer platforms and wallets for buying and trading cryptocurrencies. These include Web-based environments as well as apps for Android, iPhone and other mobile phone platforms. Crypto users can buy and sell different currencies that are legal tender around the world with ease on these sites.

The major worldwide crypto exchanges in the world that provide wallets and Web platforms for cryptocurrency trading are listed in the below figure. In crypto exchanges, pairings refer to the pairs of cryptocurrencies that are used to buy and sell such coins.

In the crypto world, there are two types of exchanges and wallets — centralised and decentralised.

Centralized Exchanges

The centralised exchanges and wallets are owned by companies or corporate giants, which record the complete Know Your Customer (KYC) details either through video KYC or paper-based KYC. Users can open accounts in these centralised exchanges and then trade in any cryptocurrency.

The below figure lists some centralized exchanges.

Decentralized Exchanges

Decentralised exchanges are platforms on which the account is opened directly without any intermediate company, and trading is done directly by the crypto users.

The below figure lists some decentralized exchanges.

Winding Up

The jury is out on the use of cryptocurrencies because these are sometimes used to circumvent the national money transfer system. Some governments prohibit their use in order to prevent money laundering.

In order to incorporate the maximum benefits and features into a real-world scenario, the use of cryptocurrencies in any country demands legislation and procedures. The benefits to society and the corporate sector might be substantial if cryptocurrencies are used for real-time applications and e-governance.

Open Source Blockchain Revolution

Blockchain is a disruptive technology that is changing the world in a variety of ways. Cryptocurrencies are the most obvious example. This section compares and contrasts this technique with opensource, another revolutionary technology that has transformed software development.

Blockchain Characteristics

Immutability: A hallmark feature of blockchain is that it is incorruptible. Data once saved in a block cannot be changed without breaking the chain.

Decentralisation: Blockchain does not require a central authority to maintain the ledger. All nodes in the network have a copy of the ledger that gets updated with every transaction.

Enhanced security: Decentralisation and consensus mechanisms built into blockchain make it highly secure, as every transaction has to be verified with ‘proof of work’.

Distributed: The blockchain ledger is not a singular entity in the hands of a few; instead it is a shared entity that is accessible and maintained by everyone in the network.

Transparency: Every addition to the blockchain requires consensus from all nodes in the peer-to-peer network. This makes every transaction transparent and public.

Open Source Characteristics

Transparency: The founding principle of open source is to make the source code of the project public. This enhances the transparency of the project, as every detail that goes into its development can be freely accessed by anyone.

Enhanced security: Finding security loopholes in the software is way easier when the code is non-proprietary and is publicly available. This naturally enhances the security of the software or, at the very least, can help raise public awareness about the potential security-related pitfalls.

Collaboration: The primary purpose of open source software is to encourage other developers to collaborate and contribute to the development of the software. This makes open source development, by nature, a community experience.

Modifiability: Open source software can be modified and re-distributed to solve different problems. This is the case with Linux, as its modified ‘distributions’ are used in various different gadgets and computers.

Decentralisation: One can argue that open source software is not inherently decentralised as making changes to the main project still requires the approval of the project moderator(s) and the owner(s). But if perceived from a different angle, given that the source code can be modified and re-distributed under proper licensing, this gives the developer the autonomy to use the software as and how desired thus making the process decentralised.

Convergent Evolution

Opensource software and blockchain are two independent technologies with different themes and strategies for addressing different problems. When we compare the attributes of blockchain to open source, however, we discover certain similarities.

In evolutionary biology, the term 'convergent evolution' refers to the occurrence in which animals from distinct time periods or epochs acquire similar characteristics. This can be seen in molecular biology, animal morphology, and even plant morphology. This holds true for technical breakthroughs as well. We produce new technologies every day to address a wide range of problems; nonetheless, there are underlying patterns in the motivations that drive the creation of these technologies.

Winding Up

Blockchain is new, but open source technology has been around for a long time. In my perspective, the rise of open source technology has had a direct impact on the birth of blockchain. Both technologies are focused on transferring power from a small number of people to a big number of people. Both strive to increase product security and transparency while also promoting fairness and collaboration. While the applications of open source and blockchain are diverse, the motives for their creation are similar. It is safe to assume that open source and blockchain share many characteristics in common and are hence the product of technological convergence.

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

Just as open-source has been the primary reason for the Big Data revolution, so has it been at the forefront of developing tools to counter the challenges that we face with the data. And while there are hundreds of popular open-source projects that are focused on Big Data management, in this article, we shall focus on the top three that caught my attention.

We shall discuss the Hadoop framework, the Spark analytics engine and the Kafka framework.

Is Big Data Hard To Handle?

• Almost 90% of the Big Data we produce today is unstructured and there are no predefined models that it adheres to. And there is no quick and easy way to access and analyse unstructured data.

• Not only is Big Data unstructured, but it is also extremely complex. This means traversing through it requires advanced algorithms that are being run on top of grade-A machinery and not everyone can afford that.

• We have multiple sources from which we accrue data and there are no clean ways to integrate disparate data from so many sources.

• With Big Data comes big mistakes. Storing massive and complex data in a secure manner is a really daunting challenge. It is also the need of the hour. Since the beginning of the pandemic, more people are stuck at home with their computers than ever before and cybercrime and data theft have gone up by 400%.

Open Source Softwares

Hadoop

Developed by the Apache Foundation, Hadoop is a framework for Big Data management. It uses distributed systems architecture, which has the ability to store and easily access vast amounts of data.

While there are many different types of Big Data management solution software, what makes Hadoop stands out are 3 components, HDFS, MapReduce and YARN.

• HDFS (Hadoop Distributed File System)

The Hadoop Distributed File System (HDFS) is a powerful and dynamic tool that is efficient at handling Big Data. HDFS breaks down Big Data into blocks and the default size of each block is 128MB. This makes accessing data simple, as the HDFS only has to access the specific block of data that the user is searching for. HDFS is a resilient framework, thanks to its replication methodology. To maintain the accessibility of the data even when one of the distributed system blocks is down, HDFS replicates that block data in a three-fold fashion making it robust to avoid failures or inconsistency.

• MapReduce

Storing and accessing Big Data, with all its complications and difficulties, is still the easy part. The real fun begins when we try to process Big Data. MapReduce is exactly what it sounds like, it maps the data followed by reducing it. MapReduce takes the data as input and splits it into different parts. It then maps each individual component within each part. Then the data is shuffled and sorted into clusters of homogenous data. The data is then reduced by integrating homogenous data and assigning IDs, which give the smaller final output.

• YARN (Yet Another Resource Negotiator)

A Hadoop environment is constrained to the number of resources it has, namely, CPUs, memory units, storage space, etc. But since Hadoop is designed to be able to run multiple processes at the same time, a mechanism for allocating resources is necessary to make sure there are no deadlocks and every task is accomplished in its desired time period. Now, YARN comes into play, when a job requires the resources to run, the application manager sends a request to the node manager to allocate the physical resources. The node manager then sends the resources to the resource manager, which assigns the physical resource to the client process.

Spark

While HDFS, MapReduce and YARN are the three major defining components of Hadoop, the Hadoop ecosystem has more tools to offer when it comes to Big Data processing, one such tool is Apache Spark. Spark is one of the few tools in the industry that combines Big Data analytics tools with Machine Learning and AI. Spark is 100 times faster than MapReduce in processing data. Spark computations are done in memory itself, it has the ability to perform both batch processing real-time processing of data. Spark is also comparatively lightweight as most of it is written in Scala.

Following are the Spark components:

• Spark Core
• Spark SQL
• Spark Streaming
• Spark MLib
• Spark GraphX

Kafka

Apache Kafka is a framework implementation of a software bus using stream processing. If you break down an information transaction on the Internet, it's essentially nothing but an exchange of information between 2 systems which we sometimes call producers and consumers. Each transaction can be thought of as integration between producer and consumer. In order to simplify complex integrations, Kafka acts as a broker between producer and consumer, which can be well integrated with Hadoop and Spark.

Kafka consists of Brokers and a Zookeeper.

• Broker

A broker is a Kafka server that runs in a Kafka cluster. Each broker divides a unique transaction between the producer and consumer into a topic. Now, these topics within the broker are used to consume and broadcast the messages in an asynchronous fashion.

• Zookeeper

In order to define topics and keep a metadata record of all the topics defined in the cluster, Kafka uses Zookeeper which is a replicated distributed log with a file system API built on top. It keeps a record of all the topics within all the nodes and also keeps track of which nodes are down and which are up and running.

Where To Go From Here?

The tools and frameworks discussed in this article are a high-level overview of the innovation and efforts taking place in the Big Data management industry. There are many more open source tools and frameworks that can be learned and used for Big Data management.

Google all the available resources and check which fits your Big Data management need to the point and become a Big Data Engineer one step at a time.

Books to check out more on Big Data Engineering:

• Big Data Simplified
• Big Data Analytics, Introduction to Hadoop, Spark, and Machine-Learning
• Big Data and Analytics

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

What is HacktoberFest?

Hacktoberfest 2021 will be a month-long virtual festival event to celebrate open source contributions. It is the easiest way to get into open source!

During the entire month of October 2021, all you have to do is contribute to any open-source projects and open at least 4 pull requests. Yes, any project and any kind of contribution. You don’t need to be an expert in programming or coding. It can be a bug fix, improvement, or even a documentation change (I don't recommend it, explore where you can do code changes if there are not many)! And win an awesome T-shirt and awesome stickers.

The Hacktoberfest’s simple plain objective is:

Support open source and earn a limited-edition T-shirt!

But, it’s not just about the t-shirts or stickers. It's about supporting open source. It's about celebrating open source and giving it back. If you’ve never contributed to open source before, this is the perfect time to get started because Hacktoberfest provides a large list of available contribution opportunities (and yes, there are always plenty for beginners too).

HacktoberFest 2021

Let's look at some of the most awesome beginner-friendly repositories that you can look at and start your contributions right off the bat.

For Complete Beginners

This section contains repositories for complete beginners. You can go and learn about first contributions and how to raise PRs.

• Hello Open Source

Yeah, self-promotion, I know but you can still check this out, no need to wait till October, go ahead and contribute to this and be more comfortable while doing other contributions during HacktoberFest.

Note: During HacktoberFest, this repository accepts only 1 contribution per user.

• First Contributions

Another awesome repository for you to check. This project aims to simplify and guide the way beginners make their first contribution.

• Start Here Guidelines

Again, an awesome repository for you to start with. This is hosted by one of my favourite institutions, Zero To Mastery. They always create awesome projects for people to contribute to during HacktoberFest. You can check out their previous projects as well here.

• Resources

Add meaningful resources to the list and help others on their learning journey. This is one of the best resources repository available on GitHub. Do check it out and contribute that link to a course or article you feel is important for others to take note of.

For CSS Enthusiasts

• sButtons

Simple buttons you can use easily for your next project. Check out this and contribute the next button design you have in mind.

• CSS Grid Learn Game

This is a game to learn CSS Grid in a Game Mode Style, to make learning more fun! Contribute and make this even more interesting.

For Python Players

• OpenCiviWiki

It is an open-source, non-profit community, working to develop a democratic engagement web system. Check out their README.md file and give a head start to your contributions.

• Babel

Babel is a Python library that provides an integrated collection of utilities that assist with internationalizing and localizing Python applications (in particular web-based applications). An awesome library you can get your name on!

• Kinto

Kinto is a minimalist JSON storage service with synchronisation and sharing abilities. Check out their easy-pick issues.

• Kinto.sh

It provides Mac-style shortcut keys for Linux & Windows. Seamless copy and paste with all apps and terminals. The zero effort solution. Well, go ahead and make your own shortcuts.

• BorgBackup

BorgBackup (short: Borg) is a deduplicating backup program. Optionally, it supports compression and authenticated encryption. Search for easy label issues and backup like never before.

Other Repositories (that you might already know)

• Ansible
• Mypy
• Bokeh
• Pytest

For JavaScript Lovers

• Name Suggestion Index

The goal of this project is to maintain a canonical list of commonly used features for suggesting consistent spelling and tagging in OpenStreetMap. Well, this is your chance to be a contributor for OpenStreetMap.

• MissionControl

Mission Control is a service running on the DAV network, and serving as a marketplace connecting DAV users, vehicles, and services. Go ahead and contribute to this awesome DAV running service and sharpen your networking skills using javascript.

• PouchDB

PouchDB is an open-source JavaScript database inspired by Apache CouchDB that is designed to run well within the browser. PouchDB was created to help web developers build applications that work as well offline as they do online. Help this awesome project grow with your innovative ideas.

• Dragula

Have you ever wanted a drag and drop library that just works? That doesn't just depend on bloated frameworks, that has great support? That actually understand where to place the elements when they are dropped? That doesn't need you to do a zillion things to get it to work? If so, then this is the right place for you to contribute your ideas.

• Kinto.js

The idea is to persist data locally in the browser by default, then synchronizing them with the server explicitly when connectivity is guaranteed. It is an offline-first javascript client for kinto, do check it out and contribute.

• Ember.js

Ember.js is a JavaScript framework that greatly reduces the time, effort and resources needed to build any web application. It is focused on making you, the developer, as productive as possible by doing all the common, repetitive, yet essential, tasks involved in most web development projects. Contribute and help developers be more productive.

• Ghost

Ghost gives creators tools to launch their own subscription business. They are redefining the creator economy. Go ahead if you are a creator or want to support their cause, it will be amazing.

Other Repositories (that you might already know)

• Hyper
• Moment
• React
• React Native
• Next.js
• Electron
• Jest

For Scala Functionaries

• Metals

Scala language server with rich IDE features 🚀. Go ahead and start contributing to this awesome repository.

• Twitter Util

This project is used in production at Twitter (and many other organizations) and is being actively developed and maintained. You can check out their contributing guidelines and become a part of the Twitter developer network.

• Play Framework

The Play Framework combines productivity and performance making it easy to build scalable web applications with Java and Scala. Play is developer-friendly with a "just hit refresh" workflow and built-in testing support. With Play, applications scale predictably due to a stateless and non-blocking architecture. By being RESTful by default, including assets compilers, JSON & WebSocket support, Play is a perfect fit for the modern web & mobile applications. Go ahead and contribute to this beast of a framework.

There are so many repositories that I want to include, but that would just make this a messy article. Keeping things short and simple, let's move on to what you should do now.

Take this as homework and go over GitHub or GitLab and search for beginners issues and repositories and see which resonates with you and just without thinking much, start with your first contributions during this HacktoberFest 2021! All The Best!

Note: Do not do meaningless contributions like adding extra space or changing the font in documentation, add your programmer thoughts to it before making contributions and explore, give it as much time as it needs for your meaningful contributions to reflect in your choice of project.

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

The only drawback people face when working with Python is related to its speed of executing programs. But is there any other programming language as easy to understand and to get started to work with? Yep, there is, Scala comes to the rescue!

Python faces speed issues mainly due to its interpreted nature, whereas Scala is a compiled language that offers dynamic typing as well (close to 90%), many new features in Python like pattern matching are already present in Scala since the beginning, there are awesome syntactic sugars in Scala that allows us to write even less code when compared to Python and also Scala being a functional programming language does not shy away from object-oriented programming as it is run over JVM.

When it comes to the syntax of these programming languages, there are a lot of similar patterns and some differences as well, but overall they both offer a lean learning curve with endless opportunities in the software engineering world.

So, let's discuss those similarities and differences in the form of a cheat sheet, which not only helps in refreshing some concepts from Python/Scala but also acts as a guide to learn Python or Scala for someone coming from the Scala or Python background respectively.

This will be a to-the-point kind of article, with little to no explanation but with necessary links wherever needed.

So, let's get started!

How To Import?

In Python importing a library can look like this:

import math.*

# OR

import math.pow

# OR

from math import pow, sqrt

# OR

from math import sqrt as squareRoot

In Scala importing a library can look like this:

import scala.math._

// OR

import scala.math.BigInt

// OR

import scala.math.{BigInt, BigDecimal}

// OR

import scala.math.{BigInt => BInt}

How To Declare Variables?

Python offers dynamic typing so you don't need to declare variables beforehand like in C/C++, but you can just type out the variables and use them:

some_variable = 10

Scala also offers dynamic typing to some extent and infer that type during compile time:

val some_variable = 10  // infers it as Int type

How To Define Conditionals?

In Python and Scala defining conditionals are more or less similar:

v = 5
if v%2==1:
    print("Odd")
elif v==0:
    print("Zero")
else:
    print("Even")

In Scala:

val v = 5
if (v%2==1) println("Odd")
else if (v==0) println("Zero")
else println("Even")

The important thing to note in conditionals is that in Python conditionals are referred to as statements whereas in Scala these are expressions that evaluates to something or nothing.

How To Define Loops?

In Python a simple for-loop would look like this:

for i in range(10):
    # do something here

The same for-loop in Scala would look like this:

for {
    i <- 0 until 10
}   {
    // do something here
}

The difference in their respective working behind the scenes, in Scala, is the use of conjunction of map and flatMap methods whereas in Python it is simple iteration.

There is a while loop in Scala, but let's not discuss that, while coding in Scala it is not encouraged to use while loops.

Why are while loops not recommended in Scala?

How To Write Methods?

In Python, we can simply use the def keyword to define functions, which are similar to methods in Scala.

def some_method():
    # do something here

In Scala we can define a method like:

def someMethod() = {
    // do something here
}

To define functions in Scala, we can use Function objects or their respective syntactic sugars. To know more about functions and functional programming in Scala, do check this.

How To Define Classes and Objects?

In Python, we can define a class using the class keyword, the same keyword can be used to define a class in Scala.

Whereas objects in Scala are singleton instances and similar to what we call static class in other programming languages.

A class however in Scala can be instantiated using the new keyword, whereas in Python calling the class directly creates an instance for that.

In Python:

class Student:

    def __init__(self):
        # do something here

student = Student()     # creates an instance of class Student

In Scala:

class Student

val student = new Student()     // creates an instance of class Student

// use Object keyword for singleton objects

Object Student

val aParticularStudent = Student

To know more about classes and objects in Scala, I recommend checking out this article.

Miscellaneous

Scala offers 2 more advantages over Python, namely traits and tail recursion.

Python does not offer tail recursive capabilities to its functions and suffers from stack overflow errors whenever functional programming goes wrong. To know more about why python does not offer tail recursion, you can read this article. However, there is a work-around as described in this article using decorators.

Similarly, Python does not have concepts like traits. A trait is used to describe the quality of a class, whereas in Python you would have to do multiple inheritances to get certain qualities or have to define certain methods within the class definition. Trait allows loose coupling.

How to define a trait in Scala?

trait SomeQuality

class Student extends SomeQuality

Wrap Up

Well, that wraps up this simple Scala Vs Python syntax cheat sheet.

What else would you add to this cheat sheet? Please let me know in the comments!

If you are looking to sharpen your coding skills in Python or Scala, then do consider buying these awesome books that go in-depth to let you understand the semantics of the language.

For Python:

• Python - The Bible
• Python - The Complete Reference
• Automate The Boring Stuff With Python
• Python Basics

For Scala:

• Scala For The Impatient
• Scala Programming Projects
• Functional Programming in Scala
• Programming Scala

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

It will be a no-nonsense, to the point kind of article (like part 1, part 2, part 3 and part 4) with all the necessary links wherever needed.

Without any further ado, let's get started.

Before We Start

Before we start coding out, first create a new object in the crashcourse package (please go through part 1 for more information on creating packages and objects).

Let's name it Collections like below:

Now, we can start coding out the examples on this Scala application.

Collections

Scala offers 2 sets of collections, one is mutable and the other one is immutable. Scala by default works with immutable collection objects.

But, we can import mutable collection objects whenever needed like:

import scala.collection.mutable

Also, if we want we can see all immutable collection objects in package scala.collections.immutable.

Following are some of the immutable collection objects provided in scala:

• HashSet
• SortedSet
• Vector
• StringLike
• Range
• List
• Stream
• Stack
• Queue
• HasMap
• SortedMap

Similar collection objects are available in the mutable set. This link has all the mutable collection objects set.

The commonality between mutable and immutable collection objects is that both extends trait Traversable. It is a base trait for all collections and offers a great variety of methods.

Some of these collection objects are often sequenced in nature. Let's discuss sequences now.

Sequences

Sequences in scala are a general interface for data structures that have a well-defined order and can be indexed.

These support various operations like:

• apply, iterator, length, reverse for indexing and iterating.
• Concatenation, appending, prepending.
• A lot of others - grouping, sorting, zipping, searching and slicing.

Let's see how to define a sequence:

Output:

Range is one of the sequences available, we can define a Range like this:

Output:

There is another type of sequence, LinearSeq which is an immutable linked list with the following properties:

• Accessing head, tail and using methods like isEmpty are fast and takes O(1) time.
• Most other operations like length or reverse takes O(n) time.

Arrays in scala are equivalent to java arrays, these can be manually constructed with predefined lengths. These can be mutated, have fast indexing and are interoperable with java's arrays.

Vectors are also present in scala, these are the default implementation for immutable sequences taking constant time for indexed based read/write, with fast append/prepend, shows good performance for large size vectors and are implemented using a fixed branched trie data structure.

Tuples are finite ordered kinds of lists that can contain a maximum of 22 elements. A tuple value data type is defined similarly to a function like TupleN[...].

There is one more collection object, Map, which is a key->value pair data structure present in scala. Following are some ways to manipulate a map:

Output:

More on Scala collections can be found here or you can check the books provided in the last section for the more detailed in-depth working of collections.

map, flatMap, filter and for

Finally, on the most important part of functional programming, that would become the daily need of a Scala programmer. I wanted to include these in the previous part but to show how these work I needed to show collections in scala first, now that we know enough about collections, let's move on to these functions.

Note: For the sake of examples, I will be showing these operations on the List sequence, you can try these on other collections as well.

First, define our list collection like this:

What is the map method? It allows a certain function to be applied to all the elements present in the given sequence and evaluates to a sequence of updated values.

What is the filter method? It filters out the elements which do not meet a certain criterion defined as another function and evaluates to a sequence of filtered values.

What is the flatMap method? This is identical to the map method, but the only difference is that in flatMap the inner grouping of an item is removed and a sequence is generated. So, if flatMap is applied to a list then the generated output will be a list of lists, changing the inner grouping of integer elements to a list and later flattening it.

What is the for loop in scala? Yeah, you read it right 'What is' and not 'How to', in scala, writing a for loop is just a fancy way of writing a coupled map and flatMap methods. A for loop in scala can be written as:

Output:

These are some important methods to remember while coding out in scala.

Wrap Up

Well, that wraps up part 5 and the end of this crash course.

I hope it was something worth it for you as a reader and made you a scala enthusiast at the end of this course.

You can pick up any of the below books to master the art of programming in scala:

• Scala For The Impatient
• Scala Programming Projects
• Functional Programming in Scala
• Programming Scala

To keep in touch, you can follow me on here or subscribe to get the updates of the new blogs that I will write in the future or follow me on Twitter where I share my thoughts not only on programming but also on personal finance.

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

It will be a no-nonsense, to the point kind of article (like part 1, part 2 and part 3) with all the necessary links wherever needed.

Without further ado, let's get started.

Before We Start

Before we start coding out, first create a new object in the crashcourse package (please go through part 1 for more information on creating packages and objects).

Let's name it OptionErrorPattern like below:

Now, we can start coding out examples on this scala application.

Options

An option is a wrapper for a value that might be present or not.

As the name suggests it evaluates to an option of 2 values, either Some or None, when given an expression. In this way, when we are dealing with some unsafe APIs, we can always wrap that API calls within an Option object to keep our program safe and error-free that might otherwise result in a Null pointer kind of exception.

For example,

Output:

• Some wraps a concrete value.
• None is a singleton for absent values.
• It is better to use Option in APIs that we are creating.

Handling Exceptions

In scala, exceptions are handled inside try-catch blocks, like below:

Output:

But, it comes with its drawbacks:

• Multiple/Nested try-catch blocks make the code hard to read/follow.
• We can not chain multiple operations prone to failure.

To overcome these limitations, scala introduced a Try object that can act as a wrapper to wrap an error-prone expression and evaluates to either a Success or a Failure as a result.

A Try is a wrapper for a computation that might fail or not. It wraps failed computations as Failure and successful computations as Success.

To use Try, Success and Failure objects, we have to import these first:

import scala.util.{Try, Success, Failure}

So, the above method someErrorProneFunc can be used with Try as follows:

Output:

We can check if a Try is a Success or Failure using isSuccess or isFailure methods respectively.

We can use Try to handle exceptions for avoiding runtime crashes due to uncaught exceptions or just to avoid an endless amount of try-catch blocks.

Pattern Matching

Pattern matching is a mechanism for checking a value against a pattern. A successful match can also deconstruct a value into its constituent parts. It is a more powerful version of the switch statement in Java and it can likewise be used in place of a series of if/else statements.

A match expression has a value, the match keyword, and at least one case clause.

For example,

Output:

Some important points to note on pattern matching:

• It is used to decompose values.
• Cases are matched in the order given.
• What if there was no case that matched the pattern, then it would result in MatchError.
• Pattern matching works really well with case classes.

Wrap Up

Well, that wraps up part 4 of this crash course.

I know, it was a very short read, my motivation was to keep it short and simple and be able to provide ample impetus to you to explore it further.

Take it as a challenge or homework, explore advanced pattern matching, how you can use Option in conjunction with Try (it can do wonders to the API you are working on) and in the comments, mention what you know about on these concepts.

You can check these books to get more insights on these topics:

• Scala For The Impatient
• Scala Programming Projects
• Functional Programming in Scala
• Programming Scala

In the next and last part of this crash course, we will discuss the collections available in scala and most important of all, the map, flatmap and filter methods in scala.

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

It will be a no-nonsense, to the point kind of article (like part 1 and part 2) with all necessary links wherever needed.

Without further ado, let's get started.

What Is Functional Programming?

The below is an excerpt from the Functional Programming in Scala book.

Functional programming (FP) is based on a simple premise with far-reaching implications: we construct our programs using only pure functions, in other words, functions that have no side effects. What are the side effects? A function has a side effect if it does something other than simply return a result, for example:

• Modifying a variable.
• Modifying a data structure in place.
• Setting a field on an object.
• Throwing an exception or halting with an error.
• Printing to the console or reading user input.
• Reading from or writing to a file.
• Drawing on the screen.

We discussed side-effects also in part 1.

Note: Functional programming is a restriction on how we write programs, but not on what programs we can express.

Before We Start

Before we start coding out, first create a new object in the crashcourse package (please go through part 1 for more information on creating packages and objects).

Let's name it FunctionalProgramming like below:

Now, we can start coding out examples on this scala application.

Creating Functions In Scala

Before moving on to create functions in scala, please keep in mind that scala works on JVM and for JVM it needs classes/objects to work with, hence everything in scala will be an object, even the functions are objects.

Note: Due to scala's syntactic sugar, we can still write functions in a more functional fashion.

Let's create a function in scala:

Scala has a collection of functions namely Function1 to Function22, which can be used out-of-the-box without any issues.

A function like Function1[String, Int] represents that it will take String as an input and evaluates to Int as an output. This function definition will be written in its apply method, as Function1 is an object and we need to override its apply method to make it callable.

A simple syntactic sugar for a function like Function2[Int, Int, Int] would be (Int, Int) => Int, which is more functional while reading the code.

We should also note that while working in IntelliJ, it tells us that the given Function1[String, Int] can be converted to its respective syntactic sugar, we can do so by hovering over the yellow line and simply clicking Replace FunctionN[A1, A1, ..., AN, R] with (A1, A1, ..., AN) => R.

Converted to syntactic sugar:

Important points to note:

• All scala functions are objects, that is, instances of Function1, Function2 and so on.
• JVM was designed for object-oriented programming, but using it for scala function we need something like objects (like Function1) to instantiate them.
• Functions are traits with maximum parameters to be 22.

Anonymous Functions

The anonymous function is something we saw in the previous example of Function2[Int, Int, Int] syntactic sugar.

So, the below expression:

can be written as:

or as:

Anonymous functions are just another way of writing functions as supported by scala's compiler, behind the scenes everything is the same.

More ways in which we can write anonymous functions:

Note: An anonymous function is also known as a function literal. A function that does not contain a name is known as an anonymous function in general.

Higher-Order Functions and Curries

Higher-order functions have at least one of the following properties:

1. Takes one or more functions as parameters.
2. Returns a function as a result.

In scala, a general higher-order function declaration can look like this:

These are called Higher-Order Functions, which essentially takes one or more functions as input and/or returns a function as output.

Moving on to curries, currying means transforming a function that takes multiple arguments into a chain of calls to functions, each of which takes one argument. Each function returns another function that takes the subsequent argument.

A simple curry can be like this:

Functions with multiple parameter list also act as curries:

Wrap Up

Well, that wraps up part 3 of this crash course.

I highly recommend you to go through the books below to get a better and deeper understanding of functional programming:

In the next part, we will discuss some topics specific to scala, like options, handling errors in a unique style and pattern matching (the most awesome thing in scala).

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

It will be a no-nonsense, to the point kind of article (like part 1) with all necessary links wherever needed.

Without further ado, let's get started.

Before We Start

Before we start coding out, first create a new object in crashcourse package (please go through part 1 for more information on creating packages and objects).

Let's name it ClassAndObject like below:

Now, we can start coding out examples on this scala application.

Classes And Objects

In scala, to define a class we use the class keyword:

We can directly use the Student class later in the program. That's it! that's how we can create a class in scala.

It is different from writing object Student as it is not instantiated right away, we have just defined it and are not using it anywhere. To instantiate a class we can use the new keyword.

A class can have parameters, like this:

Note: Class parameters are not class fields, which means we can not use these parameters with instantiated objects.

To make class parameters as class fields, we have to use the val keyword along with the name of the parameter, like this:

We can use class parameters within the class code block by using the this keyword if value name conflict occurs, like below:

If value name conflict does not occur, then the class method by default (implicitly) uses the this operator on class parameters values.

Some other important concepts:

• Overloading occurs with only different signature methods. More on overloading in scala here.
• Auxiliary constructor are generally used for default parameters. More on auxiliary constructor here.
• Instances are fixed, whenever we want to do something with the given class, say creating/updating something, then we would need to instantiate a new class, it is the clause of immutability, useful in functional programming.

Conceptually, scala does not provide class level functionality, like a static class. However, scala provides something called an object, using which we can obtain class level functionalities.

Scala objects are singleton instances by definition. We can create an object like the below code:

We can create an object with the same name as that of a class in the same scope, creating such an object/class is called companion object/class, known as companions.

Companions can be used to make a factory method in objects, that can help instantiate a class in a certain way. Using companions does not require using the new keyword to instantiate a scala class, we can define a method named apply within the object to handle instantiation.

We can create a companion like below:

Well, that's about it on classes and objects in scala. You can check out official docs on scala classes here and on objects here.

Anonymous And Case Classes

To create an anonymous class we can directly define the class like this:

Things to remember when creating an anonymous class:

• Pass proper parameters whenever required.
• Anonymous class declaration works for abstract as well as for non-abstract classes. It works for traits as well.

  Note: We will discuss abstract classes and traits in the next section.

• Useful for on-spot declaration in some scenarios.

Using the case keyword in front of the class keyword will make it a case class, like this:

Case classes promote class parameters to fields, it has a predefined toString method that evaluates to a representation that is understandable.

Equality and hashcodes are implemented out-of-the-box with a handy copy method to copy instances. Case classes come with their companion objects predefined.

Things to remember when creating a case class:

• Case class is a quick lightweight data structure with little boilerplate.
• Case classes are serializable and used with the Akka framework.
• Case classes have extractor patterns that can be used in pattern matching.
• Case objects are the same as case classes but don't get companion objects as they themselves are objects.

Well, that's about it on anonymous class and case class in scala.

Inheritance, Abstract Class And Traits

Scala offers single level inheritance. Inheriting a class inherits public methods and protected methods can be used within the child class.

Inheritance example:

Important notes on inheritance overriding:

• To override methods, use the override keyword. Override works for val, var, def or anything within in the class.
• To prevent override, we have to use the final keyword.
• Put a final keyword before class to altogether prevent the inheritance of a class.
• Use the sealed keyword to restrict inheritance in different scopes of the program.

Moving on to abstract classes in scala, we have to use the abstract keyword to make an abstract class and an abstract class cannot be instantiated, however, we can create an anonymous class using the new keyword and defining all the methods within that anonymous code block.

Traits are similar to interfaces in java. They are also used to declare undefined or unimplemented methods. We have to use the trait keyword to define traits in scala.

Important points to note for abstract classes and traits in scala:

• Abstract class can have both abstract and non-abstract methods. It is the same for traits.
• Traits does not have constructor parameters.
• Classes can inherit multiple traits, but not multiple classes.
• Traits are used to define the behaviour of a class.
• Abstract class is the type of thing itself.

Note: If you see ??? in abstract/trait methods, it means that method is not implemented and evaluates to Nothing.

Well, that's about it on inheritance, abstract class and traits in scala.

External Links

Below are some of the external links you can go through to get a more in-depth understanding of object-oriented programming in scala.

• Object Oriented Programming in Scala
• Scala Exercises

Wrap Up

Well, that wraps up part 2 of this crash course.

In the next part, we will discuss functions, HOFs, curries and much more related to functional programming in scala.

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

It will be a no-nonsense, to the point kind of article with all necessary links wherever needed.

Without further ado, let's get started.

What Is Scala?

Scala is a programming language just like any other that is available out there but with a lot of sweetness and awesome features that opens our world to functional programming with easy to understand syntax, running on JVM under the hood, having all functionality that Java language offers with popularity ranging from being used in major FinTech companies to FAANG companies and as one of the major language for data engineering applications.

Need to know more about what is Scala, visit here.

How To Install Scala?

Well, there are a couple of ways, in which the shortest and easy to follow is:

1. Install IntelliJ IDE from JetBrains. Check here.
2. Select IntelliJ IDEA | Preferences for macOS ( Ctrl+Alt+S ) or File | Settings for Windows and Linux.
3. Select Plugins on the left pane.
4. Search for Scala, install the plugin and restart IDE.
5. Now, after it restarts, select New Project and then Scala -> IDEA project, click Next, set project name and your project folder are ready with necessary scala features.

Installing Scala

Creating a New Project

Set Suitable Project Name

How To Start Working With Scala?

After successful installation and creating a scala project, you would be seeing a nice project structure with the src folder.

We will create a package, inside that package we will continue our work. What is a package?

To create a package, right-click on the src folder and select New | Package type, then fill in a name, whatever you like, for our case, let's name it crashcourse.

Create New Package

Now, right-click the crashcourse then New | Scala, here we are creating a scala object (we will discuss what scala object is in a minute). Let's name it BeginnersCrashCourse. It will create a standard template of scala object like below:

Select Scala Class

Select Scala Object

Well, now we have all we need to get started with some code!

What Is An Object?

Before moving to object, if you notice the created template have package crashcourse at the top, it means that whatever code we are going to write below this, will belong to this package and can be accessed by any code file within the same package or can be imported using import crashcourse._ in some other package. How to do imports in scala?

Now, what is an object in scala?

The object is a class that has exactly one instance, it means it already is an instance with a defined class structure. What is the defined class structure for an object type? It is everything we write inside scala object.

Scala objects are singleton, which means if we say we have an object named BeginnersCrashCourse then it is an instance that is a singleton in nature and whenever I am accessing it in the same executing program then its behaviour is going to be the same at every place, containing same values, methods or functions.

Treat an object as something that has static class level functionality.

How to write an object? Simple, just use the object keyword before writing an object, like below:

package crashcourse

object BeginnersCrashCourse extends App {

}

What is extends App? We extend App level functionality to a scala object whenever we want it to be able to run something inside it. It is like saying, we have a prebuilt public static void main(String[] args) whenever we extend it.

The above code is equivalent to:

package crashcourse

object BeginnersCrashCourse {
  def main(args: Array[String]): Unit = {

  }
}

Just to avoid writing the main method we can simply extend App to an object.

It is called a Scala Application if the main object (here BeginnersCrashCourse) extends App and is executable in nature. The main code goes inside an object that has App level functionality. Make sure you have a single main application while creating a service. Each service will have its main application to execute scala code.

Need more on scala objects, visit here.

Expressions, Types, Vars, Vals, Def, Print and Codeblocks

How to create a variable in scala?

Well, there are 2 ways in which we can create a variable in scala:

package crashcourse

object BeginnersCrashCourse extends App {
  var var1 = 1  //Mutable
  val var2 = 2  //Immutable
}

Writing comments in Scala is the same as Java.

The key difference between the 2 variables is that var1 is mutable and var2 is immutable and in functional programming, we will prefer to use immutable values.

val - values and var - variables, the name suggest itself that val will be a definite value whereas var are variables.

We can also use the semicolon ; at end of each line, but they are not needed. We can also define types to the variables, but for the above case, the compiler does this work for us, although it is best to explicitly define the type of each value we use in our code. So below code is similar to the above:

package crashcourse

object BeginnersCrashCourse extends App {
  var var1: Int = 1;  //Mutable
  val var2: Int = 2;  //Immutable
}

There are several data types available in scala, some of them are as below:

package crashcourse

object BeginnersCrashCourse extends App {
  var var1 = 1;  //Mutable
  val var2 = 2; //Immutable

  val bool: Boolean = true  //or false
  val chr: Char = 'a'   //Make sure you use single quotes for character type value
  val str: String = "String"    //And double quotes for a string type
  val int: Int = 123    //An int value
  val shrt: Short = 123   //A short value
  val lng: Long = 123     //A long value
  val lng2 = 123L   //Make sure to put L to let compiler know that it is of type Long
  val flt: Float = 123.0f   //Make sure to put f at the end of float values
  val dbl: Double = 123.0   //Otherwise compiler will infer it as a type of double
}

More on scala types, here.

Now, let's move on to defining methods in scala. It can be done so using the def keyword, methods can take arguments passed to them as parameters while calling them. We can define empty methods as well, those that take nothing.

Let's define some methods and call them:

package crashcourse

object BeginnersCrashCourse extends App {
  var var1 = 1;  //Mutable
  val var2 = 2; //Immutable

  val bool: Boolean = true  //or false
  val chr: Char = 'a'   //Make sure you use single quotes for character type value
  val str: String = "String"    //And double quotes for a string type
  val int: Int = 123    //A int value
  val shrt: Short = 123   //A short value
  val lng: Long = 123     //A long value
  val lng2 = 123L   //Make sure to put L to let compiler know that it is of type Long
  val flt: Float = 123.0f   //Make sure to put f at the end of float values
  val dbl: Double = 123.0   //Otherwise compiler will infer it as a type of double

  // Methods
  def greetings(name: String): String = "Hello " + name
  println(greetings("Siddharth"))

  def greetingsModified(name: String): Unit = println("Hello " + name)
  greetingsModified("Sid")

  def greetingsFromSystem: Unit = println("Hello, you are learning Scala!")
  greetingsFromSystem
}

There are a lot of things happening here, let's break it down for each method:

1. We define a method using the def keyword, our first method named greetings takes a single parameter named name which of type String and the method returns a value of type String denoted by : String after greetings(name: String), and this method evaluates to "Hello " + name with replacing with whatever name value we pass. We can print it to the console using the println method that conveniently puts a new line after printing the passed value to the console.

A little detour before we move on to the next methods.

• In scala everything we write gets evaluated to some value, those statements like "Hello " + name from above are called expressions. Everything in scala can be referred to as an expression, even assigning of values is called an expression evaluating in such a way that assign values to a given name.

• Any expression that does not evaluate anything but does something, like printing to console or assigning a value or storing data, then data type of that whole expression is called Unit. So, whenever we assign a value within a method, and that's the last thing that method evaluated to then it will be of type Unit. Anything that evaluates to Unit type is called side-effect in scala.

• We can use code blocks {...} instead of directly writing an expression for our methods. Methods are evaluated to the value returned by the last expression if it has a number of expressions. You can consider it to be the return value of the method but without needing to write return explicitly. Why we should not use return in scala?. A method code block would look something like this:

def methodWithCodeBlock(name: String): String = {
  "Hello " + name    //Evaluates to String type
}

//Below method evaluates to same value as above method while doing something else, like printing something
def methodWithSomethingElse(name: String): String = {
  println("Inside methodWithSomethingElse")   //Evaluates to Unit type
  "Hello " + name    //Evaluates to String type, hence the type of method as it is the last expression evaluating
}

Now, the remaining methods can be understood well.

2. We define the second method greetingsModified that takes a parameter named name of type String but evaluates to Unit as all this method does is print the greeting to the console as a side-effect.

3. The last method we wrote greetingsFromSystem does not take any parameter and evaluates to Unit with the side-effect of printing to console. This is called a parameterless method, scala allows us to define such a method, awesome, right?

For each method call, the following is the output to the console (to run a scala application, right-click and run in IntelliJ):

Hello Siddharth
Hello Sid
Hello, you are learning Scala!

More on println, visit here.

More on Unit type and other such types, visit here.

More on codeblocks in scala, visit here.

More on methods in scala, visit here.

Wrap Up

Well, that wraps up part 1 of this crash course.

In the next part we will be discussing classes, more on objects, companions, case classes and much more related to object-oriented programming in Scala.

• Make sure to follow me to get regular updates or subscribe so that you never miss my upcoming articles, ranging from Python to Computer Vision to Scala.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

So, without any further ado, let's get started!

What Are We Going To Use?

We are going to use Python and one of its awesome 3rd party library, gh-md-to-html.

To install gh-md-to-html run the following command on terminal:

$ pip install gh-md-to-html
Collecting gh-md-to-html
  Downloading gh_md_to_html-1.11.4-py3-none-any.whl (59 kB)
     |████████████████████████████████| 59 kB 5.9 MB/s 
Collecting shellescape
  Downloading shellescape-3.8.1-py2.py3-none-any.whl (3.1 kB)
Collecting Pillow>=8.0.1
  Downloading Pillow-8.2.0-cp38-cp38-macosx_10_10_x86_64.whl (2.8 MB)
     |████████████████████████████████| 2.8 MB 4.8 MB/s 
Collecting webcolors
  Downloading webcolors-1.11.1-py3-none-any.whl (9.9 kB)
Collecting requests
  Using cached requests-2.25.1-py2.py3-none-any.whl (61 kB)
Collecting beautifulsoup4
  Using cached beautifulsoup4-4.9.3-py3-none-any.whl (115 kB)
Collecting soupsieve>1.2
  Downloading soupsieve-2.2.1-py3-none-any.whl (33 kB)
Collecting idna<3,>=2.5
  Using cached idna-2.10-py2.py3-none-any.whl (58 kB)
Collecting certifi>=2017.4.17
  Using cached certifi-2020.12.5-py2.py3-none-any.whl (147 kB)
Collecting chardet<5,>=3.0.2
  Using cached chardet-4.0.0-py2.py3-none-any.whl (178 kB)
Collecting urllib3<1.27,>=1.21.1
  Using cached urllib3-1.26.4-py2.py3-none-any.whl (153 kB)
Installing collected packages: urllib3, soupsieve, idna, chardet, certifi, webcolors, shellescape, requests, Pillow, beautifulsoup4, gh-md-to-html
Successfully installed Pillow-8.2.0 beautifulsoup4-4.9.3 certifi-2020.12.5 chardet-4.0.0 gh-md-to-html-1.11.4 idna-2.10 requests-2.25.1 shellescape-3.8.1 soupsieve-2.2.1 urllib3-1.26.4 webcolors-1.11.1
$

As we can see, this library depends on a lot of other libraries and is not a pure library like pytube discussed here.

Advantages

Advantages include (from its official documentation):

• Let's you specify the markdown to convert as a string, as a repository path, as a local file name or as a hyperlink.
• Pulls any images referenced in the markdown files from the web/ your local storage and places them in a directory relative to your specified website root, so the resulting file structure is host-ready for static sites. Multiple arguments allow the customization of the saving locations, but the images will always be referenced correctly in the resulting HTML files. This is especially useful since it reflects GitHub's behaviour to serve cached copies of README images instead of linking to them directly, reducing tracking and possibly downscaling overlarge images in the process.
• Creates all links as root-relative hyperlinks and lets you specify the root directory as well as the locations for CSS and images, but uses smart standard values for everything.
• Supports inline LaTeX-formulas (use $-formula-$ to use them), which GitHub usually doesn't. gh-md-to-html uses LaTeX and dvisvgm if they are both installed (advantage: fast, requires no internet), and otherwise the Codecogs EqnEditor (advantage: doesn't require you to install 3 GB of LaTeX libraries) to achieve this.
• Supports exporting to pdf with or without Github styling, using the pdfkit python module (if it is installed).
• Tested and optimized to look good when using DarkReader (the .js-module as well as the browser extension). This is especially relevant considering that DarkReader doesn't usually shift the colours of SVG images, and the formulas added by gh-md-to-html's formula support are embedded as inline svg. gh-md-to-html ensured that the formulas are the same colour as the text, shifted in accordance with DarkReader's current/enabled colorscheme.
• Supports umlauts and other non-ascii-characters in plain text as well as in multiline code blocks, which the github REST api usually doesn't.
• Allows you to choose which tool or module to use at its core for the basic markdown to html conversion.
• Styles its output with github's README-css (can be turned off).

Whilst using pandoc to convert from markdown to pdf usually yields more beautiful results (pandoc uses LaTeX, after all), gh-md-to-html has its own set of advantages when it comes to quickly converting complex files for a homework assignment or other purposes where reliability weights more than beauty. pandoc's md-to-pdf-conversion acts quite unusual when it comes to images, nested lists, multiline bullet point entries, or formulas, and gh-md-to-html does not.

Converting Markdown To HTML

Now, let's create a simple script that converts markdown text to HTML using gh-md-to-html.

Add the following code to a file, name it whatever you like, say mdtohtmldemo.py:

#./ mdtohtmldemo.py

import gh_md_to_html

html = gh_md_to_html.main('md-to-html/sample.txt')
print(html)

Where the markdown contents are as follows (notice that we are using it as a text file, but it is not necessary, we can use .md files directly):

# This is a sample markdown

Hello World!

> Feel free to add your own markdown here.

After running the above script for given markdown content, we get the below output:

<?xml version='1.0' encoding='UTF-8'?>
<link href="/github-markdown-css/github-css.css" rel="stylesheet"/>
<meta charset="utf-8" content="text/html"/>
<div class="gist">
<style class="formula-style">
        svg.gh-md-to-html-formula {
            fill: black;
        }
    </style>
<div class="gist-file"> <!-- This is the class that is responsible for the boxing! -->
<div class="gist-data">
<div class="js-gist-file-update-container js-task-list-container file-box">
<div class="file" id="article-sample">
<div class="Box-body readme blob js-code-block-container p-5 p-xl-6" id="file-docker-image-pull-md-readme" style="margin-left: 40px; margin-right: 40px; margin-top: 20px; margin-bottom: 20px">
<article class="markdown-body entry-content container-lg" itemprop="text">
<h1 id="user-content-this-is-a-sample-markdown">
<a aria-hidden="true" class="anchor" href="#user-content-this-is-a-sample-markdown" id="user-content-this-is-a-sample-markdown"><span aria-hidden="true" class="octicon octicon-link"></span></a>This is a sample markdown</h1>
<p>Hello World!</p>
<blockquote>
<p>Feel free to add your own markdown here.</p>
</blockquote>
</article>
</div>
</div>
</div>
</div>
</div>
</div>

If we notice, it created a CSS /github-markdown-css/github-css.css in our local directory where we ran the script similar to what github uses.

There is an output HTML file also created with the same name as sample.html, if we open it in a browser, we get the following output:

Well, that's it from me. If you followed this, you would be seeing an autogenerated HTML file for your markdown file.

Try different functions, methods and utilities it provides and use them with your projects as needed.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

So, why not we create our own bot that can download any YouTube video with just simply running a Python script? Everything would be in our control then, awesome, right?

In this article, we are going to see how we can make a Python script to automate the YouTube video downloading activity.

After going through this article, you can say NO to all those annoying ads, privacy issues, authorisation to different extensions and can finally have total control.

Let's get started!

What Are We Going To Use?

We are going to use Python and one of its amazing 3rd party library, pytube.

To install pytube:

$ pip install pytube
Collecting pytube
  Downloading pytube-10.7.2-py3-none-any.whl (42 kB)
     |████████████████████████████████| 42 kB 3.4 MB/s 
Installing collected packages: pytube
Successfully installed pytube-10.7.2
$

More on pytube:

• pytube is a very serious, lightweight, dependency-free Python library (and command-line utility) for downloading YouTube Videos.
• pytube is a lightweight library written in Python. It has no third-party dependencies and aims to be highly reliable.
• pytube also makes pipelining easy, allowing you to specify callback functions for different download events, such as on progress or on complete.
• Finally, pytube also includes a command-line utility, allowing you to quickly download videos right from the terminal.

Features:

• Support for both progressive & DASH streams.
• Support for downloading complete playlist.
• Easily register on_download_progress & on_download_complete callbacks.
• Command-line interfaced included.
• Caption track support.
• Outputs caption tracks to .srt format (SubRip Subtitle).
• Ability to capture thumbnail URL.
• Extensively documented source code.
• No third-party dependencies (written in pure Python).

On a high level, to download a video using the library in a script, we'll need to first import the YouTube class from the library, and pass it an argument of the video URL. Then we can download different streams present on that YouTube object.

Now, let's move on to use this information to build our first YouTube video downloader.

Get The Streams

First, we will make a simple script to get all the available streams for the given YouTube video URL. Open a file name it whatever you like with the .py extension, let's say for our case we name it pytube_demo.py, add the following code in it and run:

# ./pytube_demo.py

from pytube import YouTube

video_url = input("Enter YouTube Video URL: ")
youtube_obj = YouTube(video_url)
print(youtube_obj.streams)

After you hit run, when the terminal prompts you to enter a video URL, enter this https://www.youtube.com/watch?v=fibIyvTleqc, it is one of my favourite songs Daydreamer by AURORA.

Note: You can enter any YouTube video URL here, what we are going to explore further doesn't depend on which URL you enter.

Enter YouTube Video URL: https://www.youtube.com/watch?v=fibIyvTleqc
[<Stream: itag="18" mime_type="video/mp4" res="360p" fps="25fps" vcodec="avc1.42001E" acodec="mp4a.40.2" progressive="True" type="video">, <Stream: itag="137" mime_type="video/mp4" res="1080p" fps="25fps" vcodec="avc1.640028" progressive="False" type="video">, <Stream: itag="248" mime_type="video/webm" res="1080p" fps="25fps" vcodec="vp9" progressive="False" type="video">, <Stream: itag="136" mime_type="video/mp4" res="720p" fps="25fps" vcodec="avc1.4d401f" progressive="False" type="video">, <Stream: itag="247" mime_type="video/webm" res="720p" fps="25fps" vcodec="vp9" progressive="False" type="video">, <Stream: itag="135" mime_type="video/mp4" res="480p" fps="25fps" vcodec="avc1.4d401e" progressive="False" type="video">, <Stream: itag="244" mime_type="video/webm" res="480p" fps="25fps" vcodec="vp9" progressive="False" type="video">, <Stream: itag="134" mime_type="video/mp4" res="360p" fps="25fps" vcodec="avc1.4d401e" progressive="False" type="video">, <Stream: itag="243" mime_type="video/webm" res="360p" fps="25fps" vcodec="vp9" progressive="False" type="video">, <Stream: itag="133" mime_type="video/mp4" res="240p" fps="25fps" vcodec="avc1.4d4015" progressive="False" type="video">, <Stream: itag="242" mime_type="video/webm" res="240p" fps="25fps" vcodec="vp9" progressive="False" type="video">, <Stream: itag="160" mime_type="video/mp4" res="144p" fps="25fps" vcodec="avc1.4d400c" progressive="False" type="video">, <Stream: itag="278" mime_type="video/webm" res="144p" fps="25fps" vcodec="vp9" progressive="False" type="video">, <Stream: itag="140" mime_type="audio/mp4" abr="128kbps" acodec="mp4a.40.2" progressive="False" type="audio">, <Stream: itag="249" mime_type="audio/webm" abr="50kbps" acodec="opus" progressive="False" type="audio">, <Stream: itag="250" mime_type="audio/webm" abr="70kbps" acodec="opus" progressive="False" type="audio">, <Stream: itag="251" mime_type="audio/webm" abr="160kbps" acodec="opus" progressive="False" type="audio">]

So, we got a list of Stream objects, each stream object giving us information about different aspects of a video.

If we see res attribute of stream object, we see that we have 360p, 1080p, 720p, 480p, 240p and 144p with different vcodec attribute. This res represents the resolution of a video, we can select any stream of desired resolution to download.

Also, notice that we have only audio option streams available as well to download.

Next, we will create a filter for video resolution and to keep it simple we will not dive into audio downloadable streams.

Filter Stream Based On Resolution

Update the code in the pytube_demo.py file to the below code:

# ./pytube_demo.py

from pytube import YouTube

def get_stream_for_res(streams, res):
    """
    Filter on the basis of a given resolution. Return a list of filtered streams.
    """
    stream = list(filter(lambda x: x.resolution == res, streams))
    return stream

video_url = input("Enter YouTube Video URL: ").strip()
youtube_obj = YouTube(video_url)

video_res = input(f"Enter YouTube Video Resolution for {youtube_obj.title}: ").strip()
req_stream_obj = get_stream_for_res(youtube_obj.streams, video_res)
print(req_stream_obj)

Hit run and we can see following output in the terminal:

Enter YouTube Video URL: https://www.youtube.com/watch?v=fibIyvTleqc
Enter YouTube Video Resolution for AURORA - Daydreamer (Audio): 720p
[<Stream: itag="136" mime_type="video/mp4" res="720p" fps="25fps" vcodec="avc1.4d401f" progressive="False" type="video">, <Stream: itag="247" mime_type="video/webm" res="720p" fps="25fps" vcodec="vp9" progressive="False" type="video">]

First, we take the video URL and creates the YouTube object, then we take custom input from the user while displaying the title of the video using youtube_obj.title. After receiving the resolution, say 720p, we call the function get_stream_for_res that filters the given list of streams on the given resolution. At last, we can see the output, it contains 2 stream objects in a list, both objects have different values for some attributes but have the same resolution.

Without diving deep on what all other attribute means, let's just simply take the first element of the list and download the video.

Download Stream Based On Resolution

Now update the code to the following to download the YouTube video (complete script):

# ./pytube_demo.py

from pytube import YouTube

def get_stream_for_res(streams, res):
    stream = list(filter(lambda x: x.resolution == res, streams))
    return stream

video_url = input("Enter YouTube Video URL: ").strip()
youtube_obj = YouTube(video_url)

video_res = input(f"Enter YouTube Video Resolution for {youtube_obj.title}: ").strip()
req_stream_obj = get_stream_for_res(youtube_obj.streams, video_res)[0]

req_stream_obj.download()
print(f"YouTube Video {youtube_obj.title} Downloaded With Resolution {video_res}")

When we run the above script, we get the following output and a downloaded video:

Enter YouTube Video URL: https://www.youtube.com/watch?v=fibIyvTleqc
Enter YouTube Video Resolution for AURORA - Daydreamer (Audio): 720p
YouTube Video AURORA - Daydreamer (Audio) Downloaded With Resolution 720p

Now, if we check our directory where we ran the script, we can find the downloaded video.

Note:

You may notice that some streams listed have both a video codec and audio codec, while others have just video or just audio, this is a result of YouTube supporting a streaming technique called Dynamic Adaptive Streaming over HTTP (DASH).

In the context of pytube, the implications are for the highest quality streams; you now need to download both the audio and video tracks and then post-process them with software like FFmpeg to merge them.

The legacy streams that contain the audio and video in a single file (referred to as “progressive download”) are still available, but only for resolutions 720p and below.

The video downloaded from the given code has a Stream object whose attribute progressive is False. The given video URL does not have legacy streams available for 720p but if you notice there is one stream with progressive as True and res as 360p.

<Stream: itag="18" mime_type="video/mp4" res="360p" fps="25fps" vcodec="avc1.42001E" acodec="mp4a.40.2" progressive="True" type="video">

So, go ahead and experiment with it and don't forget to check out the progressive attribute.

What Next?

Well, that's it from me. If you followed this and ran the final script, you would be seeing a downloaded video in your working directory.

You can take it to the next level by creating a UI for this utility. You can host this as a service that would be strictly private to you.

What are you waiting for then? Use Tkinter, PyQT, Kivy, Flask or Django and make a UI with more functions like a select option for audio and video, for video resolution and for audio ABR, etc. and say NO to all those annoying ads, privacy issues, several authorisations to different extensions and have total control over your downloaded videos.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

Let's get started!

List

Python list as we all know is a mutable dynamic array that behaves like a linked list as well. Let's look at some code for creating and updating a list:

# ./list_1.py

l = [1,2,3]     # A new list gets created
print('Initial List', l)

l.append(4)     # Updating list using in-built append method
print('Append 4, List updated to', l)

l.pop()         # Pop last item
print('Pop, List updated to', l)

l += [5, 6]     # Updating list by adding a new list to given list
print('Add new list, List updated to', l)

Following will be the output:

Initial List [1, 2, 3]
Append 4, List updated to [1, 2, 3, 4]
Pop, List updated to [1, 2, 3]
Add new list, List updated to [1, 2, 3, 5, 6]
>>>

Now let's see what happens in memory when we run the above script, here we will be using sys to help us out on viewing system-related information:

# ./list_2.py

import sys
l = [1,2,3]     # A new list gets created
print('Initial List', l)
print('Initial List Address', id(l))
print('Initial List Memory', sys.getsizeof(l))

l.append(4)     # Updating list using in-built append method
print('Append 4, List updated to', l)
print('Append 4, List Address', id(l))
print('Append 4, List Memory', sys.getsizeof(l))

l.pop()         # Pop last item
print('Pop, List updated to', l)
print('Pop, List Address', id(l))
print('Pop, List Memory', sys.getsizeof(l))

l += [5, 6]     # Updating list by adding a new list to given list
print('Add new list, List updated to', l)
print('Add new list, List Address', id(l))
print('Add new list, List Memory', sys.getsizeof(l))

Let's look at the output first:

Initial List [1, 2, 3]
Initial List Address 139688582615624
Initial List Memory 88
Append 4, List updated to [1, 2, 3, 4]
Append 4, List Address 139688582615624
Append 4, List Memory 120
Pop, List updated to [1, 2, 3]
Pop, List Address 139688582615624
Pop, List Memory 120
Add new list, List updated to [1, 2, 3, 5, 6]
Add new list, List Address 139688582615624
Add new list, List Memory 120
>>>

Following points we can find out after looking at the output:

• Initially, when the list got created, it had a memory of 88 bytes, with 3 elements.
• Later on, after appending an element 4 to the list, the memory changes to 120 bytes, meaning more memory blocks got linked to list l.
• Even after popping out the last element the created blocks memory remains the same and still attached to list l. And when we add another list with 2 more elements to the given list l, we see that occupied memory is still the same 120 bytes. Hence, we can conclude that it is behaving more like a dynamic array, which updates the size of the list to contain more elements at once to avoid repetitive callbacks (to create and attach new memory address) at every insertion of the new element.
• We also notice that the list address remains the same, even if we do append, pop or add a new list to it (as long as we don't assign it to a new variable). This advocates the nature of the mutability of python lists (it means, more or less, that at the same address we are able to update values or extend it further).

Now, let's look at the tuples.

Tuple

Python tuple as we all know are immutable and do not extend in the memory further after the initial declaration. Now, let's look at the above same scenario but for tuples:

# ./tuple_1.py

import sys
t = (1,2,3)     # A new tuple gets created
print('Initial Tuple', t)
print('Initial Tuple Address', id(t))
print('Initial Tuple Memory', sys.getsizeof(t))

t += (5, 6,)     # Updating tuple by adding a new tuple to given tuple
print('Add new tuple, Tuple updated to', t)
print('Add new tuple, Tuple Address', id(t))
print('Add new tuple, Tuple Memory', sys.getsizeof(t))

Output:

Initial Tuple (1, 2, 3)
Initial Tuple Address 140452527817280
Initial Tuple Memory 72
Add new tuple, Tuple updated to (1, 2, 3, 5, 6)
Add new tuple, Tuple Address 140452528572728
Add new tuple, Tuple Memory 88
>>>

Following points we notice after looking at the output:

• Since, tuples are immutable, once created cannot be updated unless a new tuple gets added to the previous one, resulting in the creation of a new tuple.
• Once a tuple gets created, its allocated memory will not be changed.
• Updating a tuple after adding another tuple to it, updates the address of the resulting tuple, this advocated its immutability property.
• We can see it allocates 72 bytes for 3 values and 88 for 6 values, it does not allocate the unnecessary amount of memory, only what is required is allocated.

Let's look at some miscellaneous points.

MISC

What happens when we create an empty list and empty tuple?

# ./misc.py

import sys

t1 = ()
t2 = ()

l1 = []
l2 = []

print('List l1 address', id(l1))
print('List l2 address', id(l2))
print('List l1 memory', sys.getsizeof(l1))
print('List l2 memory', sys.getsizeof(l2))

print('List t1 address', id(t1))
print('List t2 address', id(t2))
print('List t1 memory', sys.getsizeof(t1))
print('List t2 memory', sys.getsizeof(t2))

What did we get?

List l1 address 139766851756616
List l2 address 139766851761800
List l1 memory 64
List l2 memory 64
List t1 address 139766871547976
List t2 address 139766871547976
List t1 memory 48
List t2 memory 48
>>>

What did we find?

• Creating 2 empty lists have the same amount of memory allocated, whereas the address of both lists is different. It makes sense because, list address will have to act as mutable and cannot be the same at a given time, which means 2 different lists will be different unless they are the same (not in value but in reference point of view).
• Creating 2 empty tuples have the same amount of memory allocated and will point to the same address initially. It makes sense because of its immutability property. Consider integer 1 value in python that is immutable and always point to the same address unless changed to some other integer. Similarly, the initial empty tuple will always point to the same address unless changed to some other tuple.

Well, that's it from me.

We explored quite a few points on how memory is allocated and how it could be managed in Python.

To know more about memory management, I encourage you to explore their code available on python's repo.

Feeling it's difficult to go through the source code of python? Don't worry, we can always use available sys module methods and other functions like id to develop an understanding of what could be happening behind the scenes.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

However, it becomes really productive when we leverage the scripting capabilities of the shell.

In this article, we are going to explore the basics of shell scripting, how simple echo command can be used in a shell script file, how to write comments, working with variables and conditionals.

Keeping it short and simple, let's get started!

Shell Script Printing

When we are working with shell scripts printing on the output screen is called echoing which can be done using echo.

$ echo "Hello Shell"
Hello Shell

Let's do this inside a shell script file. Follow the below steps:

1. Create a file, name it whatever you want with the .sh extension. Let's say echo_script.sh.
2. Add following inside the file - echo "Hello Shell", hit Save and open a terminal on the file location.
3. On the terminal, write - $ bash echo_script.sh and hit enter, you should be able to see - Hello Shell.

Shell Script Comments

Comments are used to improve the readability of the script. Shell uses the pound # symbol for comments. A line beginning with the pound # symbol is ignored by the shell interpreter during execution.

The script given below shows the usage of the comment:

# Display Hello Shell using echo command of shell, filename.sh
echo "Hello Shell"

Go to terminal and type - $ bash filename.sh (replace filename with whatever name you have given) and hit enter. You should be able to see - Hello Shell without printing anything given after the # symbol.

Shell Script Variables

We can define variables to store information, which can be accessed within the shell script. There are certain rules we need to follow while defining variables:

1. The variable name can contain any combination of letters from A-Z or a-z, digits from 0-9 or an underscore (_) character.
2. The variable name should start with a letter or an underscore character.
3. Variables are case sensitive.

By convention, shell variables are defined in the upper case. Given below is a simple script, which shows the usage of a variable within it:

$ cat hello.sh
NAME="CodeKaro"
echo "Hello $NAME"

cat command is used to display the content of a file given after that. Try your hands on it.

So, we have a file hello.sh which contains a variable NAME which we used in the echo statement as $NAME that is after the $ symbol. Here we saw variable declaration and how inside double quotes a variable can be used.

If you hit - $ bash hello.sh and hit enter, you should be able to see - Hello CodeKaro on the terminal.

Shell Script Conditionals

Like other programming languages, shell supports conditional expressions like – if, if-else and case. Let us understand this with simple examples:

1. if expression: In case we want to verify whether a file exists or not, we can use the if expression, as follows:

$ touch file.txt #this creates a file

$ cat file_existance.sh
if [ -e file.txt ]; then
echo “file.txt file exists”
fi

The script given above generates the following output when it is executed:

$ bash file_existance.sh
file.txt file exists

1. if-else expression: Let us modify the above script to generate output when the file does not exist:

$ rm file.txt
$ cat file_existance.sh
if [ -e file.txt ]; then
echo “file.txt file exists”
else
echo “file.txt file does not exists”
fi

Type following and hit enter:

$ bash file_existance.sh
file.txt file does not exists

1. case statement: Shell provides a switch statement-like functionality using the case statement. Let us understand this with the example given below:

$ cat case_statement.sh
read -p “Enter the day: “ DAY

case $DAY in
Mon) echo “Today is Monday”
;;

Tue) echo “Today is Tuesday”
;;

Wed) echo “Today is Wednesday”
;;

*) echo “Unknown day”
;;
esac

The script given above generates the following output when it is executed:

$ bash case_statement.sh
Enter the day: Mon
Today is Monday

$ bash case_statement.sh
Enter the day: Tue
Today is Tuesday

$ bash case_statement.sh
Enter the day: Invalid
Unknown day

In the case statement, an asterisk (*) denotes a default case.

Well, that's it from me.

We covered printing, variables, comments and conditionals, not too much, right?

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

Image Credits - pch.vector

It could be a pass time activity or something new to learn or just to show off your friends or juniors, so without any further ado, let's get started!

Note: If you do not have OpenCV installed, I suggest you visit here and check Prerequisites steps on the process of installation.

Necessary Imports

First, create a python file, name it whatever you like, for this article let's say slideshow.py. Now add the following imports to the file created:

# ./slideshow.py

import cv2
import numpy as np
from math import ceil
import os

• We import cv2 for all image processing tasks, numpy with alias np to create an initial window for display (all things in OpenCV works with numpy under the hood), ceil from math to satisfy a future condition (how do I know if need it or not?, well you don't, during the process of making an app there would be times when you will have to continuously improve your program and it's fine, but for this article, I want to keep everything at one place from starting, so don't worry just know that we will need this import) and lastly we import os to extract all image files that we need in a slideshow.

Note: You also need a set of images you would want to view as a slideshow. Collect them and keep them in the ./images folder and don't worry about the size of images.

Variables, Image Window and Alpha-Beta

Add the following code to the same file:

dst = "./images/"       # Images destination
images = os.listdir(dst)    # Get their names in a list
length = len(images)

result = np.zeros((360,360,3), np.uint8)        # Image window of size (360, 360)
i = 1

a = 1.0     # alpha
b = 0.0     # beta
img = cv2.imread(dst + images[i])
img = cv2.resize(img, (360, 360))

• First 3 lines find out the image name of all the images present in the ./images folder. We use the os.listdir method to list all the contents of a directory and then keep them in the images variable and also we keep the length as a measure for total available images.
• Next, we create an image window of size (360, 360, 3), which is a 3 channel image. Initially, it will all be black (filled with zeros).
• Then we define some more constants, i to be used to loop over images, a to keep initial alpha value and b for initial beta value, we will see how these are used for image transition that ultimately will give the slideshow effect.
• At last, we take the first image from the list of images, resize it to fit the window, this will be the first image to appear on the slideshow.

SlideShow Loop

Let's create our slideshow, add the following code to the same file:

# Slide Show Loop
while(True):

    if(ceil(a)==0):
        a = 1.0
        b = 0.0
        i = (i+1)%length    # Getting new image from directory
        img = cv2.imread(dst + images[i])
        img = cv2.resize(img, (360, 360))

    a -= 0.01
    b += 0.01

    # Image Transition from one to another
    result = cv2.addWeighted(result, a, img, b, 0)
    cv2.imshow("Slide Show", result)
    key = cv2.waitKey(1) & 0xff
    if key==ord('q'):
        break

cv2.destroyAllWindows()

• Now, we create a while infinite loop. Inside it, there is a conditional that checks for ceil(a) if it reaches 0 (zero) then we reset the a and b values, update i in a circular fashion using modulus operator % on the length of the list of images to get the index of next image, and update img variable to contain a new image and resize it.
• Outside of the conditional, we use a and b to decrease and increase alpha and beta values respectively. This variation will give us the transition effect that seems to be smooth. We will use these with the cv2.addWeighted method that just overlaps one image over another depending on the weight of the given images.
• result stores the new updated image that we will display using the cv2.imshow method of the OpenCV. At last, we wait for a key event and breaks out of the while loop if it happens and destroy all windows created during execution using the cv2.destroyAllWindow method.

cv2.addWeighted method is what helps us to achieve the slideshow effect that we wanted. Here, the alpha a value is the weight for the resulting image (that was initially a black window) and the beta b value is for a new image that will overlap the result window. Make sure that sum of a and b remains equal to1 (one). For more information on this, please visit here.

Demo - How It Looks

The images I took are logos of my favourite programming languages - Python, Scala and ReactJS (currently learning).

For complete script, visit here.

What Next?

Well, that's it from me. If you followed this, you might be seeing a wonderful slideshow of your collection of images. As for the next steps, you can enhance this application by adding the following:

• Add buttons to change the type of slideshow. Currently, it is only doing a smooth transition, try to implement a different animated transition.
• Add a utility to select a number of images and not all, as we did, we just took every image. Also, you can try to handle exception like what if a non-image comes from the folder.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Want to showcase your Python project or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

GitHub hosts software for development and version control. The main repository can have many branches or forks. GitHub is widely used by developers to test code and to collaborate with other developers in the software development life cycle.

In this article, we will go through the ten most popular open-source repositories on GitHub.

FreeCodeCamp

This is one of the biggest repositories on GitHub because it offers newcomers the means to learn how to code effectively, for free. As the name suggests, it is a user-friendly and safe environment for coders to learn skills.

Any learner can build his or her own project, learn to code and adopt best practices. Since its inception, the page has collected more than 320K stars on GitHub. This community is the best example of OSS - a place where everyone can contribute and learn for free.

VSCode

Visual Studio Code is a free and open-source code editor developed by Microsoft for Windows, Linus and macOS. It is an all-purpose code editor and its focus is to provide developers with a single stop solution for all their coding needs, including editing and debugging.

VSCode is an extremely well-liked open-source repository on GitHub, with more than 110K stars and 1.4K contributors. This repository is used to work on code and can also be used as a publishing platform. It gets updated every month with bug fixes, new features and some enhancements.

Flutter

This software development kit made by Google is one of the fastest-growing open source communities on GitHub. It permits applications to be developed from a single codebase with a user interface toolkit. The applications created by Flutter are attuned with PC and mobile platforms and their appearance creates aesthetic and efficient end-user experiences.

Flutter is pushed by Skia, and the hardware-accelerated 2D graphics library by Android and Chrome. It also employs a layered architecture for building applications, which allows developers to flawlessly add text, graphics, video and animated content as overlays without disturbing the source code. Its GitHub page has over 117K stars.

Ansible

This open-source IT engine automates application operation and cloud provisioning. It was created in 2012 by AnsibleWorks and is now owned by Red Hat. Ansible is developed in Python, is lightweight and has fast deployment. As Python is used to build most Linux and UNIX systems, getting Ansible up and running is very quick, and its agentless feature makes it easy to be set up and used.

It can also be run from CLI commands without using configuration files. For comparatively difficult tasks, its configuration is handled by the YAML syntax in the configuration file known as playbook. Ansible commands can be written in any programming language and sent over in JSON format. It has also recently started supporting Windows. It has over 46K stars on GitHub.

Kubernetes

The powerful open-source system was initially developed by Google for managing containerised applications in a cluster environment. Kubernetes was launched in 2014 after more than a decade of experience running production workloads at Google with Google's internal container cluster managers Borg and Omega.

It aims to provide better ways of managing related and distributed components and services across varied infrastructures. Kubernetes has now become the de facto standard for deploying containerised applications at scale in private, public and hybrid cloud environments. The largest public cloud platforms - including AWS, Google Cloud, Azure, IBM Cloud and Oracle Cloud - now provide managed services for Kubernetes. Its repository has more than 76K stars.

React Native

React Native is a JavaScript framework that is used in many social media platforms, including Facebook, Twitter, and so on. This framework allows the user to build native applications using JavaScript. It brings React's declarative user interface build to mobile platforms as well as allows the developer to use native UI controls to gain full access to the platforms.

React Native has a lively GitHub community with several contributors and over 94K stars. This platform understood and modified more easily. It also makes it simple to build component-based complex UIs and allows any local changes to replicate quickly on the project. Developers use the GitHub community to interact, collaborate and contribute to the program, making it a popular choice for JavaScript coders.

TensorFlow

This is a popular open-source machine learning framework. It contains a large number of useful libraries, tools, and community resources focused on making ML capabilities available for developers looking to use them in their projects. With TensorFlow, developers can easily create and deploy ML models as part of their application and also use them on their system, on the cloud or from a mobile platform.

Developed by experts working in the Google Brain team, the system is compatible with all major operating systems. The GitHub page has more than 150K stars and more than 2.9K contributors.

DefinitelyTyped

This is a library of TypeScript type definitions maintained on GitHub. In this open-source repository, developers can share and keep TypeScript type definitions for JS libraries. It mainly serves as a translator for JS developers to work with TypeScript. Using DefinitelyTyped and its declaration statements, they can discover TypeScript equivalents for existing JS libraries.

Developers can contribute to the repository by adding definitions, testing, and so on. This is an extremely popular page, with thousands of contributors and many times more users. It has more than 33K stars and 13K active contributors.

Azure

This is a cloud computing service developed by Microsoft. The GitHub repository of Microsoft Azure is devoted to its open-source documentation. The page calls developers to contribute to the project by giving feedback, reporting issues and similar helpful ways. The page has more than 7K contributors and is one of the most active repositories on the platform.

Home Assistant

This open-source home automation software is intended to the central system for controlling smart homes. The system is built using a modular approach so support for other devices or actions can be implemented easily. Homes Assistant core application software is written in Python and its main aim is local control and privacy, powered by a worldwide community of tinkerers and DIY enthusiasts. Perfect to run on a Raspberry Pi or a local server. It has more than 42K stars and more than 2.4K active contributors.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Need inspiration or a different perspective on the Python projects or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏

Image Credits - vectorjuice

In this article, we are going to make a paint application that features the brush functionality with customizations like:

• Changing brush size using a trackbar.
• Changing paint colour using a trackbar.
• Viewing the selected colour on the window.

We will also see how current trackbar values can be displayed on the window, so we have a general idea of the colour variation.

Note: We are going to make this application on macOS and somehow the in-built create trackbar method of OpenCV does not show selected trackbar values, hence the need to display these values on the image window itself.

If you do not have OpenCV installed, I suggest you visit here and check Prerequisites steps on the process of installation.

Without any further ado, let's start making our first paintbrush application.

Imports and Variables

Create a python file, name it whatever you like. Add below code in it (make sure you have OpenCV installed):

# ./paintApplication.py

import cv2
import numpy as np

draw = False
window_name = "Paint Brush Application"
bgr_track = {'B': 0, 'G': 0, 'R': 0}

img = np.zeros((512,512,3), np.uint8)
cv2.namedWindow(window_name)

# Initial color window, showing black color, same as paint area
cv2.rectangle(img, color_win_position[0], color_win_position[1], (0,0,0), -1)

• First 2 lines import necessary libraries. Here, we are going to import cv2 and numpy with an alias np.
• Next 3 lines define some constants that we are going to use later. draw says if the mouse is drawing on image window, window_name describes the name of the application window that is Paint Brush Application and bgr_track is a dictionary that we will use to keep track of previous BGR values (you will know later why we are doing this).
• Next 2 lines create an area for our paint application and set a name to the window. img contains a numpy array of 3 dimensions where each value is zero, meaning it will be a black coloured area. cv2.namedWindow attaches a name to the image we just created, we can later use this window name to place all other things like trackbar.
• The last line of this code snippet creates a rectangle window which we will be using for viewing our colour that we are choosing from the trackbar.

Now, add the below code:

font = cv2.FONT_HERSHEY_SIMPLEX
img = cv2.putText(img, "R: ", (10, 30), font, 0.5, (255,255,255), 1)
img = cv2.putText(img, "G: ", (90, 30), font, 0.5, (255,255,255), 1)
img = cv2.putText(img, "B: ", (170, 30), font, 0.5, (255,255,255), 1)

img = cv2.putText(img, "0", (30, 30), font, 0.5, (255,255,255), 1)
img = cv2.putText(img, "0", (110, 30), font, 0.5, (255,255,255), 1)
img = cv2.putText(img, "0", (190, 30), font, 0.5, (255,255,255), 1)

• Now, we put text on the image window that will work as the counter for values of the BGR trackbar. Since on macOS, the track bar is not showing selected values, so we need this functionality. Also, take it as a side activity that we can do.
• We put text using the cv2.putText method of OpenCV and set a font as well. We can set any font we want, here we are using Hershey simplex font.
• We are placing text like R: and 0 separately because we need to change only number values and not constants like R:.
• We can select any random position for these counters on the image and check which best suits our needs.

So far, we have all the variables that we need, now let's move onto creating some interesting functions!

Functions - All We Need

Add below python code snippet to the same file where we left above:

def nothing(x):
    pass

def update_R_value(x):
    global font, img, bgr_track
    img = cv2.putText(img, f"{bgr_track['R']}", (30, 30), font, 0.5, (0,0,0), 1)
    img = cv2.putText(img, f"{x}", (30, 30), font, 0.5, (255,255,255), 1)
    bgr_track['R'] = x

def update_G_value(x):
    global font, img, bgr_track
    img = cv2.putText(img, f"{bgr_track['G']}", (110, 30), font, 0.5, (0,0,0), 1)
    img = cv2.putText(img, f"{x}", (110, 30), font, 0.5, (255,255,255), 1)
    bgr_track['G'] = x

def update_B_value(x):
    global font, img, bgr_track
    img = cv2.putText(img, f"{bgr_track['B']}", (190, 30), font, 0.5, (0,0,0), 1)
    img = cv2.putText(img, f"{x}", (190, 30), font, 0.5, (255,255,255), 1)
    bgr_track['B'] = x

• We create a function like nothing that does nothing just do a simple pass. We can use it to fulfil our need to pass it as a parameter where it is required but we want it to not do anything.
• Next 3 functions are the same with just a difference of B, G and R. Let's explore update_R_value.
• Here we are trying to update the counter value of R: 0 on the image window.
• First, we get all global variables and try to replace the already present value of 0 against R:. In OpenCV, there is no feature that lets cv2.putText keep track of previous text on the same position so it could just replace it. Here we need to first put the same text as the previous value, like 0 in this case, and change colour similar to the background of the paint area (here it is black) so that it is like that it vanished from the paint area. Now we just put a new trackbar value, which is passed to the function as x with the colour white in the same place. Lastly, we update the bgr_track dictionary that keeps the track history of the last value it put and the same process repeats.

The same kind of thing is going on with the other 2 functions, just for different colour trackbar values.

In simple terms, take the below scenario:

• Let's say we have a list - l = [0, 0, 0]. Here all the values were -1 initially representing the start stage of the list. It is a special kind of list where we can only change its values only if they are -1 first and nothing else.
• What we are going to do now is that, replace the first index (R colour value let's say) with a new value.
• So we try to replace 0 knowing its position with -1 because if we replace it directly it overlaps and doesn't work. So what we do instead is l[0] = -1 and then after setting it to -1, it is back to its original state from where we can do anything to its value. Now we do the actual replace l[0] = x.

So what just happened? If you need more insight on this please visit my answer on StackOverflow here.

Let's move on to mouse events, which will help us to draw using a paintbrush.

def draw_circle(event, x, y, flags, param):
    global draw, img

    if event == cv2.EVENT_LBUTTONDOWN:
        draw = True

    elif event == cv2.EVENT_MOUSEMOVE:
        if draw:
            cv2.circle(img, (x,y), cv2.getTrackbarPos("Brush Size", window_name),
                       (cv2.getTrackbarPos("B", window_name),
                        cv2.getTrackbarPos("G", window_name),
                        cv2.getTrackbarPos("R", window_name)),
                       -1)

    elif event==cv2.EVENT_LBUTTONUP:
        draw = False
        cv2.circle(img, (x,y), cv2.getTrackbarPos("Brush Size", window_name),
                       (cv2.getTrackbarPos("B", window_name),
                        cv2.getTrackbarPos("G", window_name),
                        cv2.getTrackbarPos("R", window_name)),
                       -1)

• This method draw_circle will be passed to the mouse event callback method of OpenCV. It takes 5 parameters - event that gives what is the event type, x and y the position of mouse, flags that can give us any flags that mouse events raise and some other param related to mouse callbacks. We can ignore flags and params for this case.
• We have 3 conditions here. if event == cv2.EVENT_LBUTTONDOWN checks for if the left mouse button down event occurred or not, if it happens then we will set draw to True.
• elif event == cv2.EVENT_MOUSEMOVE this condition checks if the mouse is moving, we simply don't want a moving mouse to draw on the paint area but we want a left button down moving the mouse to draw on the paint area, that's where the draw variable comes in, which will be checked to see if a left mouse button is actually down or not. Then it creates a circle of defined radius that it gets from the Brush Size trackbar, the colour of the circle from the BGR trackbar and colour fill is done via the last -1 parameter value. This creates a circle while moving a mouse and this happens so smoothly that it shows an effect of a paintbrush.
• elif event==cv2.EVENT_LBUTTONUP is for when the mouse button is not clicked and we don't want to draw on the paint area. Here, we set draw to False and draw the last circle on positions given.

Now, let's put trackbar and mouse event callback. Also, we will create a loop to continuous display the changes to the image window.

Trackbar, Mouse Event Call and Main Loop

Add the following code to the same file:

cv2.createTrackbar("R", window_name, 0 ,255, update_R_value)
cv2.createTrackbar("G", window_name, 0, 255, update_G_value)
cv2.createTrackbar("B", window_name, 0, 255, update_B_value)
cv2.createTrackbar("Brush Size", window_name, 1, 8, nothing)
cv2.setMouseCallback(window_name, draw_circle)

• Here, we create a trackbar for R, G, B colour values and for Brush Size adjustment. cv2.createTrackbar method takes the following arguments, trackbar name R, window name where the trackbar needs to be put (here window_name), start value 0, end value 255 of trackbar and last is a callback function which calls update_R_value whenever trackbar value gets changed. All 4 trackbars are similar to this structure and are self-explanatory now.
• cv2.setMouseCallback takes 2 parameters to set a mouse callback event, first one is the image window window_name on which this callback event should be tracked and the second is the callback function to call when a mouse event occurs.

Notice here, that we don't have separate callback methods for MOUSE_UP or MOUSE_DOWN, but only a single one that captures all events with a passed parameter to callback function event and later we can use conditionals to filter them out.

Now, add the following code to the same file for our main loop:

while(1):
    cv2.imshow(window_name, img)
    key = cv2.waitKey(1) & 0xff
    if key==ord('q'):
        break

    b = cv2.getTrackbarPos("B", window_name)
    g = cv2.getTrackbarPos("G", window_name)
    r = cv2.getTrackbarPos("R", window_name)
    cv2.rectangle(img, color_win_position[0], color_win_position[1], (b,g,r), -1)

cv2.destroyAllWindows()

• Here, we want the loop to continue until it encounters a keyboard keypress event. We are going to quit the application whenever the Q key is clicked.
• Inside the loop, we are checking for keyboard quit condition and also getting BGR values and displaying them in a rectangle at color_win_position.
• At last, if the program exits the loop, then we simple destroy the unwanted image window using the cv2.destroyAllWindows method of OpenCV.

Well, that's complete our code.

For complete script, please visit here.

Now, let's look at the demo.

Conclusion Demo

Displaying colour trackbar values.

Displaying colour trackbar colours.

Changing brush size.

Hello World, CodeKaro!

I know, my paint skills are very poor!

What Next?

Well, that's it from me. If you want to explore further, the following activities can be done to add more feature to the paint application:

• Add utility to select brush type. Add rectangle, diamond, hexagon, etc shaped brushes.
• Try to include no-fill brush utility.
• Try to add a function that creates a circle or rectangle with a given size with a double click of the mouse on the paint area.
• Add a utility to clear the area and restart the work, by not having to close and restart the program.

• Just starting your Open Source Journey? Don't forget to check Hello Open Source

• Need inspiration or a different perspective on the Python projects or just out there to explore? Check Awesome Python Repos

• Want to make a simple and awesome game from scratch? Check out PongPong

• Want to ++ your GitHub Profile README? Check out Quote - README

Till next time!

Namaste 🙏