DEV Community: Sahil Bondre

☄Deep Dive into Object Oriented Programming: Part 2

Sahil Bondre — Thu, 23 Sep 2021 13:26:31 +0000

In the last post, we started with the basics of Object-Oriented Programming. We made our first class. Added some members and methods to it and initialized an object of the Car class. It's time to dive deeper now.

Earlier, we had defined a refuelTank method to increase the fuel in our car. Now when I have a car object with me, no one stops me from changing the fuelLeft value without using the refuelTank method. I can directly access the member using the dot operator and change its value:

car.fuelLeft = 500;

In the real-life, I cannot magically change the fuel in my car. That's against the laws of physics. But apparently, I can do that in the software version of my car. To solve this, we'll introduce access modifiers.

Access Modifiers

Java has three keywords to solve this problem: public, private and protected. When something is public, everyone can access it. When something is private, it can only be accessed internally. We'll talk about protected in some time.

To prevent someone from magically changing the fuelLeft member, we'll add the private keyword before its definition in the class. This will prevent it from being accessed using the dot operator.

// Car.java
private Integer fuelLeft;

But this creates a different problem. In our main method, we used the fuelLeft member to print the value. Not to magically change the value but just to have a look at its value.

//Main.java

// ERROR!
System.out.println(honda.fuelLeft);
honda.refuelTank(100);
System.out.println(honda.fuelLeft);

Running the above code will give us an error. To preserve the functionality to be able to view the data, we'll create a "getter" method in the Car class:

// Car.java

int getFuelLeft() {
    return fuelLeft;
}

Since this method belongs to and is "inside" the class, it can access the private members. So it just takes the value and returns it. Now we can refactor our main function code to use this method instead of the member:

System.out.println(honda.getFuelLeft());
honda.refuelTank(100);
System.out.println(honda.getFuelLeft());

And voila! Everything works as before with additional security of not changing the fuelLeft member magically.

Refactoring Other Members

If you think about it, all the other members of the Car class should be private by the same argument of not changing their value manually. Let's make all of them private and add getter functions to them:

public class Car {
    private String name;
    private String color;
    private Integer peopleCapacity;
    private Integer fuelLeft;
    private Integer distanceTravelled;

    public String getName() {
        return name;
    }

    public String getColor() {
        return color;
    }

    public Integer getPeopleCapacity() {
        return peopleCapacity;
    }

    public Integer getFuelLeft() {
        return fuelLeft;
    }

    public Integer getDistanceTravelled() {
        return distanceTravelled;
    }
    // other methods...
}

Access of methods

Just like members, we can add access modifiers to our class methods as well. If a class method is private, it cannot be called using the dot operator in the object. It can only be used internally by other methods inside the class. And that is the reason we had

In the last post, we defined our constructor as public. Now let's make sense of it. Our constructor needs to be accessible from anywhere to initialize the object from the class. Hence, we made it public. Let's now define a private method. When we start the engine, the car also checks if all the systems are working in proper condition. Let's call this method checkSystems. This method shouldn't be used by the car user but just called internally by the startEngine method.

// Car.java

private void checkSystems() {
    System.out.println("Checking Systems...");
}

void startEngine() {
    checkSystems();
    System.out.println("Starting Engine!");
}

Now when we call startEngine on the car object from the main method, it'll print "Checking Systems..." too. However, we cannot access the checkSystems method externally:

// Main.java

// ERROR
car.checkSystems();

Now you may wonder, earlier all members and methods in the Car class were neither public nor private; still we could access them. Why is that? If nothing is mentioned, does java make them public by default? The short answer is not really. Let's take a step back and understand what packages are in java.

Packages

Packages in java are used to group similar classes (and sub-packages) together. At the start of each java class, we mention the package name:

package com.godcrampy.oop_deep_dive;

Conventionally, to avoid naming collisions, companies use reverse domain names as a prefix for the package name. So if let's say if a company has its domain as example.com and is developing a utility for helpful string operations, it may name it as com.example.string_util. Packages can contain sub-packages too. So, suppose the string operations utility has a section for generating random names. In that case, it could be in a package called com.example.string_util.random_name.

All the class files are structured in directories according to the package name. For example, let's consider the java project that I am using for this tutorial. I have defined the package name as com.godcrampy.oop_deep_dive. All the source code for my project is in the src/main folder of the repository with the following structure:

    └── src
        └── main
            └── java
                └── com
                    └── godcrampy
                        └── oop_deep_dive
                            ├── Car.java
                            └── Main.java

Now let's move our Car class to a subpackage called vehicle. To do this, I created a new directory called vehicle and moved the class there:

└── src
    └── main
        └── java
            └── com
                └── godcrampy
                    └── oop_deep_dive
                        ├── Main.java
                        └── vehicle
                            └── Car.java

Now we need to update the package declarations of our Car class. So I change the first line of the Car class from package com.godcrampy.oop_deep_dive; to package com.godcrampy.oop_deep_dive.vehicle;

Now, if you are coding along with this tutorial, you may notice that your IDE has already started showing some errors. honda.startEngine, honda.refuelTank and honda.drive methods are not accessible in the main function.

For these methods, we didn't add the public or private keywords. So when a member or method has no access modifier specified, it gets the default access. This means that they can be accessed in some other class only if both the classes are in the same package. In our example, both Main and Car classes were in com.godcrampy.oop_deep_dive package. So everything worked fine before. So when we moved Car to com.godcrampy.oop_deep_dive.vehicle package, all the default methods became inaccessible.

Fixing the defaults

To fix this, I'll make all the default methods in our car class public. So finally, the Car class looks like this:

package com.godcrampy.oop_deep_dive.vehicle;

public class Car {
    private String name;
    private String color;
    private Integer peopleCapacity;
    private Integer fuelLeft;
    private Integer distanceTravelled;

    public String getName() {
        return name;
    }

    public String getColor() {
        return color;
    }

    public Integer getPeopleCapacity() {
        return peopleCapacity;
    }

    public Integer getFuelLeft() {
        return fuelLeft;
    }

    public Integer getDistanceTravelled() {
        return distanceTravelled;
    }

    public Car(String name, String color, Integer peopleCapacity) {
        this.name = name;
        this.color = color;
        this.peopleCapacity = peopleCapacity;
        this.fuelLeft = 100;
        this.distanceTravelled = 0;
    }

    private void checkSystems() {
        System.out.println("Checking Systems...");
    }

    public void startEngine() {
        checkSystems();
        System.out.println("Starting Engine!");
    }

    public void refuelTank(int fuel) {
        fuelLeft += fuel;
    }

    public void drive(int distance) {
        System.out.println("Driving...");
        distanceTravelled += distance;
    }
}

Now all the errors are gone, and we are good to go. If you notice, at the start of the class as well, we added the public keyword: public class Car {. This follows from the same access rules as we discussed before.

In summary:

Acess Modifier	Within Class	Within Package	Outside Package
Private	Y	N	N
Default	Y	Y	N
Public	Y	Y	Y
Protected	?	?	?

The protected keyword is still to be investigated. We will do that in the next post.
That wraps it up for the post. We understood what access modifiers are and how they can be used to improve the security of our code. We also explored packages in java and how to organise our code. You can find the code mentioned in the post here: https://github.com/godcrampy/oop-deep-dive-notes

I hope you liked the post. If this was helpful, please show some love by clicking ♥, 🦄 and saving the post for later. Feel free to express your suggestions and opinoins in the comments below. Oh, BTW do you want to learn Bash? Here's my crash-course post on Shell Scripting:

🚀 The Missing Shell Scripting Crash Course

Sahil Bondre ・ Apr 21 '20

#bash #linux #beginners

🌟 I made some Cheat-Sheets
🚀 Follow me on Github | Twitter
📜 Check my Website
😄 Have a wonderful day!

☄Deep Dive into Object Oriented Programming: Part 1

Sahil Bondre — Fri, 17 Sep 2021 17:07:16 +0000

Introduction

In this series of posts, We are going to explore object-oriented programming. We'll start with a few basic concepts, then build upon them, trying to dig more and more into the depths of object-oriented programming.
Object-oriented programming is one of the three popular paradigms of programming. The other being functional and procedural programming.

Procedural programming is based on making procedure calls. A procedure contains a series of instructions that need to be executed. Procedures are also commonly referred to as functions or routines. In procedural programming, we write a list of instructions to tell the computer what to do line by line.

Functional programming treats computation as a series of mathematical functions. Each function takes in data, does some computation and returns some data. A key idea in this paradigm is that state and data should be immutable. Thinking of computer programs as mathematical functions are quite an exciting idea; we'll save it for another post!

Finally, object-oriented programming tries to map real-world objects into the software. Using object-oriented programming, we can model the properties and the functions of things that appear in our natural world and simulate them in our computer programs.

Class vs Object

OOP boils down to emulating real-world things in our code. Every real-world item has some properties and a few things it can perform. Let's say we want to model a car in our code. Let's consider a few properties of a car:

What is its name? String
What is its colour? String
How many people can it accommodate? Integer
How much fuel is there in the car currently? Integer
How much distance has it travelled so far? Integer

Let's also assume that the car can perform some essential functions like:

Start the engine
Refuel the tank
Drive a certain distance etc.

Now we'll model our car in code. We need to define a class like a blueprint describing all these car characteristics to the programming language.

Defining the Class

package com.godcrampy.oop_deep_dive;

public class Car {
    String name;
    String color;
    Integer peopleCapacity;
    Integer fuelLeft;
    Integer distanceTravelled;

    public Car(String name, String color, Integer peopleCapacity) {
        this.name = name;
        this.color = color;
        this.peopleCapacity = peopleCapacity;
        this.fuelLeft = 100;
        this.distanceTravelled = 0;
    }

    void startEngine() {
        System.out.println("Starting Engine!");
    }

    void refuelTank(int fuel) {
        fuelLeft += fuel;
    }

    void drive(int distance) {
        System.out.println("Driving...");
        distanceTravelled += distance;
    }
}

Let's break the code down piece by piece:

Members

    String name;
    String color;
    Integer peopleCapacity;
    Integer fuelLeft;
    Integer distanceTravelled;

These are known as the members of the class. Imagine them to be variables of the class. When we make a new car, every car object will get its own copy of these variables. I've defined them as either String or Integer as per the property of the car that they represent.

Methods

    void startEngine() {
        System.out.println("Starting Engine!");
    }

    void refuelTank(int fuel) {
        fuelLeft += fuel;
    }

    void drive(int distance) {
        System.out.println("Driving...");
        distanceTravelled += distance;
    }

These are the methods that we've defined to imitate various functions of a real-world car. startEngine imitates the starting of the engine by printing to the console. refuelTank takes in an Integer and increases the fuelLeft member of the class by that amount. The same goes for the drive method that increases the distanceTravelled member and prints out a message on the console.

Constructor

    public Car(String name, String color, Integer peopleCapacity) {
        this.name = name;
        this.color = color;
        this.peopleCapacity = peopleCapacity;
        this.fuelLeft = 100;
        this.distanceTravelled = 0;
    }

This is a unique method of the class called the constructor. Ignore the public keyword; we'll get back to it later. Notice that it has the same name as the class. Also, notice that we don't specify any return type (like void or int). The blueprint class tells Java about something known as a Car, but it does not create a car for us. When we make a car, we need to invoke the constructor method. So essentially, the constructor is the first method that is called when we create a car from the class.

Have a look at the bunch of this keyword here. The constructor has three parameters name, color and peopleCapacity. We use these to set the initial values of our own members in the class. Now to distinguish between the name of our class and name of the constructor, we use this keyword. The parameter name belongs to the function scope and just writing name points to the parameter. To access the member name, we use this.name as it is in the outer scope of the class. Now let's actually make a car object from the class that we have defined over here.

Creating the Object

package com.godcrampy.oop_deep_dive;

public class Main {
    public static void main(String[] args) {
        Car honda = new Car("Honda", "Red", 4);

        honda.startEngine();

        System.out.println(honda.fuelLeft);
        honda.refuelTank(100);
        System.out.println(honda.fuelLeft);
    }
}

Output:

Starting Engine!
100
200

Let's step through the code line by line and see what's happening:

Car honda = new Car("Honda", "Red", 4);

We use the new keyword to instantiate an object from a class. The Car in Car honda = refers to the type of the variable honda. The Car in new Car(...) is a call to the constructor. Observe the parameters we are passing are precisely the same as the constructor above expects. This runs the code in the constructor and sets the members accordingly.

honda.startEngine();

Here we are calling the startEngine method of the Car. We use . operator to access members and methods of the object. This, in turn, runs the imaginary code to start our car's engine and prints "Starting Engine!" on our console.

System.out.println(honda.fuelLeft);

Here we are accessing the value of thefuelLeft variable of the car and printing it out.

honda.refuelTank(100);
System.out.println(honda.fuelLeft);

The refuelTank function increases the fuelLeft of the honda car, and on the following line, when we print it again, we can see the final value to be 200.

What did we discover?

We have now established the basics of Object-oriented programming. Let's take a step back and analyze the consequences of what we have discovered so far. In procedural programming, we used to pass data into procedures to performs computations. In this paradigm, the data itself can perform operations on itself. The Car class has all its properties built-in and knows all the tasks it is supposed to serve. This new way of thinking about programs has its own advantages and disadvantages:

Advantages:

Classes are logically a layer of abstraction above writing simple procedures. This makes it easier to write complex software.
It's easier to write and maintain code (open to debate :P)
Object-oriented code has a reasonable degree of reusability. The standard library of Java is a beautiful example of this.

Disadvantages:

Look at the lines of code we wrote and what we printed out. A large number of lines of code is required to set up things and bootstrap even the most straightforward programs.
Computer hardware still executes code pretty much in a procedural way, line by line. Object-oriented code runs a bit slower as it requires extra processing layers before it reaches the silicon level.

That wraps it up for the post. We laid the foundation to build upon even more object-oriented programming concepts in the upcoming stream of posts. You can find the code mentioned in the post here: https://github.com/godcrampy/oop-deep-dive-notes

I hope you liked the post. If this was helpful, please show some love by clicking ♥, 🦄 and saving the post for later. Oh, BTW do you want to learn Bash? Here's my crash-course post on Shell Scripting:

🚀 The Missing Shell Scripting Crash Course

Sahil Bondre ・ Apr 21 '20

#bash #linux #beginners

🌟 I made some Cheat-Sheets
🚀 Find me on Github | Twitter | Website
😄 Have a wonderful day!

🌞 Java I/O with java.io Package

Sahil Bondre — Wed, 14 Jul 2021 10:30:10 +0000

In this video, we'll look at the java.io package. This package implements input and output through streams of data.

I'll go over various classes in the java.io package that allows us to perform operations on data streams. I'll explain the hierarchy of these classes and show how to use them together in a program to perform IO.

Oracle java.io Documentation

And that is it, folks. Let me know your takeaways from the video. If you have any other video or article ideas, comment on them too. Oh, BTW, do you want to learn Bash? Here's my crash-course post on Shell Scripting:

🚀 The Missing Shell Scripting Crash Course

Sahil Bondre ・ Apr 21 '20

#bash #linux #beginners

🌟 I made some Cheat-Sheets
🚀 Stalk me on Youtube | Github | Twitter | Website
😄 Have a wonderful day!

📦 How is C++ Compiled?

Sahil Bondre — Sun, 11 Jul 2021 12:16:25 +0000

I've been using C++ for quite a while now. This got me into thinking, how does C++ work under the hood? So I came up with this short video in which I explain the whole C++ compilation process.

🚀 The Missing Shell Scripting Crash Course

Sahil Bondre ・ Apr 21 '20

#bash #linux #beginners

🌟 I made some Cheat-Sheets
🚀 Stalk me on Youtube | Github | Twitter | Website
😄 Have a wonderful day!

🐋 ELI5 Docker: Easy Docker Concepts in 5 Minutes!

Sahil Bondre — Sun, 17 Jan 2021 14:13:40 +0000

A Story

Let's start with a story first. Mary was a painter in the Medieval era who was really good at drawing portraits. She wanted some career change. Nature was more exciting to her than the faces of people. So she decided to travel. She travelled all the way to the beautiful Fjords in Norway for some inspiration.

Photo by Robert Bye on Unsplash

She quickly realized that the environment around her was not suitable.
It was way too cold. Norwegian food wasn't her favourite either. And she couldn't work without her canvas and pigments.

She came up with a plan. On a piece of paper, she noted all the things she needed to live, eat, sleep, and paint in the foreign land. She further listed where to get them and wrote the steps to build a small abode to live and work for a few weeks peacefully.

She went to Amazon (the internet was built in Renaissance!), fetched all the things and made her a small cabin according to her paper's recipe. She then could work peacefully in an environment that was suitable to her. A few days later, a friend who fancied changing jobs wanted to join her too. Mary then gave the page containing the instructions to John. Since all the ingredients and steps were already documented, John made his own cabin in no time and got to work in Norway too. End of story!

Photo by Olivier Guillard on Unsplash

What's Docker

Let's get back to Docker now:

The painters in the story are like the programs that we write. They might work correctly on our machine but maybe not on someone else's computer. The other system may have a different version of Python or Node, different pre-installed packages or even a completely different OS. As in the story, our applications won't work in a completely different environment, so we need to build a small cabin to do their job comfortably. These are known as Images.

Docker Images

Docker Images include our application's source code and all the tools, libraries, and packages that it needs to run. We can run these Images as an instance of a Container.

Docker Container

A Container is a lightweight, independent, executable software package with everything you need to run the application. Images are more of a blueprint, and Containers are more like an executable file.
Remember the page that Mary had made? In the Docker world, we call it the Dockerfile.

`Dockerfile`

A Dockerfile is a text file that includes the recipe to build the Docker Image. It specifies the OS, languages, environmental variables, file locations, network ports, and other components that our app requires.

Mary could build everything she needed with the help of Renaissance Amazon. Now that's like Docker. To quote the official documentation:

"Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications."

Docker Registry

Now let's assume she posted a picture of her page with the recipe (along with links to Amazon) on her Medieval Blog so other people can use it, that would be an example of a public Docker Registry.
A Docker Registry is where the Docker Images are stored. The registry can be either private or public. Several people can collaborate and share images by uploading them to the registry.
One such example of a Docker registry is the Docker Hub. What Github is for code, Docker Hub is for Docker Images.

Next Steps

So, I've covered all the basic concepts that you'll require to get started to use Docker. There are several resources on the internet from where you can learn docker. I'll list down a few that I've used personally:

Installing Docker

The Docker suite contains two principal tools: Docker Engine and Docker Desktop.
The Docker Engine is the core set of docker tools required to run docker commands and containers on your machine.

Docker Desktop is a GUI that talks to the underlying Docker Engine to make your life easy.

What's next?

Docker is among the first steps to learn about Microservices and DevOps. You can start learning about the microservice vs monolith philosophy, container orchestration, Kubernetes there's lots and lots of great stuff to learn!

🌟 Thank's for reading! I'd love to hear any feedback, opinions, and ideas for what I should write on next.
😄 Have a wonderful day!

🚀 Github Hidden Feature: Profile README

Sahil Bondre — Thu, 09 Jul 2020 13:31:10 +0000

Github has a brand new secret feature! Now you can setup a README for your entire profile. Here's how mine looks: godcrampy

To enable this, make a repository with the same name as your username:

Then add a README.md which will then be displayed on your profile page. And that's it!
Thanks, Github for this super cool feature!

🌟 I made some Cheat-Sheets
🚀 Stalk me on Instagram | Github | Twitter | Website
😄 Have a wonderful day!

Discuss: What's the one thing you hate about programming?

Sahil Bondre — Fri, 26 Jun 2020 17:01:41 +0000

What's that one thing that annoys you? What's that one thing that you would improve if you were made the god of programming?

Alternatively, what was that one thing that was a significant roadblock in your programming history?

(PS: You can rant about more than one issue)

To Die List: My first indie app!

Sahil Bondre — Fri, 05 Jun 2020 08:46:40 +0000

I made my first app as an indie dev! It's a todo list app with some gamification dust sprinkled on it. The idea is that every time you create a todo/task, there's a timer running down. If you complete the job before the timer hits zero, some additional time is added to the timer for the rest of your tasks. But instead, if the timer hits zero, then one of your tasks will be randomly killed(deleted).

The app is currently available on Android only. If people end up liking the Android version, I'll make one for IOS. Here are the links:

The pro version offers additional features such as dark mode and starrable todos. I'd really appreciate it if you could buy the pro version and help me in my indie app journey!

I'd love to hear feedback from you guys. Please feel free to let me know about any suggestions and bugs you may find.

How I built this

I've made this app using flutter which allows you to create cross-platform apps. Flutter makes it really easy to quickly build mobile apps. If you know React, flutter is a weekend job to learn. If you don't, then two weekends are enough!

🌟 I made some Cheat-Sheets
🚀 Stalk me on Instagram | Github | Twitter | Website
😄 Have a wonderful day!

💡 10 VS Code extensions I can't code without

Sahil Bondre — Thu, 30 Apr 2020 16:00:38 +0000

VS Code is my favourite text editor. It is the most extensible and popular code editors out there. And surprisingly it's made by Microsoft (i know). In my opinion, no other IDE or editor comes even half as close as to what VS Code does. What makes it so robust is it's extension system. It allows you to write an extension for every possible use case you can think of. Here are my top 10 extensions.

1. Beautify

ext install HookyQR.beautify

Beautify allows you to format html, js, css, JSON and sass file with your own custom style configuration. It extends over the internal js-beautify and makes it customizable to your personal style.

2. Better Comments

ext install aaron-bond.better-comments

This extension allows you to add semantics to your comments. It categorizes into categories like comments into alerts, queries, todos and highlights.

3. Bookmarks

This one is a lifesaver, especially if you find yourself lost in hundreds of lines of code. This extension allows you to bookmark any line of code. Then when you need to go back all you need to do is browse through the list of bookmarks and select the line you want to visit.

4. Bracket Pair Colorizer 2

ext install CoenraadS.bracket-pair-colorizer-2

This one does exactly what its name suggests. It colour codes correlated pairs of brackets. This helps a lot when you end up several scopes deep into code.

5. Format in Context Menus

ext install lacroixdavid1.vscode-format-context-menu

This extension allows you to format all your files by just selecting them from the side-bar. This is especially useful when you have tonnes of files, and your environment does not support formatters and linters.

6. Git Graph

ext install mhutchie.git-graph

It allows you to view a Git Graph of your repository, and quickly perform Git actions from the graph. It is highly configurable and has lots of features. Explaining the goodness of this extension will probably take a whole new post.

7. Git Lens

ext install eamodio.gitlens

GitLens helps you to reflect code authorship at a glance via Git blame annotations and code lens. It enables you to seamlessly navigate and explore Git repositories, gain valuable insights via robust comparison commands, and so much more.

8. indent-rainbow

ext install oderwat.indent-rainbow

This extension colourizes the indentation of code, in different colours on each indent level. This is especially helpful in deep scopes with languages like Python.

9. Path Intellisense

ext install christian-kohler.path-intellisense

Path Intellisense adds auto-completion to file paths. While VS-Code natively supports auto-completion, it is limited to only HTML, CSS and JavaScript files. This extends it to all languages and file types.

10. Total Lines

ext install praveencrony.total-lines

This a handy little extension add the number of lines of the currently opened file in the status bar. A neat addition to your extension collection.

And that is it folks. These are my top VS Code extensions. I'd like to hear your favorite extensions in the comments. Oh, BTW do you want to learn Bash? Here's my crash-course post on Shell Scripting:

🚀 The Missing Shell Scripting Crash Course

Sahil Bondre ・ Apr 21 '20

#bash #linux #beginners

🌟 I made some Cheat-Sheets
🚀 Stalk me on Instagram | Github | Twitter | Website
😄 Have a wonderful day!

🔭 Git Stalker: Stalk GitHub users without leaving your terminal!

Sahil Bondre — Sat, 25 Apr 2020 13:35:40 +0000

Github is the platform for code and for developers. I'd spend tons of time stalking friends, colleagues and pros like Sindre Sorhus, Ryan Dahl, starring and forking repos and just slacking off Github. I'm sure you do too. Stalking code and devs on Github is fun. Can we make it efficient? Can we make it mouse-less? Can we do it from the terminal itself?

Well, now you can with Git Stalker.

I made git-stalker, which is a CLI that allows you to stalk people on GitHub from your terminal. It shows you the profile of the dev, what (programming) languages do they speak and what have they been up to lately. Here's the demo:

Install

You need node + npm to install this CLI.

$ npm i -g git-stalker

# or using yarn

$ yarn global add git-stalker

Usage

$ stalk <github-username>

# For example
$ stalk godcrampy

Built With

Typescript
GitHub API
And several awesome dependencies

What's Next?

So the current release allows stalking people. Why not hunt repos? I'll probably work on that. If you have any ideas, please open up an issue.

Here's the repo for Git Stalker.

godcrampy / git-stalker

🔭 Stalk GitHub users without leaving your terminal

Git Stalker

Stalk GitHub users without leaving your terminal.

Install

$ npm i -g git-stalker

# or using yarn

$ yarn global add git-stalker

Usage

$ stalk <username>

# For example
$ stalk godcrampy

Authors

Sahil Bondre - godcrampy

License

This project is licensed under the MIT License - see the LICENSE file for details

View on GitHub

🌟 I made some Cheat-Sheets
🚀 Stalk me on Instagram | Github | Twitter | Website
😄 Have a wonderful day!

How to Publish your Dart Package

Sahil Bondre — Thu, 23 Apr 2020 14:17:45 +0000

In this tutorial, I'll be making a Dart Package from scratch. I'll be going over all the steps for creating a package from coding till publishing.

The Package

For this tutorial, I made a package that provides commonly used regex patterns. Let's go over how the library works before building it.

Installation

# pubspec.yaml
dependencies:
  regex_toolkit: ^1.0.0

$ pub get

Usage

import 'package:regex_toolkit/regex_toolkit.dart';

void main() {
  var email = 'john@doe.com';

  if (RegexToolkit.emailId.hasMatch(email)) {
    print('Valid Email');
  } else {
    print('Invalid Email');
  }
}

$ dart main.dart
Email Valid

Building

Let's build our package now.

1. Setup

We'll use stagehand to bootstrap a starter template.

$ pub global activate stagehand
$ mkdir <project_name>
$ cd <project-name>
$ stagehand package-simple

This sets us up with a boiler template of a simple Dart package.

.
├── analysis_options.yaml
├── CHANGELOG.md
├── example
│   └── <project-name>_example.dart
├── lib
│   ├── <project-name>.dart
│   └── src
│       └── <project-name>_base.dart
├── .gitignore
├── pubspec.lock
├── pubspec.yaml
├── README.md
└── test
    └── <project-name>_test.dart

2. Code

Next up is the actual coding part. Dart package convention is to write all of your code in lib/src directory and export required code through in src/<project-name>.dart file:

// lib/src/regex_toolkit_base.dart
/// Base class containing all the [RegExp] instances
class RegexToolkit {
    // All the code
}

// lib/regex_toolkit.dart
/// A collection of commonly used regular expressions.
library regex_toolkit;

export 'src/regex_toolkit_base.dart';

3. Test

Tests are written in test/ directory. Each test-suite comprises of a group which consists of several tests. Each test test one specific functionality. Assertions are done using the expect function, which takes in two arguments: actual and expected. If both of them match, then the test passes.

group('Common regualer expressions', () {
  setUp(() {
    // Add setup code if any
  });

  test('adds two numbers', () {
    expect(1 + 1, 2);
  });

  // More tests...
});

4. Documentation

When it comes to documentation, there are three places you need to write documentation in: README.md, example and comments.

README.md is reasonably apparent, every GitHub repo has that. The example directory should some code showing a sample use of the package. Here's how I have done in my package:

// example/main.dart
import 'package:regex_toolkit/regex_toolkit.dart';

void main() {
  var email = 'john@doe.com';

  if (RegexToolkit.emailId.hasMatch(email)) {
    print('Valid Email');
  } else {
    print('Invalid Email');
  }
}

You might have noticed that comments with three forward slashes: ///. These are used by Dart to form the package documentation.

/// Description of what this function does
void foo() {
  // code
}

This documentation is what is shown in the API Reference of your package once published. To get a preview, run dartdoc in your project directory. dartdoc will create the documentation preview in doc/api directory. You can open up the doc/api/index.html to preview the generated documentation.

5. Publish

Once you are confident enough with your code, tests and documentation, it's time to publish your code to pub.dev. Before publishing, it's a good practice to check for the following things:

Make sure all tests pass
Run dartanalyzer and fix errors is any
Run dartdoc and verify the docs
Make sure that README.md, CAHNGELOG.md and pubspec.yaml are updated

Before you can publish, you need to sign in with your Google account on pub.dev. Once that is done, run the following command to test your build:

$ pub publish --dry-run

If you get no errors, run:

$ pub publish

The CLI will ask you to login again, which is trivial.

And there you have it. That's how you make your own dart package. As mentioned above, I made my own package which is a collection of common regex patterns. If you are getting started with Open Source, contributing to this package will be a good starting point. You can add any of the regex patterns which you feel are missing. One major regex which is missing is the time pattern. Hope someone sends a pull request for add that 😄.

🌟 I made some Cheat-Sheets
🚀 Find me on Instagram | Github | Twitter | Website
😄 Have a wonderful day!

🚀 The Missing Shell Scripting Crash Course

Sahil Bondre — Tue, 21 Apr 2020 11:32:18 +0000

Bash is a shell and a command language. You can use it like any other language to write scripts. Bash scripts can run on Linux and Mac right off. For Windows, there's a small workout to be done. In this tutorial I'll be going over Shell Syntax and not Shell Commands like ls, grep, cat.

This crash-course will teach you all the necessary stuff you need to get up and running with writing shell scripts.

1. Hello World

All you need in this tutorial is your terminal and a text editor. Let's write a simple hello world in bash. Create a new file called script.sh and write the following code:

#!/bin/bash

echo "Hello World"

Now save this file. To make this executable, run chmod +x ./script.sh in your terminal. Then you can run the above script using ./script.sh in your terminal.

Hello World

Tah Dah! Your first bash script. Let's examine the code closely. The first line #!/bin/bash is called a shebang. It tells your computer which program to give this code to run. In our case, it is /bin/bash.
If you wanted to write javascript instead of bash you could write the following code.

#!/bin/node

console.log("Hello Javascript")'

$ ./script.sh
Hello Javascript

The above code will work only if you have node installed in /bin/ directory. So essentially you can write code in any language. All you need to do is specify which program can handle that code and your system will pass on that file to that program.

Let's hop back to bash now. In the above code, the second line is echo "Hello World". echo is a command which prints stuff to the Standard Output which is the terminal in our case.

2. Variables

Let's modify the above code a little bit.

#!/bin/bash

name="Bash"

echo "Hello, $name"

$ ./script.sh
Hello, Bash

We create a variable called name and store the string "Bash" to it. Then to access it, we need to reference it with $. If you forget the $ sign, bash will treat name as a string literal, and you'll get Hello name as output instead.

Note that there are no spaces around the = while defining a variable. Also, use double quotes while referencing.

3. User Input

Let's continue modifying our script. We'll request the user for their name and then greet them back.

#!/bin/bash

read -p "What is you name: " name

echo "Hello $name"

$ ./script.sh
What is you name: godcrampy
Hello godcrampy

The read command takes in one line of input from the Standard Input and saves it to the variable name. The -p flag allows us to pass a prompt of "What is your name: " before taking in the input.

One neat trick to reference variables in a string is to use curly braces:

#!/bin/bash

read -p "Enter an action: " verb

echo "You are ${verb}ing"

$ ./script.sh
Enter an action: cook
You are cooking

4. Comments

# Comments start with hash

Multiline Comments are a bit of a complicated mess.

5. Arguments

$1, $2 and so on, store the arguments passed into the script. $0 stores the file name.

#!/bin/bash

echo $0
echo $1
echo $2
echo "${@}" # Access all the arguments [More on this later]

$ ./script.sh first second
./script.sh
first
second
first second

6. Expressions

There are 3 common expressions: return values, arithmetic evaluation and test command. All three of these return either a true or false value.

Return Values
This is literally the return value of programs like grep, find.

Arithmetic Evaluation
Bash uses a parenthesis to denote arithmetic expressions.
Example: (( 1 <= 5))

Test Command
The test command often denoted by [ or [[ can carry out more complex operations:

[[ -e "$file" ]] # True if file exists
[[ -d "$file" ]] # True if file exists and is a directory
[[ -f "$file" ]] # True if file exists and is a regular file
[[ -z "$str" ]]  # True if string is of length zero
[[ -n "$str" ]]  # True is string is not of length zero

# Compare Strings
[[ "$str1" == "$str2" ]]
[[ "$str1" != "$str2" ]]

# Integer Comparisions
[[ "$int1" -eq "$int2" ]] # $int1 == $int2
[[ "$int1" -ne "$int2" ]] # $int1 != $int2
[[ "$int1" -gt "$int2" ]] # $int1 > $int2
[[ "$int1" -lt "$int2" ]] # $int1 < $int2
[[ "$int1" -ge "$int2" ]] # $int1 >= $int2
[[ "$int1" -le "$int2" ]] # $int1 <= $int2

Note that [ is actually a command. Try running $ where [.
test, [ and [[ are almost similar. There are a few subtle differences.

And & Or

[[ ... ]] && [[ ... ]] # And
[[ ... ]] || [[ ... ]] # Or

7. Conditionals

Now since we know, expressions let's use them in conditional statements.

# 1. Return values

# If notes.md file doesn't exist, create one and 
# add the text "created by bash"
if find notes.md
then
  echo "notes.md file already exists"
else
  echo "created by bash" | cat >> notes.md
fi

# 2. Arithmetic Evaluations
read -p "Enter your age: " age

if (( "$age" > 18 ))
then
  echo "Adult!"
elif (( "$age" > 12 ))
then
  echo "Teen!"
else
  echo "Kid"
fi

# 3. Test Expressions
# Check if argument was passed
# "$1" corresponds to first argument
if [[ -n "$1" ]]
then
  echo "Your first argument was $1"
else
  echo "No Arguments passed"
fi

The if statement has to end with fi.

If you are keen enough, you might wonder why I am using "$var" and not $var to reference the variables. Here's your answer. (Hint: Both work but double quotes are safer).

8. Looping

# print numbers 1 to 10

# c like for loop
for (( i = 1; i <= 10; ++i ))
do
  echo "$i"
done

# for in
for i in {1..10}
do
  echo "$i"
done

# while
i=1
while [[ "$i" -le 10 ]]
do
  echo "$i"
  ((i++))
done

# until
i=1
until [[ "$i" -eq 11 ]]
do
  echo "unitl $i"
  ((i++))
done

Iterating over arrays
Arrays are declared using parenthesis without commas between elements. More on arrays later on.

arr=(a b c d)

# For in
for i in "${arr[@]}"
do
  echo "$i"
done

# c like for
for (( i = 0; i < "${#arr[@]}"; i++))
do
  echo "${arr[$i]}"
done

# while
i=0
while [[ "$i" -le "${#arr[@]}" ]]
do
  echo "${arr[$i]}"
  (( i++ ))
done

${arr[@]} allows you to iterate over an array while ${#arr[@]} returns the length of the array.

Iterating over arguments
@ holds all the arguments passed in to the script

for i in "$@"
do
  echo "$i"
done

continue and break work the same way as in other programming languages. continue skips the current iteration. break quits the loop.

9. Arrays

Arrays in bash are defined with parenthesis with no commas separating the elements.

arr=(a b c d)

Read

echo "${arr[1]}"     # Single element
echo "${arr[-1]}"    # Last element
echo "${arr[@]:1}"   # Elements from 1
echo "${arr[@]:1:3}" # Elements from 1 to 3

Insert

arr[5]=e                            # direct address and insert/update
arr=(${arr[@]:0:1} new ${arr[@]:1}) # Adding 'new' to array

Delete

arr=(a b c d)
unset arr[1]
echo << "${arr[1]}" # Outputs nothing

Notice how once we delete the element at position 1, the following item does not take up its place. Once removing is done, we need to re-index the array.

arr=(a b c d)
unset arr[1]
arr=("${arr[@]}")
echo << "${arr[1]}" # c

10. Functions

Functions in bash have a kind of similar syntax as in other programming languages. Arguments to a function are accessed identically to the arguments to the script.

greet() {
  echo "Hello, $1"
}

greet Bash # Hello, Bash

The function definition does not specify any information of the arguments passed to it. Notice how while calling a function, parenthesis is not used. Instead, arguments are passed in separated by space.

All the arguments of a function can be accessed using @.

greet() {
  echo "Hello, ${@}"
}

greet every single body # Hello, every single body

And that's it for this crash course. You can now start writing your own shell scripts. There's more to be explored beyond what I have mentioned here.

🌟 I made some Cheat-Sheets
🚀 Find me on Instagram | Github | Twitter | Website
😄 Have a wonderful day!