DEV Community: Educative

LeetCode Blind 75 patterns: Crack the coding interviews

Fahim ul Haq — Fri, 22 Nov 2024 10:31:56 +0000

Coding interviews are a critical part of the hiring process for software engineering roles in the tech industry. They typically involve solving algorithmic and data structure problems, and sometimes domain-specific tasks. These interviews aim to assess a candidate’s problem-solving abilities, coding skills, and understanding of computer science fundamentals.

Why preparing for the coding interviews is important

The competitive nature of the tech industry means that many qualified candidates compete for the same positions. Thorough preparation can make a significant difference, because it helps candidates to quickly and accurately solve problems under pressure. By practicing extensively, candidates become familiar with common problem types and can develop efficient problem-solving strategies.

Practice a pool of problems
One effective method for interview preparation is to practice from a curated pool of problems. These problems are selected to cover various topics and patterns that frequently appear in coding interviews. By focusing on a well-rounded set of questions, candidates can ensure they are prepared for the diverse challenges they may face during the interview.

LeetCode is one of the most widely used platforms for coding practice and interview preparation. It offers a vast collection of problems categorized by difficulty and topic, along with detailed solutions and discussions. However, the extensive set of problems can make it challenging for candidates to prepare effectively for technical interviews. This is why, instead of practicing thousands of problems, we’ll focus on a curated pool of selected problems known as the Blind 75.

Introduction to Blind 75

Blind 75 is a curated list of 75 coding interview questions that are considered essential for preparing for technical interviews, particularly for software engineering roles. This list was created by a software engineer Yangshun Tay from Blind, a community where tech professionals discuss various topics, including job interviews and career advice. The Blind 75 list has gained popularity due to its focus on fundamental problems that frequently appear in coding interviews.

The problems included in the Blind 75 list are carefully selected to cover a broad range of topics that are commonly asked in technical interviews. These topics include arrays, linked lists, dynamic programming, trees, graphs, intervals, strings, binary search, heap, and backtracking. Each problem is chosen to help candidates understand and master key concepts, techniques, and patterns necessary for solving a wide variety of coding challenges.

How is the Blind 75 structured on the internet?

The Blind 75 problems are typically organized by data structures and difficulty levels. Here is the complete list of problems categorized based on data structure:

Array

The following are the array-related problems in Blind 75. There are three easy problems and seven medium-difficulty problems.

Binary

The following are the binary-related problems in Blind 75. There are four easy problems and one medium-difficulty problem.

Dynamic programming

The following are the dynamic programming-related problems in Blind 75. There is one easy problem and ten medium-difficulty problems.

Graph

The following are the graph-related problems in Blind 75. There are seven medium problems and one hard-difficulty problem.

Interval

The following are the interval-related problems in Blind 75. There is one easy problem and four medium-difficulty problems.

Linked list

The following are the linked list related problems in Blind 75. There are three easy problems and two medium-difficulty problems.

Matrix

The following are the matrix-related problems in Blind 75. There are four medium-difficulty problems.

String

The following are the string-related problems in Blind 75. There are three easy problems, six medium-difficulty problems, and one hard-to-solve problem.

Tree

The following are the tree-related problems in Blind 75. There are four easy problems, seven medium-difficulty, and three hard-to-solve problems.

Heap

The following are the heap-related problems in Blind 75. There is one easy problem and two hard-to-solve problems.

How is the Blind 75 structured on Educative?

On Educative, the Blind 75 problems are structured in a course format that guides learners through each problem step-by-step. Instead of organizing problems by data structures, they are categorized by coding patterns. This approach helps learners recognize and understand recurring patterns in coding problems, making it easier to apply similar strategies to unseen problems.

With the same set of 75 problems, we have covered 23 patterns. These patterns are as follows:

The course is offered in five programming languages: Python, C++, Java, JavaScript, and Go, allowing learners to choose the language most relevant to their needs. Explore the course variants available in different programming languages below:

Why use pattern-based categorization instead of data structure-based categorization?

In the context of coding problems, patterns are recurring solutions or strategies that can be applied to solve similar types of problems. Instead of focusing solely on data structures, which are more about the organization and storage of data, pattern-based categorization emphasizes the methodology and approach to solving problems.

Recognizing and understanding patterns is important for several reasons:

Efficiency in problem-solving: Patterns provide a blueprint for approaching a problem. Once you recognize a problem as fitting a particular pattern, you can apply the known solution strategy, which saves time and effort in devising a new approach from scratch.
Transferable knowledge: Learning patterns helps in transferring knowledge across different problems. Even if the problems differ in specifics, the underlying pattern remains the same, allowing you to apply the same strategy to multiple scenarios.
Enhanced understanding: Understanding patterns deepens your grasp of problem-solving techniques. It moves beyond rote memorization of solutions and toward a more conceptual understanding of why certain approaches work, which is essential for adapting to new and unfamiliar problems.
Preparation for interviews: In coding interviews, problems are often designed around common patterns. Recognizing these patterns can give you an edge, as you can quickly identify the nature of the problem and apply a proven solution strategy.

Pattern-based categorization helps learners develop a toolkit of broadly applicable strategies, making them more universal and effective problem solvers. This approach not only assists in mastering specific problems but also builds a strong foundation for tackling new challenges in the future.

Why choose Blind 75 on Educative

Educative offers several features that make it a valuable platform for learning Blind 75:

Interactive learning: Educative provides interactive learning in terms of implementing and testing your code, running the solutions, and understanding them with the help of illustrations.
Video vs. illustration-based learning: Unlike other EdTech platforms that primarily use videos for teaching, Educative employs illustrations to help learners first understand the problem and then grasp the intuition behind the solution by demonstrating a dry run on an example. Moreover, learners can easily run the illustration at their own pace, which helps them better understand the scenario.
AI-enabled feedback: Coding widgets provide personalized feedback on the solution codes. The AI-enabled widget helps learners develop problem-solving skills and encourages them to think in the direction of generating their own solutions.
Test cases: Educative tests learners’ codes on a bunch of test cases, validating their problem-solving and coding skills on the edge cases.
Pattern-based focussed learning: As compared to other platforms that just bombard learners with an extensive pool of problems, Educative provides pattern-based focussed learning that teaches the underlying patterns in solving coding problems.
Difficulty distribution: Educative starts with easier coding interview patterns, gradually increasing the difficulty level to medium, and finally ending with the hardest patterns to provide an effective interview preparation.
Premium content: Educative includes a few premium LeetCode problems to ensure comprehensive interview preparation.

Where to go next?

If you have enough time to learn more or you want to be a pro in the interview, then you can explore the following:

Educative-99
Grokking the coding interview patterns
Dynamic programming

Educative-99

Educative-99 is a special list of curated coding problems to help learners ace their coding interview preparation in a reasonable amount of time. It is designed for focused and systematic blitz pattern-based interview preparation. You can explore the course variants available in different programming languages below:

Grokking coding interview patterns

To effectively prepare for coding interviews, many candidates opt for specialized courses that teach coding interview patterns. Platforms like Algo Monster and LeetCode offer various resources to help learners master these patterns. However, at Educative, we provide a unique and comprehensive approach. Our Grokking Coding Interview Patterns course stands out with its in-depth coverage and practical focus. The course includes individual lessons that introduce each pattern, discussing techniques, algorithms, and data structures tailored to address common coding challenges. Our course ensures thorough preparation by covering a total of 26 patterns. You can explore the course variants available in different programming languages below:

Dynamic programming

Dynamic programming is one of the most frequently asked question patterns. Almost all companies ask questions relevant to dynamic programming. To master dynamic programming, you can explore the course variants available in different programming languages below:

Conclusion

In conclusion, preparing for coding interviews is essential for aspiring software engineers aiming to secure roles in the competitive tech industry. The LeetCode Blind 75 offers a focused approach, emphasizing the importance of mastering fundamental problems that are frequently encountered in technical interviews. Educative enhances this preparation by structuring these problems around coding patterns, which not only helps in solving specific problems but also equips learners with versatile problem-solving strategies.

The Blind 75 list, with its comprehensive coverage of key topics and patterns, provides a solid foundation for tackling a wide variety of coding challenges. Educative’s interactive, pattern-based learning approach, supported by AI-enabled feedback and extensive test cases, ensures that learners gain a deep understanding of these patterns and learn how to apply them effectively.

System Design Primer

Fahim ul Haq — Mon, 18 Nov 2024 07:15:39 +0000

Imagine you're at a top-tier tech interview, and the interview asks you to design a scalable social media platform for millions of users. Where do you start?

That's the essence of System Design —the skill that can make or break your career in tech.

Whether you're prepping for a major interview or building scalable applications, System Design skills are essential. It's your software's blueprint to ensure that everything runs smoothly under real-world demands. And top companies use System Design interviews to test how well you can create systems that are efficient, reliable, and scalable.

Today, I'm going to walk you through the critical System Design concepts and strategies you'll need to succeed, whether you're a beginner or an experienced engineer sharpening your skills.

Drawing on my experience at FAANG companies, I'll share practical tips and insights to help you ace your next interview. Here's a look at what I'll cover:

For starters, we'll discuss the first section in this System Design primer—the fundamentals you'll need to master!

System Design fundamentals

Before you can design complex systems, you need a solid foundation in the core components that power them. Operating systems, computer networks, and distributed systems form the backbone of modern software architecture, and mastering these fundamentals will prepare you for even the toughest System Design challenges.

Each of these areas play a critical role:

Operating systems manage the resources and processes that keep applications running smoothly.
Computer networks enable communication across machines and locations.
Distributed systems ensure applications are scalable, reliable, and available.

In the next section, I'll break these concepts down and show you how they come together to create the scalable systems you'll be asked to design in interviews—and beyond.

Of course, there are hundreds of terms and concepts in System Design. However, based on my experience as both a candidate and an interviewer in several System Design interviews, the following topics are considered the highest priority.

Operating systems fundamentals

Operating systems (OS) are more than just the software that runs your applications—they’re the backbone of modern computing. A solid understanding of OS internals, from process management to memory allocation, is essential for any aspiring System Design engineer. Mastering these core concepts can significantly impact the efficiency and reliability of your designs.

Key OS concepts for System Design

Process management: The ability to handle multiple processes efficiently is at the heart of any OS. Understanding how an OS schedules tasks, manages CPU time, and controls process states will help you create responsive and stable systems.
File systems: The file system is responsible for storing and retrieving data. Different file systems offer various advantages and trade-offs, affecting performance and scalability. Understanding these can be pivotal when designing systems that handle vast amounts of data.
OS architectures: Lastly, learn about different OS architectures, such as monolithic and microkernel systems. Each has its own performance implications and trade-offs, which can greatly affect your design choices.

Another fundamental concept closely tied to operating systems is concurrency —the ability to execute multiple tasks simultaneously. concurrency is crucial in modern systems that need to perform several operations at once, whether it's processing user requests, running background tasks, or managing distributed workloads.

In System Design, concurrency is one of the key factors that determines how responsive and scalable your system will be. However, managing concurrent tasks introduces complexity, especially when multiple processes need to access shared resources. Without proper synchronization, you risk issues like race conditions, deadlocks, or inconsistent data.

How concurrency works
Concurrency works by dividing tasks into smaller, independent components that can run in parallel. Synchronization techniques, such as locks, semaphores, and condition variables, act as “traffic lights” that control when processes can safely access shared resources without conflict.

In distributed systems, concurrency becomes even more complex due to network delays and the absence of shared memory. Specialized algorithms like distributed locks and consensus models are required to manage these challenges, ensuring performance and data consistency across multiple machines.

Mastering concurrency not only boosts your system’s efficiency but also prepares you for the design challenges that arise in large-scale, real-world systems.

Continue reading about operating systems with this fundamentals course: Operating Systems: Virtualization, Concurrency & Persistence.

Next up—let's focus on the fundamentals computer networks.

Computer networks fundamentals

Have you ever wondered how computers talk to each other across vast distances? The magic lies in computer networks, interconnected devices sharing information and resources. Think of it as inter-machine communication, much like how processes communicate within a single machine through IPC (inter-process communication).

OSI model and protocols

Computer networks are the backbone of the internet. The OSI (Open Systems Interconnection) model, which divides network tasks into seven layers, ensures everything runs smoothly—from physical wires (Layer 1) to your applications (Layer 7). This layered approach facilitates communication within local area networks (LANs) and across wide area networks (WANs).

TCP (Transmission Control Protocol) and UDP (User Datagram Protocol) show how data travels. TCP ensures reliable, ordered data transfer—ideal for emails and web browsing. UDP offers faster but less reliable communication, perfect for live video streaming.

Application layer protocols

At the top of the OSI model lie application layer protocols like HTTP and HTTPS, the languages your browser uses to talk to websites. HTTP enables web page requests and data exchange, forming the basis of internet communication. HTTPS adds security, ensuring data privacy.

FTP (File Transfer Protocol) and SMTP (Simple Mail Transfer Protocol) facilitate seamless file transfers and email communications, respectively.

APIs and RPCs

APIs revolutionized how systems interact. REST (Representational State Transfer) and GraphQL are popular web API architectures. REST uses a stateless, client-server model, making it scalable and straightforward for public APIs. GraphQL, a more flexible query language, allows clients to request specific data, minimizing over-fetching.

While APIs excel in many areas, remote procedure calls (RPCs) bring another layer of efficiency. RPCs, like Google’s gRPC, allow a program on one computer to execute a function on another as if it were local. It leverages Protocol Buffers and HTTP/2, offering high performance and low latency—perfect for modern microservices.

Communication models

Communication models define how information flows between entities in a system, playing a key role in shaping the design and behavior of technologies we use every day. Two of the most fundamental models are client-server and peer-to-peer (P2P).

In the client-server model, distinct roles exist: clients request services, and servers deliver them. This model, common in web services and databases, simplifies management but introduces a single point of failure if the server goes down.

In contrast, the peer-to-peer (P2P) model decentralizes these roles—each device (peer) acts as both a client and a server. This increases redundancy and resilience, making P2P ideal for use cases like file sharing and blockchain. However, its distributed nature introduces added complexity in management.

Together, these models form the backbone of modern internet architectures, influencing designs like Model-View-Controller (MVC) and microservices . To dive deeper into how these models function within computer networks, check out the course Grokking Computer Networking for Software Engineers.

Now, onward to distributed systems!

Distributed systems

In today's world, software rarely runs on a single machine. Instead, it operates across multiple computers working together to deliver services. These d istributed systems share workloads across a network of devices, powering everything from cloud infrastructure to smart home sensors. Their unique characteristics shape how they’re built, maintained, and used.

Key characteristics of distributed systems

These key characteristics define a distributed system’s behavior in the real world:

Scalability: The main advantage of distributed systems is their capacity to scale. As demands grow, additional computers can be integrated to handle more users, data, or transactions. Scalability can be achieved through vertical scaling (boosting the power of existing servers) or horizontal scaling (adding more servers).
Availability: Distributed systems are designed for high availability, ensuring they remain functional even if some machines fail. This is achieved through redundancy and fault tolerance, where data and services are replicated across multiple machines.
Consistency: Maintaining data consistency across numerous machines is challenging. Strict consistency ensures every read sees the latest write but may sacrifice availability. Eventual consistency favors availability, allowing temporary inconsistencies to be resolved. The CAP theorem and PACELC theorem help us understand these trade-offs.
Latency and performance: Communication between distributed computers introduces latency, affecting performance. Minimizing latency through careful design and optimization is crucial for a responsive user experience.
Security and privacy: Distributed systems are more susceptible to security threats because they have a larger attack surface (lots of interconnected machines). Robust measures like authentication, authorization, and encryption are essential to protect data and system integrity.
Monitoring and observability: Monitoring system health and performance is vital for detecting and resolving issues before they impact users. Observability tools provide insights into system behavior, aiding in diagnosis and troubleshooting.
Resilience and error handling: Failures are inevitable in complex distributed systems. Resilient systems are designed to withstand failures and recover quickly, minimizing downtime and data loss. Effective error handling is key to maintaining reliability.

I can go on with the list, but Dimos Raptis explains the ins and outs of distributed systems really well in his course.

With all that in mind, let's switch gears to talk about System Design interviews, what makes them unique, and how to nail them.

Strategies for acing the System Design interview

Now that we've covered key System Design concepts, let's discuss how to put that knowledge to use in the interview process.

System Design interviews can be challenging because they’re unconventional compared to typical coding interviews. They require not only technical skills but also the ability to structure your thoughts clearly and tackle open-ended problems. With practice and preparation, however, you can develop a strategy to approach these interviews with confidence.

To help you prepare for your System Design interview, I recommend checking out my blog on what NOT to do in a Netflix System Design interview.

Defining system requirements

Before diving into design, the first and most important step is to clarify the system’s requirements. This is crucial for success, as it sets the foundation for everything that follows.

Functional requirements: These define what the system should do. For example, a social media platform might require features like user profiles, messaging, and posting capabilities.
Non-functional requirements: These outline how well the system performs. For instance, the same social media platform might need to support 10,000 concurrent users with a response time under 2 seconds, emphasizing performance, reliability, and security.

Remember, functional requirements describe what the system does, while non-functional requirements describe how well it performs those tasks. You’ll need to address both in your interview, demonstrating a clear understanding of core functionalities before considering trade-offs in performance or scalability.

Estimation

Effective System Design includes estimating the system’s scale. You’ll need to calculate factors like queries per second and data storage to ensure the system can handle its expected load. For instance, a platform like X (formerly Twitter) needs to estimate storage, bandwidth, and post views based on user activity.

Example: Assuming each post with metadata is 30 bytes, 100 million new posts per day would need about 30GB/per day.

Interview tip: The most important estimations an interviewer is looking for are storage, bandwidth, and the number of servers required.

High-level design

Once you’ve defined the requirements, it’s time to start outlining the high-level design. This stage involves identifying the main components and how they interact, without diving into implementation details just yet.
Considerations for high-level design:

What are the key building blocks of the design?
SQL databases vs. NoSQL databases?
What is the database schema/data model?
What database should we use? Amazon RDS? MongoDB?
What do the interfaces look like for these components? Do we need REST APIs or RPCs?

For instance, X’s system must efficiently handle high storage and bandwidth requirements. We can see a sample high-level design for X below:

Interview tip: The GitHub repo contains the most-asked System Design interview questions.

Detailed design

Next, dive into the details of each component, ensuring that your design addresses both functional and non-functional requirements.

Consider different approaches and evaluate their pros and cons.
Perform a trade-off analysis for caching, load balancing, and data partitioning.
Evaluate whether to use open-source solutions or custom, closed-source components.

Interview tip: Check out Twitter/X's detailed system design to see a robust example.

Identifying and addressing bottlenecks

With your detailed design in place, the next crucial step is to identify and mitigate system bottlenecks. Bottlenecks can arise from various aspects, such as traffic, data handling, storage, availability, redundancy, and backups. Addressing these can significantly improve system performance and reliability.
Here are some sample questions to guide you in this process:

Is there a single point of failure in the system? If so, how can it be eliminated?
Is data replication sufficient to ensure continued service if a few servers fail?
Do we have enough copies of our services to avoid potential shutdowns?

By thoroughly analyzing these factors, you can strengthen your system’s resilience and ensure it operates smoothly under various conditions.

Next steps to master System Design

Mastering System Design starts with the fundamentals—operating systems, networking, and distributed systems—and extends into real-world problem-solving. These concepts give you the foundation you need to tackle System Design interviews.

In interviews, clearly define both functional and non-functional requirements. Focus on balancing trade-offs and designing solutions that meet constraints like time and resources. Success in System Design is about more than just code—it's about problem-solving, making smart decisions, and delivering reliable, scalable systems.

To sharpen your skills, explore courses like Grokking Modern System Design Interview, and test yourself with mock interviews to prepare for real-world challenges.

Hopefully this System Design primer has you feeling confident about building your skills and how to show them off in interviews. Good luck—you've got this!

What are the best resources for studying System Design?

Fahim ul Haq — Thu, 14 Nov 2024 10:01:26 +0000

The tech world is changing fast, and if you want to stay ahead, you need to be able to design systems that can handle anything. This can feel overwhelming, especially if you’re just starting or prepping for a tech interview specifically focused on designing scalable systems.

I had the same experience preparing for my first System Design interview at FAANG. I searched online to find what could work for me. I found many resources through informational videos, books, and e-learning platforms. So, as any software engineer would, I decided to try each one to find the best.

In this blog post, I share my ongoing journey of learning System Design, which began with exploring various interview prep resources. I dive into the details of the different platforms I used, ultimately revealing which one I found most valuable and continue to use today.

I will be comparing three popular resources: Educative’s “Grokking Modern System Design Interview for Engineers & Managers,” Design Gurus’ “Grokking the System Design Interview,” and Alex Xu’s “System Design Interview” books.

Here is everything we will cover:

Disclaimer: This blog is based on my experience and opinion alone. You may have different preferences.

Why System Design mastery matters

System Design interview preparation is crucial for professionals aspiring to thrive in tech industry roles, such as software engineers, system architects, or technical leads. Unlike traditional coding interviews that focus on algorithmic prowess, System Design interviews evaluate candidates’ ability to design complex, scalable systems that are robust and efficient. This shift reflects the industry’s growing emphasis on practical problem-solving and architectural considerations in real-world applications.

Challenges in System Design preparation

System Design interviews stand out from their coding counterparts. While standardized coding tests present well-defined problems with clear solutions, system design relies on open-endedness. Candidates must navigate multifaceted questions, demonstrating a holistic understanding of:

Architectural patterns: Identify the appropriate architectural approach (e.g., monolithic, microservices). Consider designing a social media platform. A monolithic architecture might be suitable in the early stages, but as the user base and data volume grow, a microservices architecture would offer better scalability and maintainability.
Scalability considerations: Design systems that can grow and adapt to increasing user demands and data volume. This includes aspects like database sharding, caching strategies, load balancing, and consistent data models. Imagine designing a photo-sharing app. A horizontally scalable database with caching mechanisms for frequently accessed data would be crucial to handle millions of concurrent users uploading and viewing images.
Trade-offs: Justify design choices by weighing different options and their benefits and drawbacks. For instance, choosing between a relational database and a NoSQL database depends on the application’s specific data access patterns and consistency requirements. A relational database offers strong data integrity but might struggle with high-volume writes, while a NoSQL database excels in scalability but might have looser consistency guarantees.

Here’s what makes System Design prep a unique challenge:

Non-trivial process: There’s no single right answer. Interviews require candidates to think critically, discuss various approaches, and defend their design decisions effectively. Be prepared to explain your reasoning and answer follow-up questions that dive deeper into the chosen architecture and its trade-offs.
Company-specific differences: Tech companies prioritize different aspects of System Design. Some may focus on distributed systems, emphasizing designing fault-tolerant services that can operate across geographically distributed data centers. Others might emphasize microservices architecture, requiring you to demonstrate expertise in breaking down complex functionalities into independent, loosely coupled services. Research the specific company beforehand to tailor your preparation accordingly.
Limited comprehensive resources: Finding up-to-date resources that cover the breadth and depth of System Design principles can be difficult. Textbooks and online courses often lack the comprehensive approach for a thorough understanding. Look for resources that combine theoretical foundations with practical application through case studies and practice problems focused on real-world scenarios like designing a food delivery app or a content streaming platform.
Theory vs. practice gap: Bridging the gap between theoretical knowledge and practical application is significant. Succeeding in interviews requires hands-on practice and familiarity with real-world scenarios. Utilize tools for simulating system behavior or participate in mock interviews to gain practical experience explaining and defending your design choices under pressure.
Navigating the interview: Articulating thoughts clearly, handling feedback gracefully, and demonstrating strong problem-solving skills under pressure are vital for success. Practice presenting your thought process, actively listen to the interviewer’s questions and suggestions, and be prepared to adapt your design based on the feedback received.
Seniority matters: The focus of System Design interviews shifts based on experience. Entry-level candidates concentrate on foundational concepts like database selection, caching strategies, and basic load-balancing techniques. Senior professionals tackle advanced topics like intricate scalability techniques, complex architectural patterns like event-driven architectures, and managing large-scale systems with millions of users and high data volumes.

Three tough contenders

After sifting through various resources to tackle System Design interview challenges, I landed on three well-regarded options:

Educative’s “Grokking Modern System Design Interview for Engineers & Managers”
Design Gurus’ “Grokking the System Design Interview”
Alex Xu’s “System Design Interview” books

Each offers a distinct approach, catering to different learning styles and experience levels.

To help you find the best fit, this blog will provide a balanced comparison of these resources. We’ll discuss their strengths and weaknesses to empower you to make informed decisions based on your needs.

Overview of System Design Learning Platforms

Comparison of top System Design resources

This section dives deeper into how the above-mentioned resources compare, looking at how many courses they offer and how much they cover. This will help you pick the best one to learn System Design from my experience!

Educative’s “Grokking Modern System Design Interview for Engineers & Managers” (GMSD)
Searching through videos on System Design, I came across this video:

https://www.youtube.com/watch?v=2kEMI3i5saQ&t=8s

It was the first video I thought had real value. So, I decided to check out what all the fuss was about. I had heard of Educative back when I started my career. After going through 175+ lessons, 2 mock interviews, and countless real-world assessments in the “Grokking Modern System Design Interview for Engineers & Managers” course, below are my thoughts.

Educative’s GMSD is a one-stop shop for learning system design, from beginner to expert. It starts with free, foundational courses that teach the basics, ensuring everyone has a strong understanding before tackling tougher topics.

Going through their extensive course catalog, I found that Educative has a wide variety of courses, everything from Python to GenAI to System Design. I really liked their distributed systems offerings. I am currently in the middle of taking their Advanced System Design and Product Architecture (API design) courses.

High-quality content that keeps up

Educative’s GMSD doesn’t just cover a lot of ground; it covers it well. You’ll get a deep understanding of System Design from different angles. If you need help, they offer support for questions and a forum to chat with other learners and instructors. The content is constantly updated with new explanations, blogs , and design problems to keep things fresh and relevant.

I asked the people at Educative to tell me how I should learn system design on their platform; this is the list they gave me:

Educative’s GMSD, being their flagship course, has over 40 chapters covering 16 key system design building blocks. You’ll also get 13 real-world design problems to test your skills. With 175 detailed lessons and quizzes, I was amazed at the quality and attention to detail in every aspect, from the content to illustrations to quizzes.

If you are short on time, they even have crash courses:

System Design Interview Prep Crash Course (33 lessons)

Advanced System Design Interview Prep: Crash Course (11 lessons)

Now, let’s look at another popular resource among avid System Design learners: the Design Gurus' course, which takes a focused approach to System Design.

Design Gurus’ “Grokking the System Design Interview”

Design Gurus has a limited number of good courses. They are also a popular destination for System Design. I recently found out that Design Gurus’ course was actually available on Educative for a while. I am unsure why that changed, but Educative’s current course, GMSD, seems to be a supercharged version of Design Gurus’ offerings. Perhaps Educative learned from the Design Gurus’ course on their platform and improved upon it to make a better version of their own; at least, that’s what they said when I asked them. In any case, here is what I learned.

Design Gurus’ course gets you interview-ready with a single, focused program. It dives right into system design fundamentals and key concepts. Then, it throws real-world design problems your way, complete with step-by-step guides to crack them.

Design Gurus’ System Design course was written before 2017. They say the older the wine gets, the better it is but I’m not sure if that applies to a course. I leave the choice to you here.

This course is known for its real-world case studies. It shows you how system design principles are actually used. Plus, the focus on patterns helps you recognize and use them in different situations, making you a better problem-solver. They even include clear illustrations to make complex concepts easier to understand. However, keep in mind there are no interactive quizzes, so if you learn best by doing, this might not be your first choice.

Alex Xu’s “System Design Interview” (SDI)

Alex Xu’s “System Design Interview” (SDI) is a two-volume book on mastering system design challenges. Volume 1 caters to beginners by introducing fundamental problems and their step-by-step solutions. Volume 2 dives deeper, tackling advanced topics and complex design scenarios as compared to Volume 1.

Note: I found that the design problems here were simpler than Educative’s GMSD. For example, they have the design of a messaging queue as a complex problem in Volume 2, while it is a basic building block in Educative's GMSD.

This structured approach ensures learners of all experience levels can build their skills progressively.

Each design problem is meticulously broken down into clear, concise steps, making it easy to follow and understand. Additionally, the content is thoroughly researched, providing learners with detailed, reliable, and accurate system design knowledge.

Extensive coverage

Across both volumes, you’ll find 29 chapters tackling 23 design problems, offering an in-depth exploration of each topic. With a combined length of 693 pages, SDI provides learners with a comprehensive resource for mastering system design challenges.

Note that even if there are a lot of pages to cover, it still has 23 design problems, compared to Educative’s GMSD, which has 16 building blocks plus 13 real-world problems, totaling 39 design problems.

System Design resources quality comparison

Let’s look at the content quality differences between the three learning resources.

Educative

Educative’s “Grokking Modern System Design Interview for Engineers & Managers” stands out for its expansive curriculum. It covers foundational concepts all the way up to advanced system design and even dives into API design. This comprehensive approach prepares you for interviews and real-world system design challenges you might encounter later. Plus, the platform offers a supportive environment with regular updates and readily available assistance, ensuring you stay current and have help when needed. Additionally, detailed illustrations provide valuable visual aids for grasping complex concepts. What I particularly liked was the structure of each design problem. For example, if you are to design YouTube, the following is the structure of lessons:

They use th RESHADED approach to tackle all problems, which is the best part for me. This approach enabled me to answer unseen problems during my interview.

Each lesson in GMSD has added value in the form of additional reasoning, quizzes, interactivity, improved structure, and better writing. In GMSD, learners are taught how to design the core components (like cache, monitoring system, blob store, etc). Problem set: GMSD has traditional as well as newer design problems like Quora, which I haven’t found on any other platform yet. I got the feeling that with GMSD, the idea is to not only prepare learners for the interviews but also to teach them System Design so they can answer traditional as well as new System Design problems.

The only gap I could find was that there were not too many advanced interview problems in that course compared to something like SDI. But later, when I found the advanced System Design course, it made sense that Educative’s GMSD is an intermediate-level course while the problems missing were expert-level.

Design Gurus

Design Gurus’ “Grokking the System Design Interview” excels at making the learning process practical. It bridges the theory-to-practice gap with real-world case studies and pattern-based learning, making the content immediately relevant and highly applicable.

The Design Gurus course has a good structure as well, but the problem is that the solution to an entire problem is given in one lesson. This makes it difficult to digest a saturated lesson full of complex concepts. I like crunching the problem into digestible chunks to learn it. On the flip side, it helps to quickly go through the boilerplate solutions of different problems just before the interview.

Keep in mind, though, that some learners might find the lack of hands-on practice elements, like quizzes, a drawback.

Alex Xu

Finally, Alex Xu’s SDI volumes boast meticulous detail and thorough research. Their structured and clear explanations ensure a deep understanding of each design problem presented. Across both volumes, you’ll find 29 chapters tackling 23 design problems, offering an in-depth exploration of each topic. With a combined length of 693 pages, SDI provides learners with a comprehensive resource for mastering system design challenges. However, the text-heavy format with minimal interactive elements might not be as engaging for everyone. Learners who prefer a more dynamic learning experience might find this approach less effective.

Note: Ultimately, the choice depends on your learning style and goals. Do you crave a comprehensive journey with ongoing support, or are you laser-focused on acing interviews? Consider your needs and choose the resource that best aligns with your learning preferences.

Overview of SDI Learning Resources

Interactivity and learning styles

We all learn differently, and some of us thrive on active participation. From my experience and knowledge, here’s how these resources cater to that need for interactivity.

Learning is most effective when engaging, and that’s where interactivity comes in. When I first started exploring resources for system design, I noticed a big difference in how interactive each one was. Educative’s “Grokking Modern System Design Interview for Engineers & Managers” stood out with features like quizzes, slides, illustrations, and even AI-powered interactivity. These widgets weren’t just bells and whistles—they helped me put my knowledge to the test by simulating real-world scenarios. Plus, the platform offered AI mock interviews, a lifesaver for practicing those nerve-wracking design interviews.

The AI-powered assessments really helped me grasp difficult concepts. These assessments were sprinkled throughout the course. I loved them so much that I asked for more, but the team told me that too much of them would hinder my progress because they are addictive!

Design Gurus’ course, on the other hand, heavily relied on beautiful illustrations to explain complex concepts. While it lacked the interactive elements of Educative, it was still effective enough to make sense of the material.

Alex Xu’s books took a purely textual approach, with extensive detailed explanations. While I appreciated the depth of knowledge, I sometimes felt like I wasn’t actively applying what I was learning.

Which resource is best for hands-on learning?

The way each resource used quizzes, slides, and illustrations definitely impacted my learning experience. Educative packed a punch with 135 quizzes throughout the course. They weren’t just busywork—they really helped solidify my understanding of the key concepts. Plus, the platform used tons of slides and over 800 illustrations, making everything more visually engaging.

Educative’s AI

What truly set Educative apart was its use of AI. Other than the AI assessments, they had something called “Explain with AI.” Simply, if you don’t know a concept, highlight the line, and AI will explain it to you by giving an example in the context of the lesson. It means on-the-spot customer support. I loved that feature!

These weren’t just fancy gimmicks—they were interactive tools that allowed me to learn efficiently. It felt like having a mini-System Design playground right there on the platform. Plus, the AI mock interviews were a game-changer. Simulating real interview scenarios with AI feedback helped me refine my interview skills in a safe space. The AI interviewer feature was also pocket-friendly; though other courses did provide interview preparation with experts, the cost went up to four hundred dollars per interview.

The other ingredients

The holy grail of System Design learning is being able to apply your knowledge to real-world scenarios. Educative’s “Grokking Modern System Design Interview for Engineers & Managers” delivered on this promise by combining comprehensive coverage of system design, APIs, and coding practices with interactive elements. This blend made the learning process not just informative but also incredibly engaging.

Design Gurus’ course took a practical approach, focusing on System Design and coding patterns specifically tailored for interview preparation. While it lacked the interactive elements of Educative, it still proved valuable by utilizing real-world case studies and pattern-based learning.

Finally, Alex Xu’s “System Design Interview” volumes covered System Design problems and their solutions deeply, making them a great resource for interview prep. The focus here was on detailed textual explanations but with less emphasis on hands-on coding practice.

Key Differences in System Design Learning Resources

Other learning resources

Here is a list of other helpful blogs and resources I found while preparing for my System Design interview:

Conclusion

Choosing the right System Design resource depends on your learning style and goals. Educative’s “Grokking Modern System Design Interview for Engineers & Managers” offers a comprehensive, interactive approach that covers system design principles extensively and provides practical, hands-on tools. This makes it a strong choice for learners at any level. This is the course I would recommend.

Design Gurus’ “Grokking the System Design Interview” focuses on real-world case studies and pattern recognition, making it ideal for interview prep, though it lacks interactive elements. Alex Xu’s “System Design Interview” volumes provide detailed, well-researched content for those who prefer in-depth reading but may not offer the practical engagement some learners need.

Whether you’re a beginner, intermediate, or advanced learner, these resources can help you master System Design and excel in your tech career.

Navigating System Design interviews: What to expect

Fahim ul Haq — Wed, 04 Sep 2024 09:01:10 +0000

The technical hiring process depends heavily on the System Design interview process, especially for roles such as software engineers, system architects, and technical leads. The basics are a given, but you must be familiar with modern trends in your field beyond the surface level.

Most importantly, you must prove your skills and experience by facing off in the System Design interview with confidence and preparation. Big company or small, there is a method to the System Design interview that must be cracked before you walk through the door.

System design interview fundamentals

System Design interviews are built to hone in on your ability to design scalable, efficient, and maintainable systems. There are various factors involved in the process, so here’s a quick rundown of key concepts that you should be clear on before moving forward.

Architecture patterns

Monolithic architecture is a tech reality of the past, and most modern services use microservice architecture. Microservices are applications decomposed into loosely coupled, independently deployable services. They are used in large-scale, complex applications and require frequent updates.

Microservices involve smaller, efficient teams that build independently from the broader system. They have proven resilient, highly scalable, deployable independently, and capable of evolving quickly. Since microservice architecture involves small, autonomous services, each is self-contained and has a separate codebase.

API design

Understanding API design principles in the context of modern distributed systems is important if you are to perform well in a system design interview. You must understand where different services need to communicate effectively and how they interact.

You should be familiar with various APIs, including REST (Representational State Transfer), GraphQL, gRPC, SOAP (Simple Object Access Protocol), and WebSockets. In addition, you must be clear about the different design principles, including consistency, versioning, statelessness, security, error handling, pagination, rate limiting, and documentation.

Knowing how the design process works is also crucial, from identifying resources, defining endpoints, and creating data models to the caching strategies, scaling, and authentication and authorization processes.

Trade-off analysis

Trade-off analysis has everything to do with your ability to make informed decisions when faced with multiple design options. Every System Design choice must be made with caution and a complete understanding of the system's functional and non-functional requirements.

In a System Design interview, you must be prepared to showcase the skill set necessary to guide your trade-offs by knowing when to prioritize certain system requirements over others and why.

Some examples of key trade-offs are the following:

Scalability vs. consistency
Performance vs. complexity
Availability vs. partition tolerance
Cost vs. performance

Modern trends

The rapid pace with which technology evolves waits for no one, and what might have been relevant to know for a System Design interview a couple of years ago might already be outdated. Below, you will find specific concepts that pertain to particular industry developments, on which your knowledge may be judged during a System Design interview.

Cloud-native designs

Cloud-native refers to the approach of building and running applications that take advantage of both built-in security features and the CSP shared responsibility model. They are built to exploit a cloud environment's scale, resilience, cost-efficiency, and portability.

Containerization

Containerization is a core software deployment process that packages an application and its dependencies into a standardized container unit. These containers are consistently deployed across various environments, ensuring the application runs the same no matter where it is executed.

For your System Design interview, you must understand Docker and Kubernetes and how they deploy and manage containerized applications. Concepts such as container orchestration, scaling, and service mesh will surely arise.

Serverless architecture

Serverless architecture is a cloud-native design model in which developers build and run applications without managing infrastructure. The application runs on servers, but it is managed by computing providers and platforms such as AWS, Lambda, Google Cloud Functions, Azure Functions, etc. Be familiar with trade-offs such as cold start latency, throttling, automatic scaling, and execution limits.

CI/CD pipeline

Within cloud-native design, a CI/CD (Continuous Integration/Continuous Deployment) pipeline is a set of automated processes that allow for rapid and reliable development, testing, and deployment of applications. During a System Design interview, it is essential to be informed about tools such as Jenkins, GitLab CI, and CircleCI.

AI/ML integration

Before your System Design interview, you should understand three key points regarding AI/ML integration: model serving, feature stores, and ethical AI.

Model serving is developing a trained machine-learning model available for use in real-world applications. You must understand how to deploy and scale ML models in production, which involves model versioning, monitoring, and A/B testing.

In AI/ML integration, a feature store is a centralized repository designed to manage, store, and consistently serve ML features across the entire ML lifecycle. In 2024, tools like Feast and Tecton are being pushed more to the forefront of operations.

With the rapid integration of AI and machine learning in tech industry operations, acute awareness and knowledge of ethical AI are crucial. It is a topic of contention that is bound to come up in a System Design interview. Ethical AI in AI/ML integration is designing, developing, and deploying AI systems that align with moral principles. Bias mitigation and explainability must be understood thoroughly.

Security and privacy

In 2024, there is a growing concern regarding data breaches, cyber threats and regulatory compliance, and knowing about strong authentication mechanisms is important to know for a System Design interview.

Data encryption strategies at rest and in transit, understanding TLS, end-to-end encryption, and other key management practices are just some of the concepts you must be proficient in. In regard to data privacy, you must be aware of global and regional data protection laws like GDPR, CCPA, and HIPPA.

Modern authentication protocols to be familiar with include OAuth 2.0, OpenID Connect, and SAML. Moreover, RBAC (Role-Based Access Control) and a zero trust approach (no entity inside or outside a network is trusted) are other concepts to have a clear grasp on.

System design interview structure

System design interviews have grown in complexity, reflecting the advanced nature of modern software systems. Here is a brief overview of specific interview components you should expect, and prepare for.

Open-ended questions

In System Design interviews, open-ended questions function to assess your critical thinking abilities, consider trade-offs, and design scalable, maintainable systems.

Ambiguity and scope As the term suggests, open-ended questions are broad and lack specific details to give the candidate space to showcase their skill set. You won’t get further guidance beyond the main premise, for example, “Decide a social media platform.” How you go about it will be up to you.

The interviewer will evaluate how you handle the problem with limited guidance, what questions you ask in response, and your ability to transform the problem into something more manageable within a given timeframe.

Exploring multiple solutions Some questions you will be asked will not have a single correct answer. The interviewer will judge whether you have the capacity to think outside the box and to what extent you explore various architectural choices while considering their pros and cons.

Employing a comparison strategy, such as ‘microservices vs. monolithic architectures,’ may help streamline your answer and thoroughly explain your reasoning.

Whiteboarding/Diagramming

To effectively communicate your thought process and ideas, visuals matter and that’s what whiteboard and diagramming provide. The objective is to break down complex ideas, and convey a structured thought process to the interviewers.

Whiteboarding and diagramming also allow for real-time collaboration as interviewers can ask questions, and you can further build on the ideas in your answers. Remember to start simple, and as you build your diagram in iterations, you clearly label all components on display.

Evaluation criteria

Here’s a breakdown of key evaluation criteria you will be judged on during a System Design interview. Through these points, you can identify the areas where your weaknesses lie and address them.

Clarity of thought
How well you understand what’s being asked and your clarity with the requirements of the system. This includes both functional and non-functional requirements. The more organized you are, the better you will be able to identify and articulate assumptions and constraints related to System Design.
Design approach and architecture
Your ability to create a high-level design that outlines major components and interactions will be evaluated–this includes system diagrams, data flow, and component interactions. Scalability is another criterion and involves how well the design scales with increased load. In addition, your design’s ability to promote flexibility is another important factor.
Efficiency and performance
The system you design must showcase minimized latency and optimization throughout in the system. How well you implement caching mechanisms, and your knowledge of caching strategies to reduce load and improve performance will also be evaluated.
Communication
Your ability to communicate your ideas clearly and logically will allow the interviewers to comprehend your knowledge, skills, and confidence. In short, your expertise needs a leg to stand on, and how well you express your answers will play a crucial role in acing the System Design interview.

Final words

You will find how System Design interviews in 2024 blend foundational knowledge, practical experience, and a sharp awareness of modern trends. While you are in the middle of your preparation process, it is necessary to incorporate a mix of study, practice, real-world experience, and honing your communication skills.

Educative’s System Design Interview Prep Handbook is available to help streamline your study routine. It encompasses all the knowledge bases you need to cover to succeed; problem strategies, as well as real-world design process simulations.

The right time for beginner coders to start projects

Hunter Johnson — Tue, 21 May 2024 09:19:31 +0000

I'm Fahim, a software developer turned tech founder. This article is part of my series: The Developer’s Launchpad. I'll share my top lessons, hacks, and best practices for learning how to code and launching a new career — things I wish I would've known earlier in my journey. If you're starting out your own coding journey, this series is for you.

When I started my first coding project in undergrad, I was incredibly excited. Being able to apply my knowledge toward a tangible outcome was a milestone in my (and any new coder's) learning journey.

I was guided into my first coding project within the structure of an academic program, but those who aren't may wonder:

When should I start my first project, and what's the best way to do it?

Taking on coding projects is essential to your journey toward programming proficiency. However, starting too soon in the learning process can hinder your progress. To set up for success with projects, you must first understand foundational programming concepts and when to apply them.

Today, I will discuss the right time to start doing your coding projects and the most effective and efficient way to learn through them.

Let's jump right in!

Don't start too early on your coding projects

Starting too early on a coding project can cause setbacks and frustration because you're missing a solid understanding of the foundational concepts involved. Imagine building a house without some sort of blueprint or foundation—it is bound to collapse. Learning the fundamentals first will give you a heads-up and solve any potential issues that may arise as you start to build a house.

When I was a student learning computer science fundamentals, we had to cover the core pillars of programming before a project was assigned for us to do independently or in teams.

This sequential learning makes sense. After all, if I didn't understand the core concepts of programming such as variables, data types, conditions, structures, etc., how would I know how to build something using them? How would I fix errors without knowing the root of it? Taking the time to understand programming concepts and how they work before diving into a project not only solidified my learning, but also empowered me to get creative with what I knew and have fun in the process.

When you thoroughly understand each component of a project, you'll see how everything works together, preparing you to troubleshoot any potential issues along the way. This will give you the confidence to build a strong foundation for success.

The sweet spot to start your first coding project

So when exactly should you start your first project?

When you've understood the foundational concepts and building blocks of a new skill, that is the time to start building things with it in order to strengthen that skill.

Having these foundational skills by the time you start your first beginner-friendly project is crucial as it will prepare you to navigate your way through your first project:

Doing this allows you to reach what researchers call "flow state." Occurring when your skills match the challenge of the task, flow state is when you are fully immersed in a task in a focused, productive way.

"Enjoyment appears at the boundary between boredom and anxiety, when the challenges are just balanced with the person's capacity to act." — Mihaly Csikszentmihalyi, 'Flow'

Start with doing small projects, then gradually build up to more complex ones. Learning to code is an iterative process. Each project you tackle should get bigger and have more challenges than the previous one as you continue to learn more advanced concepts.

The value of projects in the learning process

Coding projects are invaluable for bridging the gap between theoretical knowledge and real-world scenarios.

Building something with code can help you internalize how programming concepts work in a much deeper way than just reading about it. When you build something, you're not just memorizing the syntax or concept—you're implementing skills in context and solidifying your understanding. To add to that, hands-on learning that comes with projects will increase your knowledge retention.

Projects also give you a chance to demonstrate your ability to perform coding tasks and showcase your abilities to potential employers. You can include projects you've worked on in your resume or developer portfolio to make your skills even more discoverable in the job market.

Every project, big or small, presents an opportunity for creativity, continuous learning, and improvement—enabling you to progress fast in your learning.

If you're not sure where to start, remember that projects should serve you and your goals. You can find countless projects online or in textbooks, but when you're choosing them, aim for ones that match your skill level in a topic that interests you.

For example, consider Piper, a dental assistant looking to become a cybersecurity engineer. Piper is passionate about cyber security, so she plans a coding project where she can learn to detect a cyber attack. Because she's already familiarized herself with the prerequisites and technologies mentioned in the project overview, she's prepared to complete the project to the finish line and claim her certificate of completion. She can then add this project to her portfolio and share it with peers and potential employers—getting her one step closer to her dream job.

Preparing for real-world developer problems

Once you've understood the fundamentals, there's no better time than the present to begin a project. Once you get started with projects, you'll be building skills you need to tackle real-world problems at work or in your free time — from coding to troubleshooting to task completion.

The main difference between projects and real-world scenarios? In a real-world scenario, you're often solving unstructured problems where solutions are not laid out in a step-by-step manner, as opposed to the guided instructions that come with projects. As you become a more proficient coder, you will be able to solve problems independently without being overly reliant on guided instructions — but until then, the guidance that comes with projects are indispensable to getting you first-hand experience with the programming skills and processes that are necessary to software development.

When you're ready to start building, you can find hands-on, beginner-friendly projects in our Learn to Code catalog at Educative.

Why learning to code is still important in an AI-driven world

Hunter Johnson — Thu, 16 May 2024 09:35:39 +0000

I'm Fahim, a software developer turned tech founder. This article is part of my series: The Developer’s Launchpad. I'll share my top lessons, hacks, and best practices for learning how to code and launching a new career — things I wish I would've known earlier in my journey. If you're starting out your own coding journey, this series is for you.

As a developer, I understand the investment of time and energy that goes into learning how to code. With Generative AI on the rise and recent layoffs, I have seen the impact on how humans approach software development today. Developers are now using AI to automate repetitive tasks like code reviews, debugging, and testing to streamline their workflow so they can focus on more meaningful and innovative work. And now with the tech lay-offs we've been seeing lately since AI has become more prevalent, it can be worrisome to consider choosing the path of becoming a developer. With all this going on, it makes sense to wonder if learning to code is still worth the investment.

Today, I'll discuss why it's still worth learning to code in the AI era. First, we'll go over how learning to code will empower you, followed by AI's impact on the job market, and then transition to the value of having human software developers for AI collaboration.

Learning to code will empower you (especially in the AI era)

In the age of AI, learning to code has become more crucial than ever as it prepares individuals to become strong in critical and logical thinking across diverse industries such as technology, healthcare, education, etc. Knowing how to code allows you to become effective at solving problems when it comes to communicating with technology. The key to good problem-solving is the ability to think outside the box, and this requires your human imagination. Like AI being trained to think like a human, coding trains us to think like a computer — which is a very valuable skill. Continuously learning the language of a computer is not only a great way to add value to your skills, but also to understand the nuances of how software is built, and how a computer thinks, which opens up opportunities for seamless collaborations with AI.

As you're starting your learning to code journey, it is best to gain strong familiarity and competency with the fundamentals of programming first, like learning how to think in algorithms.

When it comes to traditional methods of learning, there are certain limitations, such as not having courses tailored to individual interests or goals. Due to this, AI-powered learning platforms are evolving to encourage enhanced learning outcomes through utilizing data-driven personalized experiences. Courses are tailored to your specific interests and career goals so that AI can recommend the right learning path for you, empowering you further.

AI affects the job market

AI technology has the potential to reshape the job market given its ability to enhance productivity through task automation. This could raise concerns for those who are seeking to land a career in the tech sector. However, this actually enables workers to focus on more creative high-value activities rather than repetitive and manual labor. Therefore, AI is in no position to fully replace our jobs.

In fact, AI will open the door for unexplored areas in our evolving world of technology, providing more job opportunities. For example, in the agriculture sector , AI can optimize the workflow of managing crops, monitor the health of plants, and analyze weather conditions. This allows for making informed decisions that maximize sustainability.

Let's remember the impact of calculators and how people used them to achieve more meaningful complex tasks while reducing tedious work. Companies are on the lookout for professionals who can use AI to automate tasks more efficiently in their workflow, encouraging more human-AI collaborations. Learning to code gives you a headstart to demonstrate technical proficiency and problem-solving abilities in order to stay current in the job market.

We still need (human) developers

Despite AI's advancements, the need for human software developers will not go away. There are certain nuances of human ingenuity when it comes to writing software, and AI has not simulated those. While AI can be an effective assistant for writing code, it still has its own limitations such as not fully replicating human intelligence and creativity. There are many cases where AI tools like ChatGPT have made mistakes when it comes to solving programming problems such as generating inaccurate code. Due to cases like this, AI needs supervision and critical thinking from humans. By learning how to code, you will equip yourself with the right skills for detecting inaccuracies and discrepancies in the outputs of AI.

For one, AI lacks the leadership abilities and creativity that bring immense value and advantages in many areas of work and life. Developers are problem-solvers at heart.

Additionally, human empathy is needed to create great software.

"Programs are meant to be read by humans and only incidentally for computers to execute." — Harold Abelson and Gerald Jay Sussman, 'Structure and Interpretation of Computer Programs'

This quote encourages us to write code that is structured well and easy to understand, but it also emphasizes that we write code for humans — not computers. Only humans will have this capacity to embody empathy to understand a user's needs, and artistic ability when it comes to coming up with solutions to solve a coding problem. The world needs more people who can code beyond the capabilities of AI.

Championing the qualities of curiosity, ingenuity, and creative problem-solving will make learning to code an exciting and fulfilling journey.

Finally, as our world becomes increasingly reliant on using technology, the demand for coding skills will heighten. Acquiring the skills needed in order to know how to program can open up a wide range of career opportunities. As you continue to sharpen your coding skills, you become much more proficient in programming. Proficient programmers have the ability to customize AI solutions to improve its overall effectiveness so that technology remains relevant and valuable.

There's no better time than now to learn

The best way to know when you should learn to code is simply by trying it out through direct experience. With all the learning resources out there, learning to code has become more accessible than ever. Becoming proficient in programming will prepare you to adapt to the evolving world of AI-driven technology.

"AI won't replace programmers, but it will become an essential tool in their arsenal. It's about empowering humans to do more, not do less." — Satya Nadella, CEO of Microsoft

At the end of the day, AI isn't going to replace someone's job; a human who knows how to work with AI will. When you are learning to code, you are empowering yourself to be equipped to work with intelligent machines. The investment is absolutely worth it.

Best of luck and happy learning!

6 hard truths about learning to code in 2024

Hunter Johnson — Thu, 09 May 2024 12:23:04 +0000

I’m Fahim, a software developer turned tech founder. This article is part of my series: The Developer’s Launchpad. I’ll share my top lessons, hacks, and best practices for learning how to code and launching a new career — things I wish I would’ve known earlier in my journey. If you’re starting out your own coding journey, this series is for you.

Considering learning coding?

I’m glad to hear it. Software development is an incredibly rewarding career. 15+ years in, and I’m still amazed by the way the field has evolved — both in how we develop applications, and how those applications have improved to serve people better.

A lot has changed since I learned to code 20+ years ago, but the essentials remain the same. You still need problem-solving skills and a commitment to lifelong learning. Some factors are new though… like the prevalence of AI and what it means for new coders.

I wanted to be frank about what new coders can expect in their coding journey, so here are 6 hard truths about learning to code in 2024.

6 hard truths about learning to code

1. It will take time

Becoming a coder doesn’t have to take years. But how fast you progress depends on your circumstances.

Some people need more time than others either because of their learning style, or because of their availability to study.

If you’re self-taught, I’ve estimated that it can take as little as 6–9 months to be learn to code if you can commit a consistent schedule of 25 hours/week — but again, results will vary.

Even those who graduate from coding bootcamps and 4-year degrees can still have gaps in understanding that they’ll have to work on in their spare time.

Overall, just know that the amount of time it takes you to get comfortable coding may be longer than you anticipated. There’s a lot to learn, so try and be realistic about your goals and expectations. Overall, it’s better to be consistent and learn a little at a time, than to cram your learning into short bursts.

Tip: Figure out what learning strategies are effective for you, and use them!

2. You will get stuck

At several points, you’re going to get stuck before certain concepts “click” for you.

Whether it’s a bug or an algorithm that you haven’t mastered, hitting roadblocks is entirely expected and is no cause for concern. A bit of fog on a hiking trail doesn’t deter hikers, so a roadblock shouldn’t stop your learning either. A roadblock is only a temporary challenge and no reason to turn back.

If you’re stuck, it helps to talk out your issue with others or even take a break from the problem at hand. Whether you’re stepping away from the problem for a few hours or a few days, coming back with fresh eyes can help you spot things you missed before.

Getting stuck can feel like learning stagnation. For some, this is very discouraging (and it’s one of the reasons people quit learning to code). But just as a bicyclist moves slowly over a hilltop before gliding effortlessly down, just know that you’ll be moving soon enough after you’re stuck too.

Everyone has these moments — it’s a natural part of the learning process, so don’t give up!

3. The learning never stops

The thing about learning programming is… the learning never stops.

Constant advancements in technology mean developers need to update their skills to stay relevant.

Constant learning is actually one of the most exciting things about being a programmer. From new ways of building software to new workflows, programmers always embrace innovation, and it helps us do our work better.

So how can you navigate a field that constantly demands that you evolve with it?

This idea can be overwhelming for some, but with the right approach, you can actually enjoy the fact that you’re in a field where there are constant opportunities to improve. Being open and eager to learn and grow is what we call a growth mindset, and is a quality I look for when hiring developers.

In addition, you’ll need discipline. There are often opportunities to upskill with classes and training through your employer, but generally, every developer has to be able to be a self-taught developer who makes time in their schedule to study and practice new skills.

That said, developers often suffer from burnout — and learning burnout is part of this. While you should have discipline, try and pace yourself and have realistic learning goals.

4. You will make mistakes

As with learning any new skill, your learning curve is going to consist of plenty of mistakes. It can be frustrating at some point, but mistakes are actually learning opportunities — and you should expect to encounter them on your road to coding proficiency.

Whether it’s a syntax error or an oversight, even skilled developers make mistakes, so don’t be too hard on yourself.

Instead, embrace mistakes as milestones in your learning journey. They reveal gaps in your understanding so that you know where to focus your studies. Indeed, you can’t truly master programming if you’re not ok with making mistakes.

If you’re NOT making mistakes, that’s likely an indication that you’re not engaging in enough of the hands-on practice that’s necessary to effectively learn to code.

5. You’ll keep having to clean up messes!

Mistakes imply someone has made a misstep, and has actively missed a detail or forgotten something. But then we have the larger umbrella of coding bugs.

Bugs in programming are issues in your code that cause unexpected or undesirable results. They can be caused by many things. In some cases, it can be your own human error (for example, perhaps you misspelled something in your code). But other times, bugs can arise from factors entirely outside of your control. For both of these reasons, encountering bugs is inevitable.

However, finding and resolving these issues is an essential skill we call “debugging.” Developers spend a great deal of time debugging.

Debugging can feel a little messy. When you’re dealing with complex software systems, there are many factors that can lead to bugs — from an issue in your codebase, to an issue in third-party dependencies that is affecting your software. With so many factors at play, identifying the root of a problem can be a little maddening.

Over time, you will get better at debugging, and you may even find it rewarding. I know I’ve personally loved the “aha” moments that came from finally resolving a bug that’s been plaguing my code.

To help you navigate debugging, I recently wrote a blog post with debugging tips for beginners.

6. Eventually, you’ll need to learn to work with AI

Many new coders are worried that the rise of AI will lead to a fall in developer demand. I’ve already debunked this concern in a separate post: AI can’t replace developers anytime soon, for a variety of reasons.

That said, the presence of AI is going to change expectations for developers: namely, learning AI skills is becoming a must.

AI skills can range to include:

Less technical skills, like prompt engineering to learn how to leverage Generative AI
Utilizing frameworks like LangChain to develop apps with LLMs
More advanced skills like AI engineering

Don’t worry too much about learning AI skills if you’re a total beginner. The best way to start is to start small with skills like prompt engineering, so that you can effectively use Generative AI tools to both learn and code.

Using tools like ChatGPT as a learning assistant can help streamline your research and learning. But Generative AI tools are not immune to errors — so you should try to fact-check their responses by doing some research of your own.

Once you’re in the workforce, AI tools will be amazing assistants that help reduce tedium in your work. That said, you should wait until you truly learn how to code on your own before using Generative AI for coding. Generative AI tools require human guidance and supervision. You need your own knowledge to be able to craft prompts for an effective output — and to properly review and edit those outputs (trust me, they need editing).

The most important thing?

One thing hasn’t changed since I started learning to code:

Developers learn best by doing.

Make sure you spend adequate time practicing coding. Even if you make mistakes, or get lost along the way, hands-on practice is the best way to truly internalize programming concepts and apply them to real-world scenarios.

You can learn everything you need to go from your first line of code to your first job with Educative’s beginner-friendly Learn to Code resources. You’ll find courses, Skill Paths, and projects with built-in coding playgrounds and AI-assisted feedback for personalized, hands-on learning.

Liked this post? Visit the Educative blog for more articles from The Developer’s Launchpad.

Zen of debugging: 5 tips for beginners

Hunter Johnson — Thu, 02 May 2024 10:31:13 +0000

I'm Fahim, a software developer turned tech founder. This article is part of my series: The Developer’s Launchpad. I'll share my top lessons, hacks, and best practices for learning how to code and launching a new career — things I wish I would've known earlier in my journey. If you're starting out your own coding journey, this series is for you.

Bugs — they happen to the best of us.

A bug is any issue in your code that is causing unexpected or undesired results. Bugs are an inevitable part of coding. As a result, learning how to resolve bugs (i.e. debugging) is an essential skill for your long-term success.

In my experience, the best programmers are also the best at debugging. Learning to debug effectively will help you better understand coding concepts, get more familiar with your code, and — in the long run — will make you more efficient at work.

If you're a complete beginner or an early-stage coder, I'll be sharing some perspectives to help you hit the ground running and become more effective at debugging.

Debugging and development

Let's do a quick rundown on bugs first.

Getting comfortable with bugs

In programming lore, the first computer "bug" was supposedly caused by a moth stuck in a computer at Harvard University.

If you don't like insects, you can at least find relief in the fact that most coding bugs don't involve actual bugs. That said, debugging can be far more complicated than removing a misplaced insect.

Software development is a complex process that works with various interconnected lines of code. Even if you know a given codebase, you may still inadvertently make a change that negatively affects the entire system (just as trying a new ingredient in a trusted recipe can unexpectedly yield negative results). You may have a bug arise simply because it's being run on a different hardware setup for which it hasn't been made compatible. Better yet, even if you didn't do anything yourself, your software can suffer from bugs that originate from their _external_dependencies, such as third-party libraries.

In any case, bugs are inevitable. Whether you like it or not, you'll have to get comfortable with them.

Ideally, you should hopefully find that you even enjoy debugging. There is certainly a great reward that comes with finally finding the source of the issues plaguing your code. It can be a challenge, but if you're curious, you'll only come out the other side having a stronger understanding of your code (and stronger problem-solving skills).

Oh, the bugs you'll find!

There are various types of software bugs.

Many bugs fall into two categories: syntax errors and semantic errors.

Syntax errors have to do with mistakes in your code's syntax, including spelling, punctuation, improper naming, or omitting definitions for variables. On the other hand, semantic errors have to do with meaning. Semantic errors don't stop the program from running — rather, the program does not operate as intended.

That said, bugs can also be grouped into other categories (some of which overlap with syntax and semantic errors):

Runtime errors: Invalid operations or insufficient memory can cause crashes or unexpected behaviors during the execution of a program.
Compilation errors: With compiled languages, these errors interfere with code being converted into executable form. They can be caused by syntax errors, types mismatches, etc.
Logic errors: These errors are correct in syntax but don't perform the intended operation, leading to incorrect output or behavior.
Concurrency bugs: These occur when the timing and sequence of executing concurrent or parallel programming techniques lead to unpredictable or incorrect outcomes.
Resource leaks: These happen when a program fails to release resources, like memory, file handles, or network connections.
Security vulnerabilities: These involve weaknesses that can be exploited to cause damage or gain unauthorized access.
Interface bugs: These stem from problems in the interaction between parts within the software, or between the software and external systems or hardware.

You won't encounter many of these bugs until you deal with more complex software. However, it helps to acquaint yourself with the different types, so you can discern the type that you're dealing with.

You're only human

Sometimes bugs will arise as a result of your human flaws, and that is okay!

I've experienced this hundreds of times. At first I think the code is right, and I'm convinced the problem is the compiler or the language... then I eventually realize the problem was me.

We're human and we make human errors, whether they're syntax errors or forgetting some nuances about our given programming language.

Keep calm, and try to have a sense of humor about it. It’s all part of the process!

If you're stuck on a bug and don't know what's gone wrong, it can be frustrating.

But it will happen… so here are some helpful strategies you can try:

1. Understand the problem

Ask yourself these questions to understand your problem:

What should the code be doing?
What is the code actually doing? What are the conditions under which the unwanted behavior occurs?
Are there any error messages that indicate specific problems?
Do you know where the bug is originating? Have you broken the code down to isolate the section that contains the bug?

Be resourceful as you try to understand what's gone wrong. Make sure that you've been correctly using any functions, methods, or features by referencing documentation and other resources.

2. Talk to yourself aloud

Calmly walk yourself through the problem at hand and how you've approached it. As you explain aloud, you may discover assumptions you've made or details you've missed along the way. This strategy is effective for many developers, and is what we call "rubber duck debugging." (Rubber ducks aren't necessary, but they do add a playful touch.)

3. Use debugging tools

There are various tools that will help you debug, and you should use them when you can! You can use specialized debugging software or built-in language tools like Python’s pdb module.
Many integrated development environments (IDEs) include debugging tools as well.

4. Seek feedback

The coding community is very willing to share knowledge and give feedback, so don't hesitate to ask for help from other developers. It can be as simple as posting your problem in an online forum (with the bonus of knowing your query could help other coders in a similar situation).

5. (Last but not least) … Sleep on it

Sometimes, all it takes to solve what seems to be an insurmountable problem is to look at it with fresh eyes. If you’re stuck on a problem and don't know how to move forward, sometimes the best thing to do is walk away. Just disconnect from the problem entirely. If it comes down to it, sleep on it.

Patience, persistence, & curiosity

Remember, debugging isn't about speed. It requires patience, persistence, curiosity, and attention to detail.

Debugging is one of many problem-solving processes that are the foundation of software development.

The better you get at debugging, the better a coder you'll be. Over time, I hope you even learn to enjoy the debugging process.

As a reminder, you can find everything you need to go from your first line of code to your first job with Educative's Learn to Code resources — courses, Skill Paths, and projects specifically for beginners.

Do I need a 4-year degree to get a developer job?

Hunter Johnson — Tue, 30 Apr 2024 12:28:37 +0000

I'm Fahim, a software developer turned tech founder. This article is part of my series: The Developer’s Launchpad. I'll share my top lessons, hacks, and best practices for learning how to code and launching a new career — things I wish I would've known earlier in my journey. If you're starting out your own coding journey, this series is for you.

With so many online courses, bootcamps, and other resources for learning to code available today, I often get asked this question:

Do I even need a degree to get a developer job?

I got a Computer Science degree before I landed my first job as a software engineer. For me, the degree was certainly worth it — and I'll share what I gained from the experience today. However, things have changed significantly since I was a programming student 25 years ago. The upshot? Getting a degree is no longer necessary to start a coding career.

If you're on the fence about pursuing a programming degree, I'll share my two cents on making that decision — and some tips for success if you choose not to take the academic path.

Was my 4-year degree worth it?

Today I'm a tech founder and CEO. Before that, I had the honor of being a software engineer at both Microsoft and Facebook. But many tech founders and CEOs are self-taught — including ones who learned to program when I did in the late 90's and early 2000’s.

So, if other people got to similar places in their career without a degree, was getting one worth it?

I have two answers for this:

1). For me personally, yes, it was absolutely worth it.

Among other benefits, my university years gave me a strong foundation for the rest of my career. It also gave me a head start with skills that I wouldn't have been able to develop on my own as easily, such as teamwork and collaboration.

2). It was worth it because of my circumstances.

If my circumstances were different, I might have done things differently. 25 years ago, there was no guarantee that I would be able to get a job without a degree. This was especially the case because my goal was to move to work in the US, and the immigration requirements included a university education.

If I were learning to program today, I might choose not to get a degree.

20 years ago, many companies required (or at least preferred) a 4-year degree to become a developer. But since then, those requirements have relaxed, and you can become a programmer without a degree.

So, while it was personally worth it to get a degree, it's definitely an optional route for anyone aspiring to learn to code today. Let's consider some of the pros and cons of the academic route.

Benefits of a 4-year degree

4-year degrees in academic programs have various benefits.

When I started university, I didn't know much about programming. I had learned some rudimentary programming in high school, and managed to pass some exams through rote memorization.

It was in undergrad when I fully grasped programming though — and fell in love with it. Along the way, I gained many skills, built a network, and found mentors through my professors.

We started doing individual assignments and projects, then moved on to projects that simply couldn't be built alone (similar to the real world). These group projects were invaluable opportunities for us to see what it's like to work on a team. We started using collaboration tools and understood how to communicate with each other and work through disagreements.

This being said, I don't mean these skills CAN'T be learned on your own accord. Universities do facilitate these opportunities through their requirements and curriculum. However, outside of a university, you need to take it upon yourself to find opportunities to collaborate with others (for example, contributing to open-source projects is one great way to do that).

Why might you NOT choose to get a degree?

Despite their benefits, university programs have some very particular requirements. Whether or not a degree is right for you will depend on a few factors.

First of all, they're expensive. While there are some opportunities for scholarships and financial aid, not everybody is able to find the resources to pay for tuition. Jumping into a program and taking out loans can be a very valid cause for hesitation, especially if you're unsure that programming will be a good fit for you.

University programs also require a huge time investment. Learning to code in a 4-year program is like a full-time job in and of itself. Regardless, learning programming takes a lot of time, but if you're a student with other commitments, like family, work, or otherwise, your schedule will feel tight (and some things may have to be put on the backburner).

While some programs can be flexible and self-paced, many traditional programs are not, and this can make it hard to accommodate every student's learning needs. University programs will have you learn set topics in rigid timeframes. Some students may need more time to get comfortable with one topic before advancing with the curriculum. However, because they can't control the pace of their program, many students end up fumbling through topics with a weaker understanding (which, unfortunately, does come back to haunt them).

These are among the many factors that will affect your decision to commit to a university program. If any of these factors apply to you, there's no shortage of alternative resources for learning to code today.

Alternatives to a computer science degree

If you're not feeling confident that a computer science degree is right for you, there are alternative routes through which you can learn to code.

Two main options come to mind.

The self-taught route

Being self-taught means that you're leading yourself through your learning journey, as opposed to being enrolled in a coding bootcamp or university program. It's easier than ever to be self-taught now, as you can learn from various resources, such as online courses, tutorials, and books.

Being self-taught has benefits — as an independent learner, you can have full flexibility to decide when and how you learn the necessary material. While some resources are paid, you can also find free materials to learn from.

The bootcamp route

Like university programs, coding bootcamps offer a structured curriculum focused on all the programming skills you need to be "job ready." They can be online or in-person. Compared to university programs, they are accelerated programs that can teach you all the relevant skills you need in a shorter period of time than in a university program.

Most bootcamps are paid, but they are a great option if you're motivated by deadlines and want the structure of a set curriculum.

At the end of the day, every developer has to be self-taught, because you'll always need to learn new skills to keep up with the industry. So whichever of these options you choose, you'll also need to develop an independent learning practice at some point by leveraging all the resources available out there.

If you have the passion, but don't have the means to get a degree, there's nothing stopping you from becoming a programmer.

In fact, depending on how much time you have to commit to learning, you could even start your developer career earlier than you would if you were confined to a 4-year program. Depending on when you start, you could even land your first developer job in 1-2 years.

If you don't need a degree, what DO you need?

It's important to start your programming education by building a strong basis in logic and problem-solving. Problem-solving is the basis of programming, and learning how to problem-solve in sequential steps is what we mean when we say "learn to think like a programmer" at Educative. Even if you're going to be in a university program, it's a good idea to start with this strong basis, as all of the programming skills you learn will build atop logical problem-solving.

As I mentioned earlier, getting a degree has some great benefits — especially in facilitating opportunities to work on projects and collaborate. If you're not getting a degree, you need to seek opportunities to build projects and work with others.

If I had to choose between either skill when hiring a self-taught programmer, I'd choose proven ability to build a product over working with others. At the end of the day, teamwork skills can be gained on the job, but to hit the ground running, a developer needs to come in with the initiative and drive to be able to build and complete projects. Be sure to build your portfolio with a variety of projects with varying difficulties. Whether you build websites, mobile apps, or contribute to open-source projects, a strong portfolio will help you get visibility and gain notice from potential employers.

Whatever you do, start early if you can

If you have the opportunity and the resources to get a 4-year degree, and you want to learn in an academic environment, go for it. There are certainly many benefits to reap.

That said, if you want to become a programmer, the degree is not required.

University programs aren't the right choice for everyone. Luckily, there are so many alternatives to traditional academic routes now, and companies are happy to employ you whether you're self-taught or coming out of Stanford.

However you choose to learn, start early, practice often, and don't give up.

As a reminder, you can find online courses, Skill Paths, and projects specifically for beginners on Educative. Check out our Learn to Code resources to learn everything you need to go from your first line of code to your first job.

Happy learning!

7 reasons people quit learning to code (& how to avoid them)

Hunter Johnson — Fri, 26 Apr 2024 09:41:30 +0000

I'm Fahim, a software developer turned tech founder. This article is part of my series: The Developer’s Launchpad. I'll share my top lessons, hacks, and best practices for learning how to code and launching a new career — things I wish I would've known earlier in my journey. If you're starting out your own coding journey, this series is for you.

So you decide to learn to code… and inevitably, you encounter an obstacle along the way.

It happens to the best of developers. I had a fair share myself. But for many aspiring coders, an obstacle can be so discouraging and frustrating that they quit pursuing their goal of becoming a coder.

Learning to code is not easy: challenges are a normal part of the journey. In an ideal world, the only reason an aspiring coder would quit is because they realized coding isn't aligned with their interests. But that's not realistic. In fact, many people quit learning due to obstacles that can indeed be overcome.

Today, I'll share some of the top reasons people quit learning to code — and some tips or perspectives for overcoming them.

Top 7 reasons people quit learning to code

1. Impatience

Many people quit learning to code because they get impatient. If you're not patient, you'll have a difficult time tolerating the inevitable moments when you get stuck.

Learning to code is a marathon, not a sprint. It takes time, effort, and discipline. It's important to realize this and be realistic when you're in your learning process.

If it's taking a while for you to master something, it's because it should take time — it's not because your brain isn't wired a certain way.

To help manage impatience, level your expectations and set realistic goals and deadlines. Break those goals into small steps, and celebrate any progress you make (no matter how small).

2. Fear of failure

If you're a bit of a perfectionist, and you're starting your learning to code journey, it's a great time to work on developing a healthy relationship with making mistakes.

The road to coding success is lined with mistakes — and there's no room for fear of failure along the way. While mistakes can be frustrating, they are really just learning opportunities. Both new and experienced coders can make trivial mistakes, but it doesn't reflect on their ability to be great developers.

In fact, I would argue that the opposite is true: great developers make mistakes all the time, in no small part due to the fact that they are challenging themselves, taking risks, and learning through experience.

To help you stay resilient and persistent in your learning journey, you'll want to develop a growth mindset, in which you embrace little failures as opportunities for growth.

In my book, the only real failure is quitting learning to code just because of a mistake you made.

Check out my recent post where I go deeper into why mastering programming requires failing.

3. Imposter syndrome

Imposter syndrome is more common than many realize — and it affects experienced and aspiring developers alike.

Imposter syndrome is characterized by a debilitating doubt of one's skills and abilities. This doubt is so severe that people often feel like an "imposter" or a "fake" (no matter how successful they are).

To overcome imposter syndrome, you'll need to make a point to track your accomplishments, and engage in positive self-talk. It can also help to connect with like-minded individuals and beginners (but you should also be careful not to compare yourself to your peers).

4. Lack of a structured learning plan

I've seen many enthusiastic learners run out of steam simply because a lack of structured learning left them feeling aimless, without a clear perception of the gradual progress they were in fact making. A structured learning plan can help us eliminate stress and feel more confident and in control of our coding goals.

This risk is particularly pertinent to self-taught coders, who — unlike those in bootcamps or university programs — bear the added weight of guiding themselves through learning topics, resources, and activities. Until they find their preferred learning resources, self-taught coders may also find themselves spending significant time browsing resources and tutorials which may lead to wasted time and (information overload.

If you're a self-taught coder, seek out courses or platforms that offer a clear, step-by-step curriculum — or, create a structured curriculum plan for yourself. It's important that a learning plan builds upon each concept progressively. For example, you shouldn't dive into a programming language without a good basis in logical thinking and problem-solving.

Looking for online learning resources? Check out Educative’s Learn to Code courses and structured Skill Paths, created by PhDs and industry experts to teach you exactly what you need to know, in the right order.

5. Coding anxiety

There are many reasons why people may have an anxious reaction toward learning to code. It's not easy to deal with anxiety, and when you don't find a way around it, you may feel you have no other choice but to give up.

Coding anxiety is common among many coders. There are various different roots to coding anxieties, ranging from overwhelm about how much there is to learn to performance anxiety. Once you know what your particular anxieties are, you can take steps to address them and find tools to manage them — you weren’t the first person to have that anxiety, and you won’t be the last!

Check out my recent blog post for an overview of common coding anxieties.

6. Misaligned learning methods

We're lucky that we have so many methods for learning to code today. However, whether it's a professor, a bootcamp, or an online course, not every resource will help students equally.

Many students quit learning to code because they're fighting an uphill battle with learning resources that don't suit their learning styles and needs. An audiovisual learner will struggle to grasp concepts from a textbook, while a kinetic learner will not solidify concepts until they have the opportunity to get hands-on with them. Similarly, a given lecturer's teaching style may not suit every one of their students.

If you're experiencing a lull with your learning, don't give up. Check in with your learning needs and see how you can incorporate them into your coding journey. It's possible that you may need to explore other learning resources, or use a mix of resources to optimize your learning experience.

Keep in mind that getting hands-on experience with coding is going to be essential — without it, you won't internalize any concepts or get the chance to learn from your mistakes!

7. Burnout

Sometimes we're so set on a goal that we're ready to fire all engines to achieve it. That passion is wonderful, but you can end up overexerting yourself to the point of burnout (i.e., blowing out an engine).

The risks of burnout are real. You can develop cynicism, anxiety, and negative associations toward something you once were excited about — and it can take quite some time to recover from it.

To avoid burnout, you'll need to pace yourself and learn to take breaks. Learning to code is a long and arduous climb — you will feel out of breath sometimes, and that's ok. But with clear goals and realistic milestones, you will reach the summit.

Staying on course

If you've decided to learn to code and you're struggling, know that you're in good company.

There are many skilled coders who have contemplated quitting at some point in their learning journey. The only defining qualities of those successful developers is that they persisted.

Everyone faces a unique set of circumstances, and I surely haven't covered all the reasons that people quit learning to code today. Whatever your obstacles are, understanding them is the first step to finding strategies to overcome them.

As a reminder, you can find online courses, Skill Paths, and projects specifically for beginners on Educative. Our hands-on Learn to Code resources help you learn everything you need to go from your first line of code to your first job.

Good luck, and happy learning.

5 steps to learn to code successfully in 2024

Hunter Johnson — Wed, 24 Apr 2024 11:54:35 +0000

I'm Fahim, a software developer turned tech founder. This article is part of my series: The Developer's Launchpad. I'll share my top lessons, hacks, and best practices for learning how to code and launching a new career - things I wish I would've known earlier in my journey. If you're starting out your own coding journey, this series is for you.

We are alive at a fascinating time in human history. AI-based technologies are changing the way we live, learn, and interact with the world around us. Meanwhile businesses across every industry are using AI to build more personalized experiences for the people using their products.
Of course, with all these rapid advancements in AI, there's a big question on everyone's mind:

"Does it still make sense to learn how to code today? And if the answer is yes, what's the best way to do so?"

First of all, I strongly believe that now is a great time to learn how to code.

AI won't be taking any developers' jobs any time soon (this is something I have written about a lot. In fact, we need more new developers to build the next generation of software for the next generation of global users.

However, we still need to remain aware of the ways that AI is poised to change the game for experienced developers and new learners alike - and learn how to use AI to our advantage (I'll talk more about this later on).

So today I'd like to talk about learning to code in the age of AI - and 5 steps you can take to set yourself up for a long and successful career as a software engineer.

(These steps are the same whether you're in a university, or teaching yourself to code online. No matter which route you choose, you will still need discipline, focus, and clear goals).

Here's how I would learn to code in 2024:

Build problem-solving skills
Learn the basics of a language
Tackle real-world projects
Get comfortable with AI
The last mile (landing a job)

Let's dive in!

5 steps to learn to code successfully in 2024

1.) Build problem-solving skills

This first step is all about learning how to think like a programmer before you even type your first line of code.
Knowing how to code is just a tiny part of being a professional software developer. Developers are problem-solvers at heart. 80% of our day-to-day consists of designing solutions to challenges - 20% consists of actually executing those solutions with code. The "coding" part is simply the process of translating those solutions into a format that a computer can understand.

You may be surprised to learn that you are already using your problem-solving skills every day, whether or not you realize it.

My biggest piece of advice during this stage is simple: take your time. Success isn't about building complex projects right away - it's about starting simple.

By investing in mastering fundamentals in logic and problem-solving, you will establish a strong foundation for your entire career. In fact, this foundation will enable you to more easily learn additional programming languages and skills down the road.

At Educative, you can develop your problem-solving skills while getting a Taste of Code - without getting too technical too quickly, and without making any sort of long-term commitment.

Last thing: as AI gets better at accomplishing basic coding tasks, problem-solving skills will become even more important. AI can help developers achieve that final step, i.e. translating the solution into code. But it will still be up to humans to understand how to approach the problem in question, and design the most efficient solution.

2.) Learn the basics of a language

Learning to code is a lot like learning to drive.

How so? It wouldn't make much sense to start by driving on the freeway. You want to start on the side streets. It's critical to get comfortable with how the car handles, and with the basic rules of the road. From there, you start building muscle memory - and only then is it safe to explore more heavily-trafficked roads.

Similarly, learning to code requires that you start by getting hands-on with the fundamentals. Take your time to build muscle memory before you jump into building anything. Truly mastering the fundamentals of your programming language of choice can set you up for long-term success. But which programming language should you learn first?

> You can start with any language, and your particular choice depends on your career goals.

If you haven't decided yet, I think Python is a great choice for any beginner in 2024.

Why Python? Here are a few key reasons why Python stands out as the best programming language for beginners:

Most popular language in the world
Easy to get started
Intuitive
Versatile

Despite its relative simplicity, Python is a very powerful and versatile language. As a Python developer, you can apply your skills to various specializations - whether that's back-end web development, data science, machine learning, or AI.

So, which Python concepts would you need to learn before progressing in your learning journey?

Algorithms & data structures
Functions
Data types
Operators
Lists & Loops
Libraries
OOP basics

Educative offers a free course called Learn Python 3 From Scratch, which will help you get a leg up on the essentials.
_

3.) Tackle real-world projects

To truly internalize the basics, you need to practice applying them in projects. Building projects is a terrific way to get real-world practice with technologies and processes you will use as a professional.

Software engineers usually work on individual parts of a larger project, sometimes taking weeks or months to complete. However, at this stage in your learning, you will want to start with shorter, self-contained "toy problems," and graduate to building more and more complex projects.

Remember, it's important not to move too quickly: don't skimp on the fundamentals before jumping into projects.

When you're ready, Educative offers more than 200 full-featured Projects. This is a great way to build your portfolio and practice your skills in a real-world setting.

4.) Get comfortable with AI

The future of tech is going to be increasingly infused with AI.

This means every developer eventually needs to learn AI skills. As a beginner, it's enough that you simply learn how to get the right outputs out of Generative AI tools through prompt engineering. Along the way, you should also get comfortable with some AI terminology and basics.

But getting comfortable isn't just about learning particular skills - it's also about getting comfortable with AI's prevalence in general.

Let's address the elephant in the room: Many beginners are nervous that AI tools will make junior developers obsolete.

But the truth is that you don't need to be afraid of AI taking developer jobs. Much in the same way that calculators didn't eliminate the need for mathematicians - AI tools won't replace developers. They will simply help us work faster and make our jobs more enjoyable. Better yet, they'll help us focus more of our time on problem-solving, and less time on rote memorization and tedious work. (Not convinced? Check out my other Medium article about Generative AI's shortcomings
In fact, new coders are lucky today because AI brings unique opportunities for learners.

AI has the ability to bring a greater degree of personalization to your learning, helping you build and practice the skills you need to level up. (At Educative, for example, we use AI to help you get customized feedback, tips, and guide you through each step of your coding journey.)

5.) The last mile (landing a job)

Learning to code is hard work, and can definitely feel like an uphill battle at times. If you have made it to this point in your journey, congratulations!

However, you may be surprised to hear that I see a lot of aspiring developers struggle most not at the start of their journey, but at the end.

Here's the critical step most people miss: interview prep.

It's possible to secure an interview with a solid portfolio that includes plenty of projects. But what a lot of new developers don't realize is that succeeding in an interview depends on an entirely new skill set. (In my experience, this is an area where university programs and many bootcamps often fall short).

Hiring managers are looking for you to demonstrate certain skills, so succeeding in an interview is all about knowing how to navigate the process and demonstrate those skills.
That means interviewing is a skill that can be built, similar to how you might learn another technical skill.

In my experience interviewing software engineer candidates, I have seen many talented developers struggle in technical interviews - but I have also seen many inexperienced developers perform exceptionally well. The difference is preparation!

Start Learning to Code for Free

Ready to learn to code and become a software engineer?

You can check out our free skill path to get your first taste of code on Educative.

Then if you like what you see, you can follow the steps from your first line of code all the way to your first day on the job with our Learn to Code resources.

All you have to do is take your first step.

Good luck - and happy learning!

6 common anxieties for new coders (& how to overcome them)

Hunter Johnson — Thu, 18 Apr 2024 09:14:31 +0000

I'm Fahim, a software developer turned tech founder. This article is part of my series: The Developer’s Launchpad. I'll share my top lessons, hacks, and best practices for learning how to code and launching a new career — things I wish I would've known earlier in my journey. If you're starting out your own coding journey, this series is for you.

Countless passionate and proficient developers have struggled with anxiety in their early coding days. I personally experienced anxious thoughts, as well. While it's not uncommon to feel anxious when learning to code, it can definitely feel like it’s slowing down and limiting your learning journey.

The good news is that most coding-related anxieties are based on unrealistic expectations, myths, or self-limiting beliefs. By understanding the particular anxiety you're dealing with, you will be better equipped to manage and overcome it.

Today I want to unpack some common anxieties that affect beginner coders. Then I will share some tips that may help you address them, so you can confidently progress towards your new career

These are:

1. Fear of math
2. Overwhelm about how much there is to learn
3. Fear of failure
4. Performance anxiety
5. Imposter syndrome
6. Believing you aren't "techy" enough

Let's get started.

6 common coding anxieties for new devs

1. Fear of math

For those with negative associations with math, the math skills required for coding can be intimidating. The amount of math you will need to undertake is a matter of your specialization.

If you know what specialization you want to pursue, you can clarify how much math you need to know, and make a step-by-step plan. Some specializations might not need very advanced math. For instance, front-end web developers may only need basic algebra, arithmetic, and geometry. However, on the back end, web developers require a deeper understanding of advanced mathematics, including calculus and trigonometry. Other specializations such as machine learning engineers and game developers would need more extensive math knowledge, including linear algebra and statistics.

If math involved in programming burdens you, I recommend:

Starting with logic and problem solving skills.
When you move on to math, practice regularly to build your confidence.
Be patient. Over time, you will improve.

2. Overwhelm about how much there is to learn

There are a lot of skills you need to learn to become a developer. For some, the list of concepts to master is enough to put their stomach in a knot.

Just like with any big undertaking, the only way to manage it effectively is to break it down into digestible, small steps. Meanwhile, track your progress. Even if it feels like you're moving slowly, each small step is an indispensable prerequisite to your coding goals.

As a developer, the hard truth is that the learning never stops: even experienced developers must continuously learn to keep pace with the industry. Ultimately, you need to find a way to enjoy the learning process; approach new concepts with curiosity and excitement to grow your skills.

It's important to realize that learning to program is a big task. Regular practice is key to your long-term success. If a complex problem overwhelms you, break it down into smaller steps. Over time, familiarity and experience will help you understand concepts with increasing depth.

Tip: Approach learning with curiosity. Break down learning goals into small steps.

3. Fear of failure

Fear of failure is a common concern among beginners. It's important to remember that making mistakes is a critical part of the learning process. Coding is about iteration: we write, test, and fail — then we learn and improve.

Every mistake is an opportunity for deeper understanding.

Your relationship with failure can determine your success in learning to code. If you react to mistakes with negative self-talk and think about how stupid your mistake was, you'll only be making the learning process more difficult for yourself. However, if you respond to mistakes constructively and curiously investigate where you went wrong, you can reinforce foundational concepts and learn from your mistakes.

Realizing that it's ok to make mistakes when programming will enable you to learn effectively. In fact, it will give you more confidence to engage in one of the most crucial learning activities: hands-on coding practice.

4. Performance anxiety

Performance anxiety concerns the quality of your performance, particularly under the pressure of being timed or evaluated. For new coders, this often presents itself as testing anxiety or interview anxiety.

The real danger with performance anxiety is that it can affect your ability to think clearly. Although you may know how to solve a particular problem, your anxiety could cause you to draw a blank in the moment — which could cause problems in an interview setting.

To overcome this anxiety, practice is key to building confidence. After all, think about an Olympic tennis player. They don't think as they play. Instead, they rely on muscle memory that's been honed through focused practice.

So practice often. If you can, do so in conditions similar to the real scenario (e.g., mock interviews).

5. Imposter syndrome

I know plenty of accomplished developers who still struggle with feelings of inadequacy because of imposter syndrome. Imposter syndrome is the belief that your skills and accomplishments are not valid, and that you're a fraud. In the programming field, it can affect everyone, but imposter syndrome can especially impact marginalized groups, including women.

Some strategies that can help with imposter syndrome include:

Keep track of and recognize your achievements
Be mindful of negative self-talk and peer comparison
Seek out a community of coders who share similar experience and background
Learn to live with self-doubt instead of letting it hold you back (for some, it never goes away)

6. Believing you aren't "techy" enough

While it's natural to struggle with new programming concepts, some learners attribute their difficulties to the belief that they aren't "techy" enough to be a programmer. I've often seen this affect those who have negative associations with math or technology, or who come from a different background such as humanities or the arts.

Any struggles you have along the way are not because you lack some innate ability of being "techy" enough. In fact, the opposite is true: you already possess one of the core skills of programming: problem-solving.

While you may be new to programming, you've been solving problems since you were young. Everyday tasks such as shopping, making social plans, and even playing games involve problem-solving skills. Learning to program involves applying those same natural problem-solving skills to identify a solution, then translate that solution as instructions for a computer.

Overcoming the hurdle

Anxieties are a common challenge among aspiring developers, but it's possible to overcome them. The more you know about your particular anxiety, the better equipped you'll be to manage it.

Whatever hurdles you face in your coding journey, I'm confident you'll find a way to overcome them. And if any of my tips helped today, I'll be glad!

As a reminder, you can learn all the skills you need to go from your first line of code to your first job with Educative's Learn to Code resources. Code as you learn, quiz your knowledge, and get personalized AI assistance and feedback. Check it out here.