Forem: Jake Espinosa

Employability and Education

Jake Espinosa — Thu, 22 Feb 2024 07:00:00 +0000

Today's job market is quite competitive, and you must separate yourself from the pack by any means necessary. Education has a high return on investment and a range of opportunity costs associated with it, but paying particular attention to this attribute of employment is highly worthwhile. This article will discuss university, boot camps, and online courses.

University

Undoubtedly, attending university is the best way to boost your education attribute. A computer science bachelor's degree (BS in CS) is the best educational investment you can make. A master's degree is a close second, and software engineering degrees are a close third.

A BS in CS will teach you the foundations of computing and set you up to learn anything else you need on the job. The goal is to gain a foundational understanding of CS, broaden your horizons, and learn to work with others. Some may argue that university is a waste of time and money because it doesn't make you job-ready. However, you must keep in mind that the goal of a degree is not to make you job-ready. The goal is to give you a solid foundation in computing upon which to build.

Concerning boosting your employability, a degree will always give you a leg up over those who don't have one. In lean times, employers will likely discard resumes without degrees. As someone who has conducted hiring panels, a degree is an easy filter to reduce hundreds of resumes into forty. All things equal, employers will choose an applicant with a degree over one without. So, your best bet is getting a degree, ideally a BS in CS. I recommend the CS program at Western Governors University for a cheap but quality education.

Boot Camps

In today's market, boot camps are not worth it. They are typically expensive, with some being more than the cost of a degree from Western Governors University. They teach you things you can easily learn independently for much less money.

However, boot camps are not all bad. They provide motivation for some and offer a decent network that may help you find jobs. Despite this, I would skip boot camps unless I can avoid paying for them.

Online Courses

Online courses are a great way to pick up new skills and technologies. They usually include code-alongs, which are suitable for building muscle memory and seeing how someone else solves a problem. Online courses are typically cheap or free through your local library, so the barrier to entry is the lowest out of the three education options.

If you have nothing else for education, I recommend putting an online course on your resume. This beats having nothing, but there are better resume builders.

Cost

Education is both more accessible and more cost-prohibitive than ever before, depending on which route you take. I always advocate investing in yourself and obtaining an education is one way to do that. However, you must balance fiscal concerns with the desire to improve. Generally, I would only recommend going into debt for education if you are reasonably sure you can pay it off with the opportunities afforded by the education.

In today's market, a cheap but quality university like Western Governors University is the best return on investment. This is not financial advice, but I would not be opposed to someone in my family going into a minor amount of student debt to get a degree in CS from here because they will be able to pay it off within a few years of working, if not sooner. Boot camps may be worthwhile if you can attend for cheap, but please avoid going into debt for one.

Takeaway

It's no secret that more education is better than less. Ideally, you would get a BS in CS and round out your applicable, technology-specific skills with online courses. This provides the best outcome and return on investment for both time and money spent. However, some education is better than none, and I'd encourage you always to be learning!

ARIA Landmark Roles: Why You Need To Use Them

Jake Espinosa — Thu, 08 Feb 2024 07:00:00 +0000

When sighted people view a webpage, they can usually discern the structure at a glance. The header, main content area, footer, sidebar, etc stand out. However, the visually impaired don't have the same luxury. To even the playing field and make the web more accessible for all, we must use ARIA landmark labels in our HTML markup.

What Are Landmarks and Landmark Roles?

Landmarks are discrete components of webpages that form the overall structure, with headers, navbars, and footers as some examples. As mentioned, sighted users can typically identify these landmarks quickly, while visually impaired users cannot. To fix this, the HTML spec introduced ARIA landmark roles.

Landmark roles are implicit and explicit labels (not ARIA labels, though) for screen readers to understand the page structure. Elements such as <header> and <main> have implicit landmark roles, and elements such as <div> do not and require explicitly adding landmark roles. These landmark roles enable screen readers to present a website's general map to users and allow skip links.

However, not every div or non-semantic element needs a landmark role. It does not require a landmark role if you use a div for styling purposes and not as a button, navbar, or something else a sighted person could see. Be careful not to over-apply landmark roles and diminish their value to the user.

Landmark roles are so easy to use that there is no excuse not to. Add a role="<someRole>" attribute into your markup to increase accessibility and the user experience for your visually-impaired users.

Best Practices

Use when you are using a non-semantic element like a div for page structure and not styling
Asses your markup with an accessibility scanner like Lighthouse (built into ChromeDevTools)
Use standard names for landmark roles

Takeaway

As web developers, we must constantly strive to improve accessibility in any way we can. Use ARIA landmark roles to improve the accessibility and navigability of your website. Some semantic HTML elements have landmark roles built in, and some must have ARIA landmark roles explicitly added as attributes. By adding these roles, you will increase your website's accessibility and do your part to make the web more accessible to all.

pip-audit: Managing pip Vulnerabilities

Jake Espinosa — Thu, 25 Jan 2024 14:40:45 +0000

When the standard library doesn't cut it, developers turn to third-party packages to extend functionality. While the Python community uses fewer than the JavaScript community, most large Python projects use several third-party packages. Managing these packages can be a pain, and staying up to date with the latest security patches is even more challenging. Luckily, the open-source community has come to the rescue yet again with a tool to do this for us.

Supply Chain Security

Before I cover pip-audit, I need to discuss supply chain security. Typically, the phrase "supply chain" is associated with global manufacturing companies that use materials from all over the world. Due to this, it is all too easy for a malicious actor to compromise one of the many components in the supply chain. This concept can be applied to software development as we typically use several packages created by various different developers. The packages we rely on can be poorly written, vulnerable to an unknown zero-day, or intentionally compromised (not unheard of with npm packages). While we can't remediate all vulnerabilities, we can apply best practices to mitigate the risk of compromise.

Using pip-audit

Like all pip packages, you should install pip-audit into a virtual environment. In pipenv, you do this by running pipenv shell to activate the virtual environment and then pipenv install --dev pip-audit. We use the --dev flag to specify that pip-audit is a development dependency and not part of the application. A notable limitation as of the time of writing is that pip-audit cannot audit Pipfiles or Pipfile.lock files. However, it can audit installed packages, and pipenv supports converting Pipfiles and Pipfile.lock files into requirements.txt files.

Then, we develop as usual, installing all the packages. Ideally, you would know what packages you need, install them, and run pipenv run pip-audit to audit the packages before development begins. Auditing is a best practice because it reduces the chances of developing your application with a vulnerable package Before packaging up/deploying your app, you should audit the packages again to ensure they aren't vulnerable. Again, this does not guarantee that the packages are secure, but it does reduce the chances of one slipping through the cracks.

Takeaway

Security is everyone's job, and Python developers are no exception. pip-audit is a tool that all Python developers should use to audit installed packages and be aware of their application's security posture. Using this tool, we do our due diligence and make the world more secure, one application at a time.

Filter on the Back End to Improve UI Performance

Jake Espinosa — Sun, 17 Dec 2023 20:05:29 +0000

Users want a fast and responsive experience and may leave if the webpage is slow. There are many ways to improve the user experience, but an easy win is to filter data on the business logic layer or data layer rather than the front end.

Why?

Typically, we want the front end to do the least amount of work necessary. Each action the front end takes adds latency and detracts from the user experience. Some things like API calls are unavoidable, but the API should return data in a ready-to-display format so the front end only has to display the information. The front end should not filter the data when the business logic layer or data layer can. Ideally, the data layer should have a SQL view or function that the business logic layer can query. The business logic layer can also filter the data, but this is less performant than having the database do the filtering.

Separation of Concerns

A big part of good software development is the separation of concerns or partitioning an application into sections with logical responsibilities. This type of architecture is called an "N-tier" architecture, with N representing the application's number of layers. A typical 3-tier application is split into the front end, business logic, and data layers.

The front end should be responsible for fetching and displaying data. The business logic layer should be responsible for data processing, such as creating accounts, confirming purchases, etc. The data layer should be responsible for storing and filtering data. Each layer should be independent of the others' responsibilities, but the realities of development usually prevent this ideal from being achieved.

Takeaway

Enforce separation of concerns to improve your front end performance. Have the data layer or business logic layer handle data processing (including filtering) and let the front end handle displaying data. This will improve front end performance and make users happier.

JIT Learning: The Method To Learn It All

Jake Espinosa — Thu, 30 Nov 2023 07:00:00 +0000

We all know the technology landscape is rapidly changing. There's too much for any one person to learn everything. And we all know if you aren't learning, you're regressing. But how do we know what to learn and when to learn it? Enter Just-in-Time learning!

What Is Just-in-Time Learning?

JIT learning is the process of learning things when you need them. Instead of trying to predict what you will need to know, you learn what you need to move forward. JIT learning benefits you by reducing wasted time if you guess incorrectly and ensures you only learn things that will bring value, whether in your personal projects or professional work.

How Should You Implement JIT Learning?

The ideal situation is one where you know the basics of everything and use JIT learning to dive deeply into what will bring the most value. For example, if you are working with databases, you should learn the benefits, tradeoffs, and situations to use NoSQL vs relational databases. Then, if your job decides to adopt MongoDB, dive deep into NoSQL theory and MongoDB. This makes you knowledgeable enough to contribute to discussions without investing too much time into things that won't immediately provide value.

Another example is the age-old question of which UI library to learn. You should learn the basic information (again, the benefits, tradeoffs, and ideal situations) about React, Vue, and Angular and then choose one to dive deep into once you have a need.

Takeaway

Time is our most valuable asset. We need to maximize our available time, and JIT learning provides a way to do that. By being familiar with all technologies in a particular area and deep diving as needed, you will maximize your time and learn things to provide the most value to yourself or your organization.

Nine Attributes to Consider When Job Hunting

Jake Espinosa — Thu, 16 Nov 2023 14:49:26 +0000

If you ask ten people about freedom, you will get ten different answers. I'd answer choosing based on desire and curiosity instead of necessity. In today's age, you can achieve my definition of freedom by being highly employable.

Being employable boils down to a few core attributes, whether you are a seasoned engineer, a fresher, or someone making a significant career shift. These attributes populate two categories: technical and interpersonal. Technical attributes are things like knowledge, technical ability, and projects. Interpersonal attributes involve human interaction like communication, networking, self-presentation, etc. In this article, I will introduce nine attributes to consider when working on professional goals and upskilling.

Technical

Technical skills are more straightforward to boost than interpersonal skills. The abundance of free training, courses, books, etc., has made learning and demonstrating technical skills easier than ever. As a result, the competition has dramatically increased. You can differentiate yourself by developing many skills and boosting the following attributes.

Education

This is perhaps the most challenging technical attribute to boost as it usually has the highest time commitment and opportunity cost. Regardless, I always recommend getting at least a bachelor's degree without going into a sizeable amount of debt, if possible. Some companies don't require degrees, but they can only help and will give you an edge over someone without a degree, all things being equal. Ideally, you should get a BS in Computer Science.

Technical Ability

Technical ability includes things like OOP, linking a back end to a database, or anything else that is technical. You can boost this attribute by doing things at work or projects and learning new things in your own time. Being able to do many things decently but a few things well is ideal.

Experience

This is your professional work experience that you would put on your resume. It's another hard attribute to boost as you need work experience. However, you can ask to take on more responsibility at work or spin (not lie) your experience to highlight more desirable skills and responsibilities. Again, don't lie; examine your day-to-day duties and extract the most valuable.

Portfolio

Projects serve two primary purposes: they allow you to apply the skills you are learning, and they let you put keywords on your resume. You should post your source code on GitHub with a nice readme and either link to the live project or have screenshots and a video of the project running. How you display the project will depend on what it is. Generic projects like a to-do list are excellent for learning and certainly better than nothing, but ideally, you have 2-3 unique projects that incorporate multiple skills and technologies.

Resume Quality

Hiring personnel spend less than 10 seconds glancing over your resume before they decide to trash or move it along. You need to use a suitable template and have pertinent information easily digestible. In a later article, I will go more into depth on crafting a great resume.

Interpersonal

The old adage, "I can teach anyone the job, but I can't teach anyone how to be pleasant," shows how important being friendly and easy to work with is. Fortunately, you can develop these skills through practice and interaction with others.

Communication

Whether verbal, non-verbal (body language), or written, communication plays the most significant role in how we interact with others. Your ability to express ideas and pass information to others is paramount to personal and professional success.

Interview Ability

Your ability to sell yourself is vital to passing interviews and achieving your career aspirations. Interviews typically consist of technical and behavioral rounds, so you should prepare for both with LeetCode and speaking practice. I will go into much more detail here in a later article, but remember that interviewing is a skill and thus can be honed.

Social Network

An online presence can dramatically expand your reach and opportunities. You should have some online presence, whether it's a blog, a YouTube channel, or a Twitter account. Being known in your field as an authority and reliable source of information is a massive advantage in the job market.

Too often, we are concerned with consuming content and must remember to give back and create. Simple discussions, tutorials, or opinion pieces are all great ideas for content. Be careful, however, as being too opinionated can alienate others. Always remember to be professional and kind.

Self Presentation

Unfortunately, humans make split-second decisions based on physical appearance. Fortunately, you don't need to be a model to improve this attribute (although the halo effect is real). Being clean, groomed, and well-dressed should prevent your appearance from working against you.

Takeaway

Getting a job isn't a luck-based endeavor. There are tangible skills you can develop to give yourself the best chance of success. By keeping your technical and interpersonal skills up to snuff, you can make more informed and riskier career moves with less fear. Hopefully, you will consider and develop these skills to improve your career and life.

Automate Your Dev Setup With Ansible

Jake Espinosa — Thu, 09 Nov 2023 03:33:54 +0000

After weeks of research, you finally unbox your new computer and start setting it up. It boots, you install your OS, and then the magic happens! Except, it doesn't. You still need to install all of your software. As fast as your new SSD, your excitement is replaced with dread...

This article will not teach you how to use Ansible or write playbooks. Rather, I aim to inspire you to automate your environment setup and think about other ways to increase productivity and decrease brain cycles spent on insignificant things.

What Is Ansible?

Ansible is an open-source tool for configuration management commonly used in cloud environments. It uses yaml to specify the desired end state of a system declaratively.

The Problem Ansible Solves

If you're like me, you program in multiple languages and thus need numerous environments. You also need the environments to be consistent across machines. Manually installing everything can be an error-prone slog and cuts into precious time you could use for anything else. Instead, consider writing an Ansible playbook to do it for you.

Playbook Ideas

Install and configure node/npm
Install python
Configure git with your username, email, and SSH keys
Clone your personal project repos from Github

Takeaway

Consider spending a few hours now to save countless hours on installing and configuring software. Automating your environment with Ansible isn't something flashy and exciting, but it will free up precious time and allow you to focus on the code.

Should You Learn Vue, React, or Angular?

Jake Espinosa — Thu, 02 Nov 2023 18:55:17 +0000

This question puzzles many beginner front end engineers, but the answer is simpler than you think! In this quick article, we will discuss and give you actionable advice. First, let's start with a quick review of the differences between the three:

React

Developed by Facebook, React is the least opinionated of the three. It grants the most flexibility and, as a result, the most footguns. Many organizations use it, so jobs are plentiful. It has rich tooling and broad community support due to its overwhelming popularity.

Angular

Angular is the oldest kid on the block. Coming from Google, it is also the most opinionated of the three. Like React, its tooling is mature and community vast.

Vue

Vue is the middle road. It is more opinionated than React but less than Angular. It sits somewhere between React and Angular in terms of popularity (at least in my market). Personally, Vue is my favorite, and I write most of my project's front ends in Vue.

Which One?

The answer is simple: it doesn't matter. The concepts and core UI skills you'll develop overlap. Pick whichever is more prevalent in your local market. A component is the same in all three, as is reactivity, user flow, etc. We should strive to be engineers who can pick up any framework in a week or two. As such, it will behoove you to master fundamental HTML and CSS before moving on to a UI library.

Takeaway

Pick the one that is most common in your local market. The skills you'll develop will spill over into the other two.

Design Patterns: Simple Factory

Jake Espinosa — Tue, 31 Oct 2023 21:00:03 +0000

Anyone who has taken an object-oriented course likely has used this pattern (I learned it in the Java course on Code With Mosh). Regardless, it is a valuable pattern that should be in your toolkit when working with object-oriented code. I will be using Java to demonstrate this design pattern in action.

What Is It?

A simple factory is an object that instantiates other objects. Simple factories do this by calling a static method that calls the constructor of the resultant object. Simple factories instantiate one or more types of objects.

In this article, we will be implementing a pencil factory. We can pass arguments such as type and lead thickness to create pencils with the specified properties. We don't have to worry about the implementation details; we pass arguments to the factory, which returns a pencil.

Some may say that the simple factory pattern is not a design pattern but a stepping stone to the abstract factory or factory method design patterns. However, I disagree, as the simple factory pattern is a flexible and reusable unit of code. Regardless of which side of the fence you are on, the simple factory is an excellent addition to your engineering toolkit.

Why Use It?

Often, creating objects is more complicated than a simple constructor call with no arguments. You may want to create multiple instances of the same class with different constructor arguments. Or, you may want to use logic to determine the type of object to create. A simple factory allows you to encapsulate this creation logic and only worry about passing the correct arguments. You call the simple factory's creation method, pass it the correct arguments, and it returns the proper object.

Code Explanation

The code in this article can be found here.
In this example, we will
There are a few steps to implementing the simple factory design pattern:

Create an interface
Implement a class (or classes) against the interface
Create a factory class
Use the factory

Create an Interface

First, we create an interface for pencil classes to implement. This interface can implement wooden pencils, mechanical pencils, etc.

public interface Pencil {  
    public String getType();  
    public float getLeadThickness();  
}

Implement the Interface

Next, we create a class that implements the interface.

public class MechanicalPencil implements Pencil {  
    private String type;  
    private float leadThickness;  

    public MechanicalPencil(String type, float leadThickness) {  
        this.type = type;  
        this.leadThickness = leadThickness;  
    }  

    public String getType() {  
        return this.type;  
    }  

    public float getLeadThickness() {  
        return this.leadThickness;  
    }  

}

Create a Factory

Next, we create a factory class that will instantiate objects.

public class PencilFactory {  
    public static Pencil makePencil(String type, float leadThickness) {  
        return new MechanicalPencil(type, leadThickness);  
    }  
}

Use the Factory

Last, we use the factory to instantiate objects.

public class App {  
    public static void main(String[] args) {  
        Pencil mechanicalPencil = PencilFactory.makePencil("mechanical", 0.9f);  
        System.out.println(mechanicalPencil.getLeadThickness());  
        System.out.println(mechanicalPencil.getType());  
    }  
}

Takeaway

Design patterns are helpful solutions to common software engineering problems. The simple factory pattern is useful for encapsulating object creation logic. Design patterns shouldn't be a hammer looking for a nail, but when appropriate, they dramatically increase the reusability and flexibility of object-oriented software.

Don't Buy Another Course, Just Write Code

Jake Espinosa — Sat, 28 Oct 2023 19:21:22 +0000

Tutorial Hell: the vicious cycle of starting but never finishing tutorials that results in very little learning.

We've all been in tutorial hell at one point or another. Most aspiring developers never make it past this time sink. Fortunately, you can escape tutorial hell and develop marketable skills by simply writing code.

The Problem with Buying Courses

Collecting Courses and Doing Courses are Two Different Hobbies

I recently got back into reading and quickly learned that buying books and reading books are two separate hobbies. The same is true with buying courses. I love buying courses and am constantly curating my backlog of things to learn. It's a rush to buy the perfect course and daydream about going through it. However, especially with newer programmers, this is harmful to your growth. All too often, newer programmers start a course, run into a tricky section, and then drop the courfse entirely and move on to the next fun thing. The result is you never make progress and waste time.

False Sense of Progress

If you actually start one of the courses you bought, watching a tutorial on a subject and following along is often a trap. If that is all you do, you will think you learned a lot, but when you open your editor, you will be lost. Don't get me wrong, tutorials and mini-projects are a great way to learn. But you need to extend the project and apply the knowledge.

Now that we know why buying courses can lead to tutorial hell and how to prevent it, what should we do?

Develop a Project to Completion

As previously mentioned, you can extend the project in your course to develop your skills. Adding a new feature or changing the back end database are great ways to do so. However, I encourage you to create a new project outside your comfort zone. This will enable you to apply your newfound knowledge while making mistakes and learning through experience. Most importantly, it allows you to write code. Stumbling through developing a web app with authentication, a UI library, and other technologies hones your skills and gives you experience writing code. As Han said in Tokyo Drift (adapted for the subject at hand, of course), "There is no wax on wax off in coding. You learn by doing it."

Don't Feel Pressured to Make it Amazing

When first learning, there is no need to focus on making your projects feature-rich or beautiful. Learning how to structure a website is miles more important than learning how to make it visually appealing (which is still essential, but not initially). Avoid letting perfection get in the way of done, and avoid spiraling back into tutorial hell so you can learn one more thing for your project. Write the code and use what you learned to improve the next project or iterate on the one you just completed.

Takeaway

I won't lie to you: making projects is hard. But not making progress and wasting time is hard, too. You will get stuck, stumble, and frustrated. It happens to us all. But I encourage you to push through and complete your project. Learning to unblock yourself and follow through on a task are vital skills in both software engineering and life in general.

Design Patterns: A Brief Primer

Jake Espinosa — Thu, 26 Oct 2023 22:18:54 +0000

Programming is both an art and a science. While creativity is essential, established standards and general patterns make writing code easier. Design patterns are templates for object-oriented code that allow you to spend mental energy on functionality rather than implementation. You do not need to memorize them all, but familiarity with the 23 standard design patterns will serve you well.

What Are Design Patterns?

According to Wikipedia:

general, reusable solution to a commonly occurring problem within a given context in software design

Design patterns give you proven solutions to common problems. However, be wary of viewing every engineering problem through the lens of design patterns. They are solutions to problems, not something you shoehorn into every codebase. With familiarity and time, you will naturally see problems best solved with a design pattern.

Creational

Creational design patterns let you abstract away the creation of an object. They are helpful when object creation relies on complex logic or many parameters/attributes.

Behavioral

Behavioral design patterns deal with algorithms -- behavior -- and let you abstract them away.

Structural

Structural design patterns concern defining relationships between classes and objects. The relationships allow composing smaller classes and objects into bigger ones.

Why Use Them?

The purpose of design patterns is two-fold: to make your code more reusable and to save mental energy for other aspects of writing code.

Reusability

At the heart of every design pattern is reusability and extensibility. They are strategies to flexibly accomplish tasks that can be modified in a logical and consistent way. For example, the Abstract Factory can easily be extended by adding one more class that implements the factory interface. The Strategy Pattern can be extended by adding more algorithms that implement the strategy interface. Often, extending code that uses a design pattern is as simple as adding another implementation of an interface.

Don't Reinvent The Wheel

Design patterns are just that - patterns. They are templates that we can follow to accomplish tasks. Following a pattern saves us the mental energy of devising a maintainable and usable solution and allows us to spend energy on using the solution to solve problems.

Resources to Learn Design Patterns

Design Patterns: Elements of Reusable Object-Oriented Software - book
Design Patterns for Humans - GitHub

Takeaway

Design patterns provide proven methods to solve common problems faced in software engineering. They promote maintainable and reusable object-oriented codebases. However, be wary of trying to solve every problem with a design pattern. They are tools, and you should pick the right tool for the job.

My Data Structures and Algorithms Study Method

Jake Espinosa — Wed, 18 Oct 2023 00:59:48 +0000

Cracking the Coding Interview? LeetCode? NeetCode? You’ve probably heard of them all if you’re preparing for a technical interview. However, most people I see are approaching interview prep the wrong way (or at least inefficiently). Data structures and algorithms (DSA) are often touted as the most challenging part of computer science, but, like everything else, it’s manageable with the right plan of attack.

I based my process on Josh Madakor’s study process, as shown in this video from 4:37-13:32. I made some slight modifications that I feel work better for me. You are free to do so as well.

Resources

I recommend several resources, some free and some paid. The paid resources are extremely well-packaged and saved me countless hours of searching for answers in incomplete tutorials. I am not sponsored by either, but I highly recommend them. Personally, I take my education seriously and am willing to pay to expedite it. It’s absolutely okay if you can’t afford the paid resources and can use others to implement this study method. However, I cannot provide any recommendations as I did not use them.

Free Resources

Paid Resources

Code with Mosh's Ultimate DSA Bundle ($30)
A Common-Sense Guide to Data Structures and Algorithms, Second Edition ($30)

Process

First, create an Anki deck to study DSA problems in smart intervals. I won’t describe Anki in this article, but I highly recommend it for effective studying. Next, begin learning DSA and solving interview problems as you go. I recommend going through the Code with Mosh tutorial in order, reading the relevant chapters in the Common-Sense book, implementing the data structure, and solving easy problems associated with it on the NeetCode 150. Each data structure, algorithm, and problem should be made into an Anki card and studied.

Try to spend only a little bit of time figuring out solutions. If you give an honest effort for around 30 minutes and still can’t solve or implement something, you should look at the solution and understand it deeply. Take a break to let the concepts sink in, then try to implement it blindly. Once you can, you will be ready to add it to your Anki deck.

The goal is not to memorize the problems and solutions. Instead, you will be building an understanding of when to use which data structure and/or algorithm to solve a given problem. By practicing with Anki, you will develop an intuition for applying what you’ve learned and significantly increase your ability to solve new DSA problems.

Once you have learned all the data structures and completed all the easy problems, begin tackling the mediums. Once you’ve mastered the mediums, do the same with the hards. Keep up to date on your Anki deck to keep the problems fresh in your mind. You don’t need to complete all 150 to feel ready for interviews. In fact, you will likely never feel completely prepared for interviewing. However, each problem, data structure, and algorithm you implement is one step closer to getting your dream job.

Too Long; Didn't Read

Learn DSA and solve problems as you go
Add the problems to your Anki deck and solve them at the specified intervals

Stay the Course

Studying DSA is not the most entertaining thing, and there are a million other things most people would rather do. However, it is absolutely worth your time as it massively improves your chances of landing a job or getting a new one. Remember your why as you study, and don’t lose sight of your goals.

Summary

DSA is a beast to learn, but with the approach outlined in this article, it is absolutely doable. With a couple of free and paid resources, time, and willingness to learn, you will grok DSA and dramatically improve your performance in the technical round of your dream job’s interview. Good luck and happy LeetCoding!