How important are habits?

Just share your honest opinion, that is all I ask. I'm hoping most people would say they are essential and I would completely agree. In case you say they don't, I would love to hear why you think so.

As I was reading the book Atomic Habit by James Clear, I was thinking this is a fantastic book and it can help me become a better software engineer(SE). So here I am trying to share the lessons I learned and how they can be applied to the field of SE specifically.

The book is not written for software engineers specifically. So I thought, why not fill that void?

Please note that I have just covered the first three chapters as I feel like these three chapters are core to this book and teach a lot. However, after reading this article if you feel like I need to write an article on other chapters please let me know in the comments.

Chapter One

Chapter one, titled The Surprising Power of Atomic Habits conveys the importance of tiny improvements over the long term.

For example, let's say you want a well-paying SE job, we all know the biggest hurdle is going to be the leetcode grind, Data Structures and Algorithms(DSA), and technical knowledge in general.

We all look at how people solved tons of questions and build great projects to get such fancy jobs. However, you are stuck at the same job for a while and cannot find time out of your busy schedule.

The easiest solution would be to start at the base level. Solve just one problem per day, work on your project for maybe just 30mins to 60mins per day, and before you know it you will have already solved more than 100 questions and will have a complete project in a matter of months.

In contrast to the above situation, let's say you just watch TV and Netflix because you get very little time outside work and want to just relax. The time will pass and you won't even know it. Days, weeks, months, and even years just pass by.

Over a year, the difference is very significant. 365 leetcode questions vs zero leetcode questions. At least 2 to 3 complete projects vs again zero projects. On top of that if you keep sharing your journey on LinkedIn and Twitter, maybe you will also gain a significant following or at least make meaningful connections.

Now, I'll accept that I haven't solved 365 questions in the past year or completed 2 to 3 side projects. However, even without consistency, I have solved more than 50 leetcode questions, built a portfolio site & hosted it on the internet, completed a course on the basics of data structures & algorithms, wrote a few articles on hashnode, and these are just things I can remember on top of my head. I have been more consistent in 2023 but these numbers are about 2022.

You can read my 2022 dev journey here to learn more about my job situation as well but I hope you get the point.

It's not about what we can do on a given day but it's about what we can do over a period of time to get compounding results.

This chapter was all about a 1% improvement from the previous day. Now let's move on to the next chapter.

Chapter Two

Chapter two, titled How Your Habits Shape Your Identity (and Vice Versa) shares the importance of changing our identity to make it easier to achieve our goals.

If someone asks you, who are you? What do you think will be the answer? I guess most of us will say student if we are in college or school and our job title otherwise.

When we want to achieve something we should change our identity or add a new identity. In case you want to be fit you can view yourself as an athlete and not a normal person who just views going to the gym as a chore.

If you want to be a better software engineer, call yourself a software engineer. You are not an aspiring software engineer, a coder or a programmer. You are a software engineer and now you are more likely to put in the effort needed to improve your technical skills.

Chapter Three

Chapter three, titled How to Build Better Habits in 4 Simple Steps.

Understanding these steps is not rocket science. So let's see what they are

1. Make it obvious

2. Make it attractive

3. Make it easy

4. Make it satisfying

These steps are in general great to build good habits.

As software engineers, our goal is to write better software and get a better well paying job or work on that product you want to launch. Either way, you need better skills and you can only develop those skills with practice.

Let's try to achieve the above goal with the four steps shared in chapter three.

Step one: Let's assume you want better problem-solving skills and want to practice problem-solving every day. To make it more obvious you can always keep one leetcode tab open in your browser. This way whenever you open your laptop you will get a reminder of what you need to do first.

Step two: Now that we have made it obvious, let's make it attractive. We know the reward for our actions will be that dream job. Keeping in mind the reason we are working hard can make it very attractive.

Step three: Our goal is both obvious and attractive. To make it easy, we can always start with easy problems. No matter how little you know about problem-solving if you know basic syntax there will be problems that you can solve.

Step four: Let's make it satisfying as well. To make problem-solving satisfying you can give yourself a little treat every time you solve a problem. Maybe 5 minutes of YouTube or a little bit of chocolate or anything that works for you.

Once we have set up this loop, eventually we will develop a habit of solving problems.

Thank you so much for reading and if you have any feedback please leave it in comments.

Collections in MongoDB

In MongoDB, collections are the equivalent of tables in a relational database. A collection contains a group of related documents, and each document in a collection represents an individual record in the database. For example, you could have a collection for users and another collection for orders. Each collection can contain documents that have different structures, allowing you to store data in a flexible and scalable way.

Databases in MongoDB

Databases in MongoDB are a way to organize collections. A single MongoDB instance can contain multiple databases, and each database can have multiple collections. This allows you to separate data into different databases, making it easier to manage and maintain your data. For example, you could have a database for your development environment and another database for your production environment.

The Document Hierarchy in MongoDB

The document hierarchy in MongoDB is straightforward. At the highest level, you have a MongoDB instance, which can contain multiple databases. Each database can contain multiple collections, and each collection can contain multiple documents.

It is important to understand the document hierarchy in MongoDB because it affects how you store and retrieve data. For example, you may want to store data about users in one collection, and data about orders in another collection.

When working with collections and documents in MongoDB, it is also important to understand the data model and how it affects the way you store and retrieve data. MongoDB uses a document-based data model, which allows you to store data in a flexible and scalable way. This means that you can store different types of data in a single document, and you can easily retrieve data based on specific criteria.

For example, let's say you have a collection of users, and each document in the collection represents a single user. You could store information such as the user's name, email, and address in the document. When you need to retrieve a specific user's information, you can easily do so by querying the collection based on specific criteria, such as the user's email address.

The Benefits of MongoDB's Document Hierarchy

One of the key benefits of MongoDB's document hierarchy is that it allows for more flexibility and scalability when it comes to storing data. Unlike traditional relational databases, MongoDB does not require you to define a schema for your data, which means that you can store data in a more flexible and scalable way.

Another benefit of MongoDB's document hierarchy is that it allows for better performance when it comes to querying data. MongoDB uses indexing to optimize query performance, and you can create indexes on specific fields in a collection to improve query performance. This means that you can quickly and easily retrieve data based on specific criteria, making it ideal for modern web applications that require fast and efficient data retrieval.

Finally, MongoDB's document hierarchy also makes it easier to maintain and manage your data. Since you can store data in a flexible and scalable way, you can easily make changes to your data model as your application evolves. This means that you can easily adapt your data model to meet the changing needs of your application, without having to make major changes to your database structure.

In conclusion, understanding collections, databases, and document hierarchy in MongoDB is crucial for effectively using the database.

JSON vs BSON

In my last article, I mentioned that MongoDB uses BSON data type and not JSON. The BSON stands for Binary JSON and JSON stands for JavaScript Object Notation.

For the most part, JSON and BSON are very similar. While using Mongo shell or accessing it through a node driver we can hardly see the difference between JSON and BSON.

BSON has additional data types and is much more efficient for storing and retrieving data. BSON achieves efficiency due to the fact that it stores type and length data when encoding information.

For a more detailed comparison, you can read the official MongoDB article here.

Data Types

Now let's have a look at a list of some important MongoDB data types.

• ObjectId: This is a unique identifier that is generated for each document in a MongoDB collection. It is a 12-byte value that consists of a 4-byte timestamp, a 3-byte machine ID, a 2-byte process ID, and a 3-byte counter. Objectives are often used as the default value for the "_id" field in a MongoDB document.

• 32-bit integer (int): This data type represents a signed 32-bit integer value. It can store values between -2147483648 and 2147483647.

• 64-bit integer (float): This data type represents a signed 64-bit floating-point value. It can store values with higher precision and range than the 32-bit integer data type.

• Double: This data type represents a double-precision floating-point value. It can store values with higher precision and range than the 64-bit integer data type.

• Decimal128: This data type represents a 128-bit decimal value. It allows you to store numbers with a high degree of precision, making it useful for financial applications.

• String: This data type represents a sequence of Unicode characters. Strings can be of any length and can include any valid Unicode character.

• Object: This data type represents an embedded document in MongoDB. It allows you to store nested data structures within a document.

• Array: This data type represents a list of values. Arrays can contain any valid data type, including other arrays.

• Binary data: This data type represents a sequence of binary data. It can be used to store images, audio, or other types of binary data.

• Boolean: This data type represents a true or false value.

• Date: This data type represents a date and time value. It stores the number of milliseconds since the Unix epoch (January 1, 1970).

• Timestamp: This data type represents a timestamp value, which consists of a timestamp and a counter. It is used to store the creation and modification times for a document.

Note that there are some addition data types offered by MongoDB which you can read in more detail here.

Do let me know if you've any feedback or think something's missing...

Many will make new year's resolutions, few will start them and even fewer people will follow through.

We can't predict the future. However, we can learn from the past and that's what we'll do in this article.

So let's start #DevRetro2022

Start of the year

The start of the year was stressful, to say the least, and this is not the last time I was gonna experience it.

As months went by the job only got tougher. However, we'll talk about them in the next few sections. For now, let's concentrate on the starting few months.

Life never gets easier, you just learn and adapt.

I got my first job offer when I was in college and joined the organization I'm currently working for in June of 2021. June 14th, 2021 to be more precise. Like any beginner, I was excited to learn and leave my mark.

The client I'm currently working for was assigned to me in mid-December 2021, and in the first couple of weeks, I was doing just local setup(installing necessary software) and watching some Knowledge Transfer(KT) videos.

In the last week of December 2021, I got my first task which was to simply add some regex to form input(backend and frontend). I dragged this task to the first or second week of January(I don't remember the exact timeline LOL).

It wasn't because I was dumb or their system was something out of the world. I was just completely new and didn't know how to search for the right field in the huge codebase.

At this point, I was genuinely stressed. I mean who wouldn't be?

I learned two things from this experience

1. With time, you'll solve the problem. (A lesson which I keep relearning now and then)

2. Ask for help if you're stuck for too long.

I never expected a simple regex problem to give me so much stress or teach me such important lessons which now seem very obvious.

After completing this task, I got one more task. It was to write a script to export data from MongoDB into an excel file and share that file over mail in regular time intervals. This task was a little easier because I had the liberty to choose any language so I naturally chose JavaScript(JS) and NodeJS.

I got a few more tasks after this but they were very trivial like changing the text on the front end or changing the content of tables on the front end. For this brief period, I wasn't stressed at all.

My first exciting and challenging task

After spending a few weeks, now it was time to pick up some actual challenging work. I had to build a new module for managing data related to different branches of a bank.

This was probably my favorite task out of all tasks I've completed for my current client. I got to work with some nice frameworks and got to learn something new.

Below is the list of technologies I used

• AngularJS ( Not to be confused with Angular)

• Play framework (Using java language)

• MongoDB for storing data

• ElasticDB for search

I had experience with the MEAN(MongoDB - ExpressJS - Angular - NodeJS) stack and I had studied JS in lockdown before starting my job. I even have a playlist of some videos related to JS on my YouTube channel which you can find here.

However, I had never worked with AnguarJS or Play or Elastic for that matter. By the way, AngularJS is not Angular and I have an article relating to it here. So it was challenging to pick up a new framework on the go.

Play wasn't much hard because at the end of the day I was writing java code and it had a familiar structure. MongoDB wasn't a challenge because it was nothing new and ElasticDB was a bit confusing but I referred to old queries and didn't need to do much.

The biggest challenge was AngularJS. In the beginning, it felt so different from anything I've ever worked with. I gave it some time and after a week or so it started feeling somewhat familiar. I guess that's the advantage of working with vanilla JS and knowing some basics of others frameworks/libraries.

More than anything this experience truly taught me that knowing the basics of a language is crucial to understanding and working with the framework.

First office experience

One day my manager asked me to join a google meet. It was to inform me that I had to go to the client's office. I had to start going to the office from 1st week of May. I was going to my client's client's office(two clients isn't a typo btw). Whenever I say bank just assume it to be the client's client.

Since I was hired during the Pandemic, I didn't have any experience working from the office. However, I had a few expectations like getting to wear anything we want and maybe free food. I didn't get any of that but I did get to meet two of my colleagues for the first time. I had never even seen the face of anyone I've worked with because of the Pandemic.

Now that I was working directly with stakeholders, the work stress was even greater. I was still relatively new with only 3-4 months of experience. I kept missing deadlines but didn't give up. Shoutout to my colleagues who helped me in the initial days.

With time, I learned more about the system. I became better at debugging the code. I started understanding how different microservices related to each other. More importantly, I learned to give more realistic timelines for tasks. I'd say giving proper timelines for tasks is one of the toughest parts of any job.

One valuable lesson here is that even if you're the most tech-savvy person in the room it's important to understand the current system and business requirements.

Knowing how to do something is pretty pointless if you don't know what to do.

I don't think my technical competence was the issue in task delays but rather a combination of a few points listed below

• Not asking for help sooner.

• Sometimes, not trying hard enough.

• Giving unrealistic timelines for my skill level.

I was scrolling through Instagram someday and there was a post saying

Hard times don't last, people do.

I don't remember who posted this or when I read this but I think this is a great quote.

Hybrid work experience

After four months, I was called back to work with the client and not for the bank. When I was going to the bank it was a completely different experience and I had to go to the office every day. The work didn't change much but the workplace did and it did make a difference.

Now I was finally wearing casual clothes at work for the first time. I know for many people it's not that big of a deal but I always wanted to look like a stereotypical programmer just for fun and little comfort.

I had to go to the office just 2 days instead of 5 days a week. The office was even closer than the previous one. All in all, it was definitely better for me personally. The best thing was meeting more people I work with.

Technologies I learned this year...

This was a rather weird year for me personally but I did try some new technologies so let's talk about them.

AngularJS

This is one technology that I had never touched in my life and now I'm fairly confident in writing code for AngularJS. I wouldn't recommend using it and considering how it's outdated for a long time now, I don't think anyone will.

I don't think this specific technology would help me a lot going forward if I ever switch projects but it definitely taught me that I can pick up any JS framework and be productive in it.

More than the technology itself, I think learning about how important basics are was the best thing I got out of AngularJS.

ElasticDB

This is one technology that is very exciting to me.

It does something different than MongoDB and traditional SQL databases (DBs). It has a different use case and it's very good at searching data.

I still have a lot to learn about it and I promise I will.

Maybe I'll even write an article series or make youtube videos about ElasticSearch next year. Depends on a lot of factors but it's definitely a possibility.

Kotlin

Ever since I made a basic android application, I was hearing about Kotlin and how it was now Google's first choice for building native android applications.

I always wanted to try it but because of trying to learn/improve other language skills I never got to it during the pandemic.

I solved a few leetcode questions using Kotlin and really loved the syntax but after that, I didn't use it for a while. However, I recently started a Spring Boot project in Kotlin and have a basic skeleton ready. I have paused that project for now because I want to finish other pending tasks first but I'll 100% complete at least a basic version of it.

It may take some time to get to it but hopefully, I can get to it soon enough.

Blockchain / Web3

The biggest buzzwords of 2022 were Web3 and Blockchain.

I think the above meme sums up the Blockchain situation pretty accurately. I did read some articles about it and got some fundamental understanding but never dived too deep.

I would definitely love to learn about all the technologies related to Web3 but for now, I think I have enough gaps in my Web2 knowledge to chase the trend of Web3.

At the end of the day, the web is web. 2, 3, or 5 are just numbers. If you have good basics and core Computer Science knowledge, that's what matters the most.

Personally, I would've loved to learn more technologies but due to work and my laziness, I definitely learned less than I could've.

Leetcode

I think this article would be incomplete without talking about my leetcode profile.

I have solved 167 questions in total till now(25th Dec 2022)

I have 336 submissions

I know, I could've done much better but a small break turned into a huge one. My leetcode skills need a lot of work and hopefully, when I'll be writing #DevRetro2023 I'll have a much better record to share with you guys.

Even the 167 questions, I have solved wasn't solved on my own. That's one more thing I would love to improve. Do leave any tips you may have specific to my situation, would love to hear from you guys.

However, this is what I have for the year 2022.

My Portfolio Site

I wanted to build a personal portfolio website for so long and I finally did. I started and completed it in the April of 2022.

You can visit the site here and I promise it's beautiful.

I didn't have time to build it out completely on my own and make it mobile-responsive so I took the help of a YouTube video. Here's the link for that video.

Just yesterday(24th Nov 2022) I bought a new domain for the first in my life so it was exciting. Before that my portfolio was hosted on the netlifys subdomain and my blog was hosted on the hashnodes subdomain.

It was a little confusing to figure out how to use the domain I bought but in the end, I figured it out. It was both fun and exciting.

URL for my portfolio - https://www.jayeshkarli.dev/
URL for my blog - https://blog.jayeshkarli.dev/

Now both are hosted on my personal domain which feels pretty good, to be honest.

ChatGPT

Just as this year was about to end we got ChatGPT. The AI program was developed to take over the jobs of developers around the world or may be a glorified search engine for some people.

I would love to learn more about your opinion in the comments.

I panicked a little but for now, I don't think it's any threat to my job. By the time, it takes our jobs I think there'll be some alternatives or maybe Universal Basic Income(UBI).

I'm quite curious about how fast it'll progress and how it will change our society but I guess only time will answer that question.

For now, all we can do is upskill ourselves and hope for the best.

The Ending

Now that the year has almost ended, I have mixed feelings about 2023. However, I'll just focus on the positive ones for now and go into the future with hope and optimism.

Happy new year and Merry Christmas to all my friends reading this blog. I hope you enjoy your holidays to the fullest and come back with fresh energy to fight the demons of 2023.

Thank you for reading the blog, if you could relate to any point in my Dev Retro 2022 please do share your experience in the comments.

Why?

I believe one of the biggest reasons is definitely the thought of being left behind.

While it is true that we need to stay up to date with latest trends, that doesn't mean we have to change our field of expertise every year.

Also, whenever there's a new technology we know there aren't many "experts" in that field so maybe there's also some greed.

Being first in something which is probably going to be an influential technology might mean a lot of money. However, we should remember that sticking to one area of expertise like frontend or backend isn't the worst thing to do, especially in long term.

At the end of the day I think it's just important to remember that if you're good at your job and give yourself time to settle in, you'll get paid regardless of whether you're working on web3 app or php project.

How?

We all like to think that we're smart enough to not chase the "NEXT BIG THING" but regardless we end up getting pulled in.

It all starts and ends with social media hype. Recently, it was web3 and before that it was Machine Learning (ML), Artificial Intelligence (AI) and evergreen JavaScript (JS). While all of these are amazing technologies and I recommend having at least basic understanding of them, I don't think you should abandon whatever you're doing and start pursuing a career in them.

Of course, there are exceptions to what I just said and some people may not like the area they're working in and in such cases if you find your interest in ML, AI, Web3 or anything else that's awesome.

Social media is great for learning about latest trends. However, it may not be the best tool for making career choices.

I think at the end of the day it's just about knowing basics of computer science, everything else will keep evolving and changing.

Let's start with why

Here are just a few reasons why I think it's worth our time to learn more about this exciting technology :

• It's in demand and as far as I can tell it'll remain in demand for quite a while, so it's a safe bet.

• If you've worked with JSON data, you'll be able to learn about MongoDB documents in no time.

• MongoDB is very popular with NodeJS and ReactJS/Angular/Vue(ton of front-end frameworks/libraries) for building full-stack applications.

• Horizontally Scalable .i.e adding more machines. This is in contrast to Vertical Scaling where we add more resources(CPU, RAM, etc) which is not always feasible.

• Flexibility. In MongoDB, we don't need to have a strict and fixed schema from the start, we can always add new fields as our needs evolve.

• Most of the data types in MongoDB map very easily to data types available in most languages.

I strongly believe in knowing why you're learning something before starting it.

Now that we know why, let's explore how.

How to learn MongoDB

Considering how this is going to be a tutorial series on MongoDB this section might seem a little strange. However, there's a good reason behind this short section.

No one article or video can teach you everything.

Below are some of my recommendations on how to truly learn and understand not just MongoDB but any technology in general :

• Nothing in this world is perfect so there's no harm in trying different articles, books, and videos.

• Always use official documentation if you want to dig deeper.

• Don't expect to learn and understand everything overnight.

• Be consistent.

What is MongoDB?

If you google "What is MongoDB?" you'll find many articles with good answers and they all will have some common words used like NoSQL database, document-oriented, open source, cross-platform, optional schema/schemaless, etc.

Let's have a look at those and understand what they mean

• NoSQL Database and Optional schema / Schemaless means that, unlike SQL databases, we don't have to follow a specific schema/structure for documents that we're going to store.

• Document-oriented means that we don't store data in terms of tables and rows. We store data in Binary JavaScript Object Notation(BSON) format. We will discuss all the supported data types in the coming articles.

/* Below is an example of a document stored in MongoDB collection */

{
  platform: "hashnode",
  name: "JayeshKarli",
  action: [
    "Read-Articles",
    "Follow"
  ]
}

• Open-source simply means that the source code for MongoDB is publically accessible. If interested you can click here to explore the MongoDB GitHub repo.

• MongoDB is cross-platform which allows us to use it on multiple platforms.

I hope this article helps you to get started with MongoDB. Drop a reaction if you like the article and if you don't tell me why in the comments, I love positive criticism.

Follow me for more such articles.

I can clearly see that it asks the specific type of problems continuously and then changes its type.

It starts the month easily and then ramps up the difficulty, especially at the month's end. (Kudos to anyone who solves all problems)

I enjoy solving daily challenges because they aren't overwhelming and they are relatively small, which in turn makes them more achievable.

However, when done consistently over time, the questions add up, and before you know you've solved more questions than you imagined.

Even if we solve just one question per day, over a year it becomes 365 questions.

Some of them will be easy, most will be medium, and some will be hard, but trust me when I say you'll learn a lot.

If this post helps/motivates you to start leetcode daily challenges, please do consider following Jayesh Karli.

Consider sharing this post with your network.

public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();

        int len = nums.length;

        for(int n = 0; n < Math.pow(2, len); n++) {
            List<Integer> curList = new ArrayList<>();
            for(int i = 0; i < len; i++) {
                if( (n & (1 << i)) != 0 )
                    curList.add(nums[i]);
            }
            res.add(curList);
        }

        return res;
    }

Recursion

public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();

        f(res, 0, new ArrayList<>(), nums);

        return res;

    }

    private void f(List<List<Integer>> res, int ind, List<Integer> arr, int[] nums) {
        if(nums.length == ind) {
            res.add(new ArrayList<>(arr));
            System.out.println(arr);
            return;
        }

        arr.add(nums[ind]);
        f(res, ind+1, arr, nums);
        arr.remove(arr.size() - 1);
        f(res, ind+1, arr, nums);

    }

It's been almost a year(11 months to be precise) since I joined my first job. However, I got my first client in December and learned some very important lessons which I think every aspiring developer/student should know.

So if you're trying to land a developer job or if you're just starting one, I'm sure this article will help you.

1. You'll eventually find the solution.

I know we shouldn't give up and keep trying to solve a problem but sometimes it just becomes too hard. Oftentimes we just give up when it becomes too hard but when you're in a job that's not an option.

These are the times when you've to ask for help, you've to make the best use of google and you've to just keep trying. Most of the time the answer is just in front of our eyes.

Just don't give up & you'll find a solution.

2. Ask for help.

Now I know this sounds simple and it is. However, it's not always the easiest thing to do especially if you're shy or introverted(or maybe both).

Personally, I was terrified of asking for help at the beginning mostly because of imposter syndrome (it's a whole topic on its own).

I think apart from being shy and/or introverted this is the issue with most developers and the only solution is to take a deep breath and send that message asking for help. Trust me you'll thank me and the person who helps you.

Most of the time senior developers don't reply because they're genuinely busy and they know if you just give some time to your problem you'll find a solution. So, I don't see not getting a quick reply as something negative.

One more very important piece of advice when asking questions is to try everything you can possibly do. On top of that when you ask questions make them as elaborate as possible without any fluff.

Sometimes your problem can be solved with a single message.

3. The easiest solution is the right one.

Now, don't go out there implementing the most inefficient solutions just because they're easy. However, you don't always need the most efficient solution either.

As a developer, we all have at least a basic understanding of time and space complexity(if you don't I'd highly recommend learning some basics).

One thing many developers ignore is the time it takes to develop the solution and code readability for other developers.

This is why I believe in implementing the easiest possible solution which is easy to understand(readability) and doesn't take up all our time.

Now there are obviously exceptions to this rule like maybe some software used in hospitals can't be rushed. Even in such cases, code readability is still equally (I'd argue more) important.

Simplicity is the solution to all problems.

I hope this post helps someone and I'd love to listen to others' opinions on this topic as well.

BST Properties

• The left sub-tree will always have values less than the root.
• The right sub-tree will always have values greater than the root.

Iterative approach

The first step is just checking if the root node is null or if its value is equal to val. If that's the case we just return our root node because it satisfies our condition.

After that, we jump into our while loop and do the following

1. Check for the same base condition in every iteration.
2. If the current node's value is greater than val we move to the left subtree.
3. If the current node's value is lesser than val we move to the right subtree.

After we're out of the loop our node's value is either null or equal to val. So we simply return that node.

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {

        if(root == null || root.val == val) return root;

        while(root != null && root.val != val) {

            root = root.val > val ? root.left : root.right;

        }

        return root;
    }
}

Recursive approach

We are performing the following three operations for a recursive solution -

1. Return the current node if its value is equal to val or null.
2. If val is greater than the value of the current node we go to the right subtree.
3. If val is lesser than the value of the current node we go to the left subtree.

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {

        if(root == null || root.val == val) return root;

        if(val > root.val)
            return searchBST(root.right, val);
        else 
            return searchBST(root.left, val);
    }
}

Thank you for reading and if you've any doubts/suggestions please do share them in the comments.

Link to the problem on leetcode.

I've also discussed time & space complexity following the code solution.

1. Code Solution in Java -

class Solution {
    public int calPoints(String[] ops) {

        List<Integer> scores = new ArrayList<>();

        for(String el: ops) {

            final int lastIndex = scores.size() - 1;
            int result;

            switch(el) {
                case "+":
                    result = scores.get(scores.size() - 1) + scores.get(scores.size() - 2);
                    scores.add(result);
                    break;
                case "D":
                    result = scores.get(lastIndex) * 2;
                    scores.add(result);
                    break;
                case "C":
                    scores.remove(lastIndex);
                    break;
                default:
                    scores.add(Integer.parseInt(el));
                    break;
            }
        }

        int res = 0;
        for(int el: scores) { res += el; }
        return res;
    }

}

2. Time Complexity -

Time Complexity is O(n), where n = size of ops.

O(n) is the result of looping through the ops array exactly once. All other operations inside are constant-time operations.

The remove method for case "C" could be O(n) in time complexity. However, it's just O(1) because we're removing the last element from the list. We don't need to change the list after removing the last item.

3. Space Complexity -

Space Complexity is O(n), where n ~ size of ops.

Since case "C" just invalidates the previous score without adding anything, it reduces the space taken by our List storing all the scores.

Therefore, n is approximately equal to the size of ops but not always the same.

First solution with bucket sort and time complexity O(n)

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        if(nums.length == 1)
            return nums;

        /**
        *
        * We are using HashMap to store the frequency of numbers 
        * We'll use it in the next steps
        */
        HashMap<Integer, Integer> numsMap = new HashMap<>();
        for(int el: nums) {
            numsMap.put(el, numsMap.getOrDefault(el, 0) + 1);
        }

        /**
        *
        * We create an array of List<Integer> for storing all elements with a certain frequency
        * 
        *
        * If we have more than one element with frequency 2, we'll store those elements
        * at index 2 in our List at that index in buckets array. 
        * We'll repeat the same process for all the possible frequencies, if there are no numbers with a certain 
        * frequency it's List will just point to null
        *
        * NOTE - 
        * The reason for creating an array with a length greater than nums.length is because
        * indexing starts from zero but we want to store elements with indexes starting from one and going till
        * nums. length, that's why we need the size to be greater by one unit.
        *
        */
        List<Integer>[] buckets = new ArrayList[nums.length + 1];
        for(int el: numsMap.keySet()) {
            int freq = numsMap.get(el);
            if(buckets[freq] == null)
                buckets[freq] = new ArrayList<Integer>();
            buckets[freq].add(el);
        }

        /**
        *
        * We're looping through our buckets array in reverse to get all the elements
        * with highest frequencies first.
        *
        * Whenever our list for a certain frequency is null we'll just skip it.
        * However, if we do find a list with values, we'll add those values to result array
        * and increment our index till we exhaust the list of till the index is equal to k
        * 
        */
        int[] result = new int[k];
        int index = 0;

        for(int freq = buckets.length - 1; freq > 0; freq--) {
            if(buckets[freq] == null)
                continue;
            for(int el: buckets[freq]) {
                result[index++] = el;
                if(index == k)
                    return result;
            }

        }

        return result;
    }
}

Second solution using Priority Queue, we follow a similar approach by creating a hashmap with elements and their frequencies. After that, we store our elements in a priority queue with the highest frequency elements having the highest priority. Finally, we just assign top k values to our result array and return the result array.

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        if(nums.length == 1)
            return nums;


        HashMap<Integer, Integer> numsMap = new HashMap<>();

        for(int el: nums) {
            if(numsMap.containsKey(el)) {
                int count = numsMap.get(el);
                count++;
                numsMap.put(el, count);
                continue;
            }
            numsMap.put(el, 1);
        }

        PriorityQueue<Integer> pq = new PriorityQueue<>((a,b)->numsMap.get(b) - numsMap.get(a));
        pq.addAll(numsMap.keySet());

        int[] result = new int[k];
        for(int i=0; i<k; i++) {
            result[i] = pq.remove();
        }

        return result;
    }
}

If someone finds any mistake or any opportunity for improvement please do share in the comments, thank you.

What is AngularJS?

AngularJS is a javascript framework like React, Vue, and Angular. It is an open-source front-end framework supported by google and many open-source contributors. According to Wikipedia it was released on October 20, 2010. AngularJS is the oldest of the javascript frameworks that can be used to build Single Page Applications (SPAs), it was Angular version 1.

What is Angular?

After the release of Angular version one, the team of AngularJS released Angular version two which was a complete rewrite of version one. Angular is a typescript-based open-source front-end framework used to develop amazing SPAs. It was first released on 14 September 2016. (Source - Wikipedia) )

My frustrations

We all know how useful StackOverflow is, it's without a doubt super crucial for solving our doubts. However, I saw a tweet by StackOverflow

Which web framework gives you the chills? pic.twitter.com/PjezZZFEN0

— Stack Overflow (@StackOverflow) May 19, 2021

It says "Angular.js is the most dreaded framework(and it is)" but there's one point that no one clarifies, angular.js is not angular.

Now, you may think it's not that big of a deal but think from a beginner's perspective they don't know that Angular2 and above are completely different from AngularJS.

When I started learning Angular, these were the thoughts I had in my mind

• Isn't ReactJS the most popular framework/library?
• People say angular is too tough and it's not worth it, maybe I should drop it.
• People hate angular so much it must be terrible.

All of these thoughts just because some people on social media were hating Angular without even knowing(or at least without telling others) that AngularJS is not Angular.

How ReactJS developers behave

I can open literally any social media platform and I will find new ReactJS developers who think the tool is greater than skills and React is the god of everything. I have tried ReactJS and I find its JSX syntax a little weird. Apart from the syntax, I think ReactJS is a great JavaScript library for building amazing web applications. It's a great tool but it does not mean it's the best tool, because there is no best tool.

Now if someone is searching for a job in most places ReactJS has the most jobs so no one can compete with React there. However, knowing or trying other frameworks never hurts and jobs for other frameworks are definitely not zero.

Angular is the biggest victim of React's popularity, I have seen so many people writing negative comments about Angular without even trying it because they "like" ReactJS.Now, there's nothing wrong with liking a framework or library but the problem is we shouldn't try to scare away new developers from trying out other technologies.

Good things about Angular or Angular Version 2+

At the time of writing this article, Angular 12 is the latest version of Angular. It updates every six months but still, the core concepts haven't changed from version 2.

We work simply with HTML, CSS or SASS or SCSS or LESS, and TypeScript(all valid JavaScript is valid TypeScript).

Angular is known to be the toughest framework to learn but I respectfully disagree, it's an amazing framework. It literally took me just 4-5hrs to understand the basics of Angular(same as React in my case). Mastering angular may take months or more but it's the same story for any framework you pick. Starting is easy, mastering is not.

One of the best features in Angular is how we can directly write sass code instead of CSS and Angular handles everything from thereon.

Now I can't cover all good things here, angular docs is the best place to learn more about it.

Angular is an amazing framework, it really is. Just try it.

Just one tip, don't dive into JavaScript frameworks without having a solid JavaScript base.

If you're new to web development you can also check out my YouTube channel, I have a playlist on web development give it a shot.

Thank you for reading.