DEV Community: Rohit

Teaching you all about APIs in 12 mins

Rohit — Tue, 28 Mar 2023 12:35:41 +0000

Did you know, With every passing day, the use of APIs and new APIs being released is growing massively, almost every application on our phone, web or Desktop is now using some sort of an API. Don't believe me? Do you listen to music through apps like Spotify or YT Music? Do you ever use transportation service apps like Uber? Do you watch movies on platforms like Netflix, Youtube etc? Do you use social media apps like Instagram, Hashnode or Twitter?

If you used/use any one of the apps of those categories above, You've interacted with an API already. You might not know it, but even hashnode(The platform you're reading this on) uses an API. As I said, with every passing day, APIs are growing in demand and new APIs are being built for multiple use cases.

So Today, Give me 5 minutes of your time so I can teach you all there is about APIs and help you get started right away! What are we waiting for? Let's dive right into it 👇🏻

What are APIs and Why use them?

You may have heard it before - it's short for "Application Programming Interface." It sounds like a fancy term, but it's actually quite simple. Let's break it down.

I am sure you have heard of Application, Programming and interface as separate words with different meanings.

An interface is like a doorway that allows different things to connect and interact. Think of the UI on your favourite app - it's how you use the app and communicate with it. That's an interface. But how do apps communicate with each other? That's where programming comes in.

Application and Programming are self-explanatory, but I will brief you about them anyways. Systems and devices don't understand our language and we cannot exactly write in their language, Programming is a way of communicating with computers, and systems by writing a set of instructions to perform any task. But how do different applications, systems or services talk to each other? That's where APIs come in.

In simple words, An API is a program or set of programs that allow different applications, codes or systems to talk to each other.

Still not sure you understand APIs? APIs act as mediators between a client( Typically an End-user or application) and a Server (The backend which consists of a database, functions etc).

Let's say, you use Paypal. When you click on pay, Ever wondered how is it that the app processes money from your account to the other person? APIs do it for you. APIs take care of going back to the server with your request and processing the request for you and come back with a response. More on this in a moment.

Why use APIs?

As humans and especially developers, we wanna streamline and optimise our systems and processes as much as possible. APIs are one such step in modern software development.

APIs enable code talking to each other and sharing of resources/services across various applications, devices and more.
You can build an API to automate tasks or events like checking the weather and integrate them directly with the application. How cool!
Some might have already seen this coming, The ability to build APIs to automate tasks, and events make it a digital product that can be used as a service or revenue stream for companies. For instance, Twitter recently made their API paid.
You can always learn and build APIs tailored to your use for internal organisation functions too.
Classifying APIs

APIs are of different types with each of them having different strengths, capabilities and use cases. They are not too many though, APIs can be classified into three simple types:

Types of APIs

*Hardware API
*
These are the type of APIs that are used to interact or talk to hardware components like devices or cameras of a device etc
Web API

These are the type of APIs used for code or software to interact with other code/software over a network. For instance, Fetching the score of a Live cricket match or tracking crypto prices
Software Library API

These are the type of APIs used to interact or give direct access to pre-written libraries which have various functions or methods that can be used to add specific functionality to our application.
Here's the part I love about APIs. You can use more than one API or multiple APIs to achieve the same task or integrate various APIs in an application. For instance, Uploading a tweet with an image on Twitter, it uses Hardware API to talk to the camera and get the image, then uses the software library API to apply any effects or filters of your choice, and then uses Web API to publish it on the server so users of Twitter can see your tweet and interact with it.

While you can use multiple APIs in an application, You cannot use all APIs everywhere meaning you need to know about accessibility.

Accessibility of API

Like variables in programming have a scope, similarly, APIs have a scope of who can use them too. What are they?

Public or Open API

These are the most common or widely used APIs since these are open to all for use and typically free. Anyone on the internet can have access to these APIs and can use them in their applications.

Private API

These are the type of APIs built internally for certain organisations or companies. These cannot be accessed but everyone, they can only be accessed by members of the org or people with access.

*Partner API
*
This is the type of API that is used by organisations that are related or have some kind of agreement in place.
So, these are the different types of APIs. With so many APIs out there already, How do you choose which API is the best for your application? More so, how do you build an API of your own? For that, you need to know about the different architectures of APIs.

Architectures of API

There are actually quite a few architectures that one can use to build their own API. I will be writing individual articles on each of these architectures including how to build your own API using certain architectures very soon, so make sure you subscribe to my newsletter here so you don't miss out on them.

For now, Let's take a brief look at different architectures

REST API

A REST API is probably the most widely used API architecture, especially for WebAPI. REST is an abbreviation of "Representational State Transfer". Ever used a food delivery app? Apps like these have menus that you can read from, edit and add to the cart and checkout. Here, your menu is like a REST API, it allows you to view different options, and perform actions based on your interaction.

SOAP

SOAP (Simple Object Access Protocol) defines a set of rules and protocols that describe how software applications should communicate with each other. It typically uses the XML format for data exchange and includes a WSDL, or Web Services Description Language, a file that describes the API's functions and data structures.
SOAP APIs are often used in more complex applications where security, reliability, and error handling are critical. Referring back to our Paypal example, A application might use a SOAP API to transfer funds between accounts or retrieve account information. The SOAP API would define the specific methods and data formats that the application needs to use to communicate with the bank's servers.

GraphQL

GraphQL is a relatively new API architecture that was developed by Facebook. GraphQL APIs use a query language to retrieve and manipulate data, allowing clients to specify exactly what data they need and reducing the amount of unnecessary data that is transferred.

gRPC

gRPC (Google Remote Procedure Call) API architecture is a modern, high-performance framework for building APIs that was developed by Google. It's designed to be fast, efficient, and scalable, making it ideal for large-scale distributed systems.
gRPC uses Protocol Buffers, a language-agnostic binary serialization format, to define the API contract and message format.
gRPC supports streaming and bi-directional communication, which allows servers and clients to exchange large amounts of data in real-time, without the need for multiple round-trip requests.

WebSockets

WebSockets API architecture is a protocol that provides a bi-directional, real-time communication channel between a client and a server over a single, long-lived connection. It's designed to enable real-time communication between web browsers and servers, making it ideal for building applications that require real-time data updates like chat rooms, online gaming, and real-time data visualization.
WebSockets support multiple message types, including text and binary messages, as well as support for custom protocols that can be defined by the application developer.

Webhooks

Webhooks are an API Architecture pattern that is designed to enable data integration across applications meaning able to send data from one application to another in response to a specific event or trigger, without the need for the receiving application to constantly poll for updates.

MTT

MTT (MQ Telemetry Transport) API architecture is a lightweight messaging protocol that's designed for connecting remote devices over unreliable networks with limited bandwidth. It's often used in Internet of Things (IoT) applications, where devices need to communicate with each other over low-bandwidth, high-latency connections.

Quite a few options and A lot to remember? Which is why you shouldn't. Yes, you don't have to learn about all the architectures now and cram them, it's of no good use.

Over time, based on your application requirement and more, pick the one that suits the best for you and start building or using one. As I earlier mentioned, the above is just a gist of API architectures available.

I will be writing blogs focused on each of them from defining and explaining them to building your own API. So, Make sure you follow and subscribe to my newsletter so you don't miss out :)

Now, you understand API types and architecture, But One thing you must've observed that's common in all is sending a Request and Receiving a Response. Are you wondering how exactly the API carry out instructions or makes calls? That's where Request and Response come in. Let's take a look at them

Request and Response

API calls were earlier made using the command line or cURL. Now there are actual tools like Postman out there that make it more easy, visual and human-friendly. You can choose to work with any of them, No wrong choice there. Irrespective of the tools you use to carry out calls, let's see how calls work.

This is something called Request-Response Pattern, which represents how computers communicate over a network. An API is an interface that lets us know what kind of response to expect when we make certain calls to a server.

Let us understand this with an example. Let's make an API call using Github API to retrieve a user's (In this case, Mine) details.

The API call using cURL would look something like this:
curl https://api.github.com/users/TRohit20
The above is a request you are making to the API Endpoint. And the response would look something like this:

It's a JSON File. Let us understand the request call and response more deeply now.

Each API has different types of Request methods that can be used to Read, Write, Delete and Update data or use APIs.

Request methods

When we make an HTTP call to a server, we specify a request method such as GET, POST, PATCH, or DELETE that indicates the type of operation we are about to perform. These are also called HTTP verbs.

In addition to a request method, a request must include a request URL that indicates where to make the API call.

A request URL has three parts: a protocol (such as http:// or https://), host (location of the server), and path (route on the server). In REST APIs, the path often points to a reference entity, like "users" in this case

Paths and full URLs are also sometimes called API endpoints.

But how do you know about the request methods of an API? Take the help of your best friend. Use the documentation of an API to get a better understanding of the API. The documentation has all the request methods and more with code snippets and examples

In fact, You can further optimise your API call by passing on Query and Path parameters.

Query Parameters

Query parameters are a way to pass information or filters for retrieving data. These are often appended to the Request URL followed by a '?'.

curl https://api.example.com/movies?genre=fiction&release=2023
Yes, you can have more than one query parameter passed by using a '&' between them.

Query parameters are given in Key-value pairs
**
Path Parameters**

A path parameter (or "path variable") is a dynamic section of a path and is often used for IDs and entity names such as usernames. These are located directly after a slash in the path. Can be anywhere in the path. It also accepts Dynamic values.
Often used for Entities names and IDs
Passing specific filters or data is fine, Now that you are requesting, what's a response? How does it work?

Response

API responses are the data that is sent back to the client after an API request has been made. A well-designed API response should contain all the information the client needs to understand what happened during the request and what data was returned.

API responses typically consist of two parts: the status code and the response body. The response body contains the data that is returned by the API, such as a JSON object or an HTML page as demonstrated earlier.

Response Status Code

The status code is a numerical code that indicates whether the API request was successful, unsuccessful, or encountered an error.

Status codes have conventions. For example, any status code starting with a "2xx" (a "200-level response") represents a successful call. Get familiar with other status code categories:

Again, you don't have to memorise them all, get a gist and learn them on the go as you work with APIs

Next steps

Now that you have a comprehensive idea of what APIs are, the different types, and how they work on a superficial level, it's time to get your hands dirty.

APIs usage is only growing by the day, learning about them and working with them is exciting. I will try to make them just as exciting for you.

This was the first of a series I am starting today on APIs. Here, I will be writing regular, consistent and fun blogs on API where I go from explaining to implementing and even building your own APIs with different architectures, use-cases and more. Subscribe to my newsletter and follow me on Hashnode Rohit T if you haven't already so you don't miss out on them.

Closing Remarks

That was it for today guys. I will see you very soon again. Until then,

Like |Comment | Share | Follow Rohit T for more!

You can catch me on my socials here, and even let me know how this article helped you, and what would you like me to cover next!

Beyond Code: How Anyone Can Contribute to Open-Source Projects

Rohit — Wed, 01 Mar 2023 15:07:40 +0000

Are you itching to make a positive impact on the tech community? Are you a student, professional, or just a tech enthusiast who wants to contribute to open-source projects but doesn't know where to start or how to proceed? Look no further! In the next 7 minutes, I'll show you the approach and mindset you need to get started on any open-source project, regardless of your skill level.

Contributing to open-source projects can be a rewarding experience, but it can also be intimidating, especially for beginners. That's why I'm here to guide you through the process, step-by-step. With this approach, you'll gain the confidence to contribute to any project you want and make a difference.

So, if you're ready to take the first step towards becoming an open-source contributor and learn the secrets to success, keep reading. We're about to embark on a journey that will change your life forever!

But, before we get started, not sure what open-source is? Don't worry, I have already covered this extensively in my previous blog. You can check it out here.

5 Steps to start contributing to any project!

1. The mindset

Firstly, you need to understand that open-source is truly open-for-all and anyone irrespective of background and experience can get involved. Are you a program manager? Doctor? Writer? Tester? Doesn't matter, you can get started today and contribute to projects you want because open-source contributions are not limited to code. Each of us has some strengths that can be leveraged by projects. What if we don't have any? Then just get involved using the below steps and start upskilling!

Fun fact: Kubernetes is the 2nd largest OS Project as of now. Most of it's contributors initially started out with non-code contributions such as documentation!

Contributions are not limited to code. You can contribute in more ways than one including but not limited to documentation, writing test cases, maintaining the project, maintaining the social channels of a project or communicating with others to get feedback etc.

Myth: You need to master tech stacks or be an expert to contribute!

Fact: If you have a basic idea as to what the project is about, you're curious to learn the tech and get involved. This is enough to contribute in numerous ways.

What better way to learn than by doing? So I am gonna teach you the approach by contributing to a Google Season of Docs and Linkfree where I will be adding myself to the list of participants for GSoD'23 and creating my Linkfree profile. Let's get right to it.

2. Understanding the project

Understanding a project doesn't mean you read all the code and get overwhelmed. Start simple.

When you look at projects, especially large codebases, they are so big with so many files etc that it is very easy to get overwhelmed and back out. But here's what you need to understand!

You don't need to understand the codebase to get started!

So, how to get started then?

Every project has a 'readme.md' file similar to the one here which can be described as the documentation or the abstract of the project. It contains all the crucial information for you to get started such as what the project does, what they expect from you, How you can run the project locally and so on. It gives you a gist of the project and gives you a lot of the information you need to get started.

Also, quick shoutout to Eddie Jaoude for such good documentation on his projects!

3. Ways to contribute

As I have already mentioned, there are more than one ways to contribute, let us look at a few, Shall we?

Using the issue tracker

Each project has an issue tracker which consists of issues raised meaning the project needs help with enhancing or fixing certain tasks. This is a great place to start when looking for ways to contribute! You can browse through the issues, and check out the ones that interest you or contribute to. How do you find good issues?

As you can see above, you can either browse through issues or search for them or filter them out using 'labels'.

'good-first-issue', and 'documentation' are some labels commonly found in all projects.

Now, it could be that you ran the project locally and found some issues, What then? You can also create your own issues and work on them after the project maintainer approves them. How cool is that?

Using Contributing.md

Each project also has a file called 'contributing,md'.

This is a file maintained by the project which is used to relay how one can contribute to the project.

The file mostly contains the steps you can take to start contributing which anyone can follow along with and recreate the steps.

Getting involved in socials

Each project has some sort of social space such as Discord, telegram or Slack that you can join and get involved.

Need help contributing? Feel free to ask your questions in public, you'll find answers.

Being active in these social channels and helping new individuals get started is also a way of contributing to the project.

It could be that some projects do not have a contributing.md file, you can connect with the project maintainers using these socials and find out how you can contribute.

You can even work on building a contributing.md file yourself, How cool and easy is that?

These are just some ways in which you can get involved right away! What now?

4. Start contributing

Using the contributing.md file, recreate the steps to contribute. Now, let us pick a scenario where you have no clue of the tech stack being used such as HTML, Javascript or so on. But you wanna contribute, What do we do now?

Take references!

There'll be someone else that must've contributed earlier right? So, look at how they did, in fact you can even just copy their code and make changes according to you. Here's how:

As you can see, to add myself as a participant in Google Season of Docs, I need to add my details in the demonstrated manner at the bottom of the list.

Don't worry if you don't know how to do it. Just recreate the steps as in contributing.md or you can take a look at someone else's work by editing the file.

When you edit the file, you see the work done by others, similar to the below image:

Feels overwhelming to look at, but if you look closely, it follows a pattern. Now to add my name as a participant, I will simply copy the code of any person here and paste it at the bottom of the file as instructed.

You don't have to remember anything practically speaking, you can reference previous work, copy and modify it as per your needs.

Once I have done that, I will now make changes to the file as required. Replacing the name field with my name and replacing the links with my links.

Now, how hard was that? You didn't have to google anything or learn the language, you just referred to another person's work and replicated it. Continue to contribute and get involved with projects, and try different things.

5. Socials

As mentioned above, get involved in the projects socials such as discord and learn in public, while getting started you might not know much, you can ask for help in these channels.

People will guide you and help you to contribute in numerous ways, They will guide you to resources that will help you learn more and get better. You can socialise and find people that are like-minded and work on solving issues together.

As you learn, you can also go through the pull requests raised and review them to the best of your knowledge. Even reviewing code is a part of Open-source contributions.

Stay active in social channels, help others, and share knowledge through communication, blogs, feedback and so much more.

Conclusion

As you can see, contributing is not limited to code. There's more to tech and open-source than just programming and writing code. The sky is the limit and ways to contribute are numerous. For instance, if you are a doctor, you can't code but you can share your expertise to help build a project related to healthcare.

It is called "Open" source for a reason. It is open for all to get take part irrespective of their background and profession. You can help in any manner you can and as often as you can.

Remember that as long as you don't act on it, you will never really get to it. So, take small steps but take steps to get to the place you wanna be.

Closing remarks

This was a bit generic blog on getting started with open-source as I have seen many struggle with it.

Like |Comment | Share | Follow me for more!

You can catch me on my socials here, and even let me know how this article helped you, and what would you like me to cover next!

Discover the Magic of Object-Oriented Programming: A Beginner's Guide to OOP Mastery

Rohit — Thu, 23 Feb 2023 12:33:10 +0000

Hey everyone, Welcome to the world of Object-Oriented Programming (OOP)! As a beginner, you might have heard about OOP being a fundamental aspect of software development, but don't quite understand what it is and how it works. Fear not, as this blog is here to demystify OOP and guide you through your journey to becoming an OOP master. Whether you're a tech-savvy individual or a non-technical person, this comprehensive guide will break down the concepts and techniques of OOP into simple, easy-to-understand terms. Get ready to dive into the world of OOP and discover the magic of this powerful programming paradigm.

Note: In this article, we will be discussing what are we doing, Not how we are doing (implementation). There will be different articles coming up language specific to teach how we implement these. :)

What is Object-Oriented Programming?

In simple words, Object-Oriented programming is the practice of breaking down your code into blocks/components such that they can be reused and even used to build upon. This practice of reusing the code makes it efficient and helps reduce redundant code. It also gets easier to write and maintain code.

Is Object-Oriented programming language specific?

Well, In short, NO! Object-oriented programming is not specific to a particular language. It is more like an adopted practice that can be applied to many different programming languages like Java, Python, Dart, and C++ to name a few.

Of course, the syntax and approach of each language are different but the underlying concepts and principles remain the same.

The implementation differs but the core principles of OOPs are "Universal".

The choice of programming language for implementing OOP will depend on the specific needs and requirements of a project, as well as the skills and preferences of the developers involved.

So, what are these universal principles? Don't worry, we will get to them but before we do, Let us take a look at classes and objects which are the basic and fundamentals of it. Let's go!!

Classes and Objects

Before we get into technically savvy, Let us look at a real-world example and understand them.

I am sure all of us here are aware of cars. We can define cars as a class. Now, this class of cars has some properties such as the "No. of wheels", "steering side", "fuel" etc and standard behaviours such as "starting an engine", "acceleration" etc. These are some basic properties that are used by various manufacturers to make their own cars. Now, these manufacturers use the features of class "cars" to make their own cars with even additional features if required and most importantly though the properties are the same, the values of those properties are unique. Toyota can derive properties from the class "car" to build fortuner(its own car) with more properties and the value of the properties like price, fuel type are all different. Even Ferrari will derive the. properties from the class "Cars" to build their car but their price will be much higher, they could only have 2 seats instead of one etc.

So, here these cars built by different manufacturers are nothing but "Objects".

Each of these objects would have its own unique values for the make, model, color, and other properties, but they would all inherit the same behaviours defined in the Cars class.

To define technically now, Objects are instances of a class.

A class is like a blueprint or a template for creating objects which defines the properties, methods or behaviour etc.

To make it simpler to understand: Remember that

Classes are just logical or virtual. On the other hand, objects are like the physical implementation of classes.

You can create a class using the "class" keyword in most languages.

How are these objects created? How are the objects able to inherit properties? You'll know soon enough.

Now that you know the fundamentals, it's time to jump into the principles of OOP.

Pillars of Object-Oriented Programming

Object-Oriented Programming has only four principles that act as its pillars of it. Let us dive into them:

Inheritance

Inheritance is a key concept that allows a new class to inherit properties and behaviours from an existing class. This helps to reduce the amount of duplicated code in a program and provides a way to reuse code.

Think of inheritance as a type of relationship between two classes, where one class (the child class) inherits from another class (the parent class). The child class has all the properties and behaviours of the parent class but can also add new properties and behaviours of its own. But parent class will not have any knowledge of the child class or its properties and behaviours.

Drawing on the above example, consider a car and a sports car. The car is the parent class, and the sports car is the child class. The car class has properties such as the number of wheels, the colour, and the number of doors. The sports car class inherits all these properties from the car class, but it also adds additional properties such as a faster engine and better handling.

By using inheritance, the code for the car class can be reused in the sports car class, reducing the amount of duplicated code in the program. This also makes it easier to maintain the code, as changes to the car class will automatically be reflected in the sports car class.

Inheritance can also be defined as a class extending another class and ironically inheritance can be implied by using the "extends" keyword. you can refer to an example below:

class Cars{
    int wheels;
    int seats;
    double price;

    Cars(){. // Constructor 
           this.wheels = 4; // More on "this" keyword later
           this.seats = 2;
        }
}

class SportsCar extends Cars {
    int fuel;

    SportsCar(String fuel){
            this.fuel = fuel;
            }
}

void main(){
    // Creating a object 
    SportsCar ferrari = new SportsCar();
    // Accessing parent class element (Inheritance)
    System.out.println(ferrari.seats);
}

There are various types of inheritance such as Single, Multi-level, Multiple, and Hybrid. We will look into these in detail in future.

Now that you have an understanding of inheritance, let us take a look at the next one.

Polymorphism

If you break the word down, it is poly which stands for "Many" and morphism which means "Ways to represent". Put together it means Many ways to represent a single thing. It is derived from the greek.

Think of polymorphism as the ability of an object to take on multiple forms. For example, consider a shape class with a draw method. The draw method could be implemented differently for each type of shape (e.g., a square, a triangle, a circle). However, because they all have a draw method, they can be treated as objects of the same class.

To better understand with code, here:

public class Shapes {
    void area(){
        System.out.println("This is the area of the shapes");
    }

public class Circle extends Shapes{
    void area(){
        System.out.println("The area of circle is pie * r * r");
    }

void main(){
        Shapes s1 = new Shapes();
        Circle s2 = new Circle();

        s1.area();
        s2.area(); // try them out to better understand

There are two types of polymorphism:

Run-Time/Dynamic Polymorphism which can be achieved by Method overriding.

Compile-Time/Static Polymorphism which can be achieved by Method Overloading.

Polymorphism makes it easier to work with objects that have similar behaviors but different properties, and it helps to make code more flexible and reusable. This is a powerful feature of OOP that allows for greater flexibility and maintainability in code.

Encapsulation

Let us consider a bank account class. The class could have properties such as the account balance and the account holder's name. The class could also have methods such as deposit, withdrawal, and transfer, which allow the user to interact with the account. By using encapsulation, the bank account class protects the account balance from being modified directly, ensuring that all transactions are processed through the deposit, withdraw, and transfer methods.

Think of encapsulation as a protective barrier around an object's data and behaviour. The data is hidden from the outside world and can only be accessed and modified through the methods defined within the object. This helps to ensure that the data remains in a consistent state and is not modified accidentally.

Encapsulation solves a implementation level issue and focuses on internal working.

Encapsulation helps to simplify the complexity of an object and makes it easier to understand and use.

Abstraction

Continuing to draw from the above example, Let us consider a car. The car has many complex systems such as the engine, transmission, and electrical system, but the user does not need to know about the details of these systems to use the car. The user can simply get in the car, turn the key, and drive. The car provides an abstract view of the underlying systems, making it easier to use.

Think of abstraction as a simplified representation of an object, showing only the essential information and behaviour. Another example can be, consider a television remote control. The remote has buttons for power, volume, and channel, but the user does not need to know about the complex electronics and programming that make the remote work. The user can simply press the buttons and the remote takes care of the rest.

To sum it up, Abstraction is a concept that involves hiding the complexities of an object and exposing only the relevant information and behaviour to the outside world. This allows users to interact with the object at a high level, without having to know about the underlying details of the implementation.

Conclusion

In conclusion, the pillars of Object-Oriented Programming (OOP) - inheritance, polymorphism, encapsulation, and abstraction - provide a powerful toolset for organizing and simplifying code. These concepts allow us to create objects that are easy to understand and use while hiding the complexities of the implementation. Whether you are a seasoned programmer or a newcomer to the world of coding, understanding and using these OOP concepts will help you to create more organized, maintainable, and flexible code.

The implementations were not covered to the full extent as the implementation differs from language to language. So, I will make sure to write a blog on implementations in detail soon.

Pro tip: You can read blogs, and watch tutorials all you want but you'll only learn and master OOPs with practice. Go and just try different things with OOPs. The hit and run or trial and error method. That's how you'll learn.

So, What are you waiting for? Go! Get started right away.

I hope the article helped you out in learning about Object-Oriented Programming.

Follow me here for more such technical content. You can catch me on my socials here for content on tech and finance. Would love to connect.

Also make sure to drop down what you would like me to cover next, feel free to reach out for work too. Thank you.