Big developments in tech are more than just headlines— they’re signals of where the industry is headed. From AI shake-ups to the growing demand for in-office collaboration, it's essential that you know what they mean in order to plan for success.

Here’s what’s happening right now, why it matters for you, and how you can stay prepared for what’s next.

What 4 recent developments mean for you

1. OpenAI transitions to a for-profit business

OpenAI, the company behind ChatGPT, was founded as a nonprofit in 2015. Their main goal was to make sure artificial intelligence (AI) was developed safely and for the benefit of everyone, rather than just to make money.

But starting in 2025, OpenAI plans to become a for-profit company. This means they’ll focus more on earning revenue, and their CEO, Sam Altman, will be paid in shares – which aligns the company’s success with personal financial gain.

This change has been building for a while. Back in 2019, OpenAI allowed investors and employees to earn profits (with limits). Now, with an even stronger focus on profit, tools like the GPT language model — which powers ChatGPT and other applications — could become more expensive. OpenAI might also start working more with big businesses and less with smaller projects or individual developers.

Why this matters for you:

• More job opportunities in AI: As OpenAI grows, there will probably be more jobs for developers with AI skills.

• Higher costs: OpenAI's tools, like ChatGPT, (which lets developers integrate AI into their own projects) and DALL·E (an AI that generates images from text), might become more expensive. This could make them harder to afford for smaller teams or individual developers.

• Focus on big companies: OpenAI could start focusing on larger businesses, which means fewer tools or support for smaller, experimental projects.

• Fewer free tools: OpenAI has contributed to a lot of free, open-source projects in the past, but with this shift, expect fewer free tools for developers to use.

The demand for AI skills is growing fast, and staying up to date with AI tools can help you stand out as you build your career. Check out my earlier post on how you can start leveraging AI while learning to code.

2. Leadership changes at OpenAI could breathe new life into the company

As OpenAI transitions to becoming a for-profit company, it's also experiencing major leadership changes. Half of the original team that built the GPT language model is no longer with the company, and out of the 11 co-founders, only Sam Altman and Wojciech Zaremba remain.

This year, key figures like Bob McGrew (Chief Research Officer) and Mira Murati (Chief Technology Officer) have left. Some have moved to other companies, while others, like cofounder Andrej Karpathy, are starting their own ventures, such as his new AI-focused education startup, Eureka Labs.

These high-profile departures could spell changes in OpenAI's direction. As new leaders join, they may introduce fresh ideas and innovations that affect the kinds of projects OpenAI prioritizes.

Why this matters for you:

• Shifting priorities: OpenAI may focus on different projects., so stay informed about new directions to keep up with tools or projects that interest you.

• New opportunities: New hires often bring new innovations, which could mean new tools and possibilities will emerge for developers.

• AI ethics and safety: As AI continues to grow, conversations around safety and ethics are becoming even more important. Staying informed will help you understand how these discussions affect the industry and your role.

3. Dell’s new return-to-office policy reflects a larger industry movement

Dell, following a trend started by companies like Amazon, just announced that its sales team will be required to return to the office 5 days a week. Right now, most hybrid employees are expected to come into the office 3 days a week, but the sales team is the first to be asked to come all week.

Earlier this year, Dell gave U.S. employees the option to go hybrid (a mix of remote and in-office work) or fully remote, but remote workers weren’t eligible for promotions or new roles. Dell’s leadership said that having teams in the office helps with collaboration and skill-building, but some employees feel the change was too sudden.

Why this matters for you:

• More companies might require in-office work: Dell’s move might be a sign that other tech companies will soon start asking employees to come into the office more often. Be ready for this possibility as you begin your career.

• In-person work helps with learning: Working in an office allows for real-time feedback and collaboration, which is especially helpful for learning new skills, solving problems quickly, and growing as a developer.

• Adaptability is important: Being flexible and open to changes, like returning to the office, can help you stand out. It shows that you’re engaged and willing to adapt, which could open up new opportunities or leadership roles down the line.

Personally, I don’t agree with how Dell handled the shift, but I can appreciate their point about collaboration. More tech companies are likely to follow, so it’s a good idea to stay open to the change.

In case you missed it, last week I wrote about why in-office work is especially valuable for junior developers — here’s the link if you’d like to check it out.

4. Tesla’s Robotaxi misses the mark, but there’s still opportunity for developers

On October 10th, Tesla revealed its new “Robotaxi,” a self-driving, two-seater car with no steering wheel or pedals. But investors were disappointed by what they felt was a lack of information about when the Robotaxi would be available or how it works, and Tesla’s stocks tumbled 9% after the reveal.

Despite the setback, the market for autonomous vehicles is definitely growing. In 2022, the autonomous vehicle market was valued at $1.5 trillion and is expected to reach $13.6 trillion by 2030, according to Fortune Business Insights.

Why this matters for you:

• We need skilled developers for autonomous vehicles to be successful. To that end, there will be plenty of opportunity for developers to work on AI, machine learning, and sensor tech for self-driving cars.

• If you're interested in self-driving technologies, there are many ways you can contribute to their improvement. For example, you could work on how these cars "think" through neural networks (a type of AI which mimics the human brain) or you could work to improve safety algorithms (the rules that keep the car and its passengers safe).

Stay informed, stay flexible

Tech is always evolving, and staying on top of trends helps you understand how to break into the career you want. As a new dev, I advise being open to in-office work, because we'll only see more of it. I also hope you're excited about AI, because if you haven't already noticed — it's driving most innovation these days (which means that, eventually, you'll need to learn some AI skills too). 

In the meantime, a strong foundation is pivotal no matter what the tech industry throws our way. You can get hands-on with Educative’s interactive Learn to Code courses to grow your technical skills and prepare for the future.

Once again, I'll be taking a little break from Letters to New Coders, so be sure to  follow me on LinkedIn to keep getting tips and insights to help you gear up for 2025.

Happy learning.

— Fahim

Generally, the world's reactions to this are mixed — some say Amazon is out of touch, others think it's a push to downsize staff.

But at our table, we agreed on one thing: for junior developers, remote work can be the silent killer of professional growth (and RTO is a good thing).

As a new developer, remote work might seem like the dream: no commute, total flexibility, coding in your pajamas. But what if it’s holding you back?

If you’re early in your career, working remotely can make it harder to tap into the culture, mentorship, and learning opportunities that come with being in the office. Without the chance to engage with other developers face-to-face, you could struggle to bridge the gap to those coveted senior roles.

With more companies returning to in-office work, being on-site could be the key to accelerating your career growth. 

Today, I’ll share 5 reasons being in-office is beneficial for junior developers, including:

• Expanding your network and gaining a competitive edge

• Immersing yourself in company culture

• Seeing the big picture of the development process

• Learning directly from senior developers

• Building essential soft skills for long-term success

Let’s go.

 In-person work is on the rise:

While hybrid work remains steady (with 42% of developers sticking to a mix of home and office), something surprising is happening: more developers are heading back to the office. In fact, in-person work has grown for the third year straight — rising from 15% in 2022 to 20% this year.*

*2024 Stack Overflow Developer Survey

5 reasons being in-office is great for new developers

1. You’ll expand your network – and gain a competitive edge

Being in the office gives you a critical edge by helping you build a stronger, more personal network – one that can open doors to new opportunities and accelerate your career.

As opposed to remote interactions, in-office networking happens naturally and spontaneously. Grabbing lunch, chatting by the coffee machine, or joining after-work activities lets you connect with more people — including those who aren’t on your immediate team. 

What’s more, being physically present gets you more visibility for your work and contributions. Through your contributions in meetings, close collaborations on projects, and eagerness to learn, it'll be easier to make a lasting impression on others. 

And here’s the real advantage: a strong network helps you get valuable referrals, which lead to new roles and project opportunities later down the line.

Tips to maximize your in-office time:

• Join lunch or coffee breaks to meet people outside your team

• Ask questions and seek advice from senior devs

• Attend in-person company events, meetups, or after-work activities

• Volunteer for projects that expose you to different teams and leaders

2. You’ll integrate with company culture

Ever feel disconnected from your company’s culture while working remotely? You’re not alone. 

Without in-person interaction, it’s easy to miss out on what truly makes the company unique — and to feel isolated from the larger mission.

Company culture is more than just a set of values to memorize before an interview: it’s the foundation for how leadership makes decisions and sets goals. For example, one of Google’s core values is “psychological safety,” which encourages employees to speak up without fear of repercussions. This value shapes how teams collaborate, solve problems, and work toward shared goals. 

Being in the office allows you to witness how these values unite your team towards a shared goal.

Company values are the qualities you’ll be evaluated on in performance reviews. To move up within a company you need to embody and grow into them — and that’s much easier when you’re immersed in them daily, working alongside your team in the office.

3. You’ll get a big-picture view of the development process

In-office work gives you a front-row seat to the entire development lifecycle. You’ll begin to understand the bigger picture — how your work fits into the larger flow, from initial idea to the final product. It’s hard to get that same depth of understanding when every interaction is planned and structured over Zoom or Teams.

For example, imagine working on a small feature that integrates into a larger product release. In the office, you can observe discussions between teams about how that feature impacts other components of the system, how design and engineering teams collaborate to troubleshoot issues, and how deployment is managed. 

These spontaneous interactions provide a deeper understanding of how everything fits together.

Some tips for ways to learn:

• Attend project meetings or sit in on sprint planning to see how tasks are prioritize, and how projects come together

• Volunteer to help with testing or deployment to understand how products are tested and launched

4. You’ll learn from senior devs

One of the biggest advantages of being in the office is the proximity to senior developers. As a junior dev, you’re often focused on smaller tasks with short deadlines. But being in the same space as senior developers lets you observe how they handle long-term, high-priority projects.

Early in my career, watching senior devs tackle complex system issues gave me insights I wouldn’t have gained on my own. Their approach – from diagnosing the root cause to testing solutions — expanded my understanding of the full development cycle.

By witnessing how senior devs work firsthand, you’ll see why being a developer isn’t just about coding — it’s about solving challenges, making difficult trade-offs, and leading teams. These in-person learning moments are invaluable, and they’re much harder to come by remotely.

How to make the most of your time with senior devs:

• Shadow their work or sit in on code reviews

• Ask them to walk you through a challenge they solved

• Offer to help with a small task

• Jot down key takeaways from what you’ve learned

5. You’ll build your soft skills

Some things Zoom just can’t teach you.

While you can pick up technical skills on your own, in-person work is the best way to build soft skills in real time, helping you grow into a well-rounded developer who’s prepared to lead and collaborate effectively.

Soft skills are skills that involve working with people, and include:

• Communication

• Collaboration

• Handling feedback well

• Navigating conflict

Soft skills are just as important as technical expertise. They are non-negotiable for more senior developers who are in leadership roles. Even a highly data-centric role like data scientist has to have the soft skill of "data storytelling" to present their findings to leadership in a way that they understand. 

Think about it: If soft skills weren't such a game changer for developers, then why would we put candidates through behavioral interviews?

Bottom line: Embrace being in-person (or be left behind)

Here’s the reality: being in the office will likely give you more career opportunities than working remotely.

While remote has its perks, if you’re a new developer looking to level up quickly, the opportunities for growth and relationship building you’ll get in person are hard to replicate online.

Sure, the comfort of working from home is tempting – but if it's slowing your growth, is it really worth it?

So, take the leap. Ask for more in-office days. Volunteer for on-site projects. And start building the connections, skills, and insights that will accelerate your career.

Your future senior developer self will thank you.

If you’re looking for other ways to level up your skills, Educative’s Learn to Code courses can help you master the technical skills you’ll need along the way. Then, you can pair that learning with in-office experiences for the ultimate career growth trajectory.

Happy learning!

— Fahim

The cloud has completely transformed how developers work. It lets us quickly deploy apps, collaborate globally, and access advanced technologies like AI — all from any device with an internet connection. By bringing so much to our fingertips, the cloud is one of the major technologies that makes today a great time to learn to code. 

Cloud technologies already underpin much of the developer workflow. As a new developer, it's essential that you learn how to leverage these technologies — learning cloud skills will set you apart and position you to contribute to cutting-edge projects in any role.

You may be wondering: How do I get started? 

…I'll help with that.

Today, I'll outline 5 steps to help you build cloud skills:

1. Solidify your programming basics

2. Build your cloud fundamentals

3. Identify the first cloud skill(s) to learn

4. Get hands-on practice

5. Optional: Get certified

Learning cloud skills as a beginner might feel overwhelming. Just know that you don’t need to rush: what I'm going to lay out today is a long-term plan that will take you from programming proficiency to being a cloud-ready developer. 

Let's jump in.

5 steps to build cloud skills

1. First, build your programming basics.

This is likely where you are right now, and I absolutely recommend spending as much time as you need to feel comfortable here.

Your to-do list here would look like this:

• Learn a core programming language

• Understand algorithms and data structures 

• Understand programming concepts such as conditionals, loops, and functions

• Build your first small applications

• Get practice with debugging

Building a foundation is most important before jumping into cloud skills. That said, there are two aspects of the cloud that are accessible to you in this stage. 

First, if you're feeling curious, you can dabble into the next step of learning high-level cloud basics (but if you feel overwhelmed, don't push yourself).

Second, you can get a headstart with one of the most popular cloud tools used by professional developers: Git. Git is used by professional developers to collaborate, debug, and much more. 

As a learner, starting with Git gets you comfortable with an industry standard tool, and will also help you to do the following in your learning journey:

• Stay organized: You can save your code to the cloud through Git, which lets you access that code across devices and have backup code in case your computer crashes

• Troubleshoot code: You can review or even revert to previous versions of your code if you encounter a bug

• Work with others: Git is helpful for collaboration on group projects or contributing to open-source

Once you're comfortable building small applications, you can start digging into cloud fundamentals.

2. Build your cloud fundamentals

There's a lot to learn, so start with the birds-eye view, then zoom into cloud components.

First off, you'll want to start with high-level cloud basics:

• Why businesses use cloud platforms and why they are so integral to our tech landscape

• Cloud types (public, private, hybrid)

• Cloud service models (IaaS, PaaS, SaaS, serverless computing)

• Different cloud providers (AWS, Azure, Google Cloud Platform)

• The concept of cloud security and why it's important

I covered some of the above points in my introductory post on the cloud.

After covering these basics, you can look under the hood to some of the components and technologies that power cloud computing:

• Networking basics (virtual machines, containers, Kubernetes, Virtual Private Clouds, load balancing)

• Core cloud services like compute (EC2), storage (S3), and databases (RDS)

Remember you have a world of resources at your disposal to learn these, from videos and blogs to courses and documentation. Choose the ones that are right for your learning style.

3. Identify the first cloud skill(s) you should learn

As developers, web developers and ML engineer don't do the same work — but they both use cloud tools to be more efficient. 

Different cloud skills are relevant to different specializations. Once you know which type of developer you'd like to be, you can then target the cloud skills that you should get started with.

For example, here are some first steps for a few different career paths:

• Web developer: Deploying a small project on AWS. This involves several important subskills, including managing a virtual server

• Data engineer: Exploring cloud data storage solutions like Amazon S3 or Google Cloud Storage

• AI/ML engineer: Training your first model with ML services like AWS SageMaker or Google AI Platform

• DevOps engineer: Automating the deployment process using Infrastructure as Code (IaC) tools like AWS CloudFormation or Terraform 

• Cloud security specialist: Begin with Identity and Access Management (IAM), which controls who can access what in the cloud

• Cloud architect: Explore high-availability and fault-tolerant architecture by using services like AWS Auto Scaling and Load Balancer

If you’re not sure which cloud skills are relevant to your career goals, I recommend checking out qualifications listed on junior level job postings for your desired roles/companies. 

These first steps may seem daunting — especially if you're a self-taught developer — but you don't have to do it alone. Be sure to make use of the many guided tutorials and resources that are available online. 

In case you missed it, I explored how different developer roles apply cloud skills last week.

4. Get hands-on practice

Once you know some of the skills that will be relevant to your career goals, you're ready for the most transformative step: practice.

There are a number of ways to get hands-on experience with cloud skills:

• Build projects: You can find many guided projects online, or tackle one on your own accord. Start simple, then gradually increase the complexity as you learn more.

• Try Cloud Labs: Educative's Cloud Labs are guided projects that you can use to build cloud skills with one of the most popular cloud platforms: AWS (no AWS account necessary). 

• Use free cloud tiers: Most big platforms offer free tiers and trials to help you explore cloud services. Some platforms even offer hands-on labs and challenges that cover cloud basics and more advanced setups (e.g., AWS Skill Builder, Azure Learn, Google Cloud Skill Boost).

• Open source involvement: Contribute to open source projects that use cloud technologies. This will not only help you learn new skills but also give you experience working with teams.

Hands-on practice will help you internalize your skills while adding tangible outcomes to your developer portfolio.

5. Get certified (optional)

Getting certified in cloud technologies is optional, but it’s a great way to demonstrate your skills on your LinkedIn and resume.

Most major cloud platforms offer certification programs, with some beginner-level certifications being: 

• AWS Certified Cloud Practitioner

• Azure Fundamentals

• Google Cloud Associate Engineer

However, these certification exams have unique structures, so it's ideal to prepare for them with a specific certification prep course. For this, Educative has a few courses I recommend:

• Cracking the Google Cloud Engineer Certification

• Master AWS Certified Solutions Architect Associate SAA-C03 Exam

One step at a time

Don’t feel like you need to learn everything at once. Start small, take actionable steps, and gradually expand your skill set as you explore different cloud tools and concepts. The fun part? There’s always something new to learn. Whether it’s diving into a new cloud service or experimenting with cutting-edge AI tools, the cloud is always moving forward — and so should you.

As a reminder, Educative has plenty of beginner-friendly courses to help you explore more of the cloud. Even if you're still learning programming basics, you can start learning some cloud fundamentals in the course: Cloud Computing Fundamentals.   

If you're on the job hunt, adding proficiency with cloud services like AWS is a great place to start. You can get hands-on with AWS through guided projects at Educative's Cloud Labs (without needing an AWS account).

Good luck, and happy learning!

— Fahim

By now, most companies — from small startups to Fortune 500 giants — have embraced cloud services. As a result, most developers have embraced cloud services for their daily workflows. 

This shift to cloud is for the better.

The cloud lets developers easily store data and access powerful computing resources. In the past, developers had to manage physical servers (which was cumbersome, to say the least). Today, the cloud automates essential tasks like infrastructure management, making it easy for developers to scale apps, push updates, and more.

By freeing developers from hardware maintenance, the cloud lets us focus on what matters most: building features and solving real problems. In today's cloud-driven world, developers who know how to leverage the cloud are in high demand.

But I get it — "leveraging the cloud" can feel a bit abstract. After all, the cloud isn’t even something you can see or touch. Today, I want to make it more concrete, so that you'll have a better idea of how the cloud will play a role in your future coding career. 

We'll cover:

• Why developers use the cloud

• What it actually means to leverage the cloud

• How the cloud changed daily work for different developers 

Let's get started.

Which developers use the cloud (and why)?

Most modern applications rely on cloud-based services for scalability, storage, and infrastructure, which means that most developers use cloud services.

You don't have to be a “cloud specialist," like a Cloud Architect, to use the cloud. After all, most devs aren't cloud specialists — and yet, 86% of professional developers work in cloud or hybrid environments, according to the latest Stack Overflow Developer Survey.

Only a select few roles may not need cloud skills (e.g., Operating System Engineers, who focus on hardware interaction and system optimization). For the rest of developers, the global shift toward cloud computing means we use cloud services for daily workflows.

Leveraging the cloud means that your work involves some cloud-based applications, services, or databases. These cloud-based tools are hugely beneficial.

The cloud streamlines the development workflow by:

• Setting up development environments

• Managing databases

• Handling security monitoring

• Automating processes

• And more

The result? Developers get to be more productive (with less elbow grease).

Depending on their roles and responsibilities, different developers use the cloud in unique ways. 

Let’s explore how three common types of developer roles rely on the cloud to work more efficiently.

How 3 different devs use the cloud

Remember: you don't have to be a cloud specialist to work with cloud. In fact, the relevance of the cloud for non-specialist roles really demonstrates the widespread benefit of cloud technology for developers in general. 

So, let’s take a quick look at how a few common developer roles use cloud technology, and why it benefits them.

1. Web developer

Web developers build and maintain websites, focusing on the front-end (what users see) or the back-end (technical operations behind the scenes). Sometimes, they do both.

Before the cloud, web developers had to set up and maintain their own physical machines (servers) to run their websites, which involved more manual, technical work and higher costs.

Now, cloud platforms handle much of that for them. Developers can host their applications online by using the internet instead of physical servers, and the cloud automatically adds or reduces computing power depending on how many people are using the app at a time – helping ensure both smooth performance and lower costs.

Web developers use cloud tools to:

• Launch apps quickly: Deploy new apps or updates using tools like AWS Elastic Beanstalk, without worrying about complicated server setups.

• Ensure sites perform well: With cloud tools like AWS Auto Scaling and CloudFront, web devs can keep websites running fast and smoothly, even during traffic spikes or issues.

• Save money: Cloud platforms charge for resources used, making them budget-friendly. Tools like AWS Cost Explorer or Azure Cost Management help both individual developers and companies monitor their use and optimize costs accordingly.

2. DevOps engineer (Developer Operations)

DevOps engineers create systems that automatically handle tasks like testing, deployment, and infrastructure management. DevOps engineers ensure efficient app releases, help ensure that apps work well with other digital tools and services, and keep track of overall system operations. 

Like web developers, DevOps engineers once had to manage physical servers and infrastructure by hand, which was complex and time-consuming. Thanks to the cloud, today’s DevOps engineers don’t have to worry about physical infrastructure. By automating tasks like app building, testing, deployment, and scaling, cloud platforms help reduce manual work for DevOps engineers — streamlining the overall development process.

DevOps engineers can leverage the cloud to:

• Automate testing and publishing: Using cloud tools like Jenkins to run tests and launch updates, reducing manual work.

• Scale apps: Using services like AWS Auto Scaling or Kubernetes to add or reduce resources (like servers) based on how many people are using the app, ensuring apps run smoothly.

• Monitor and log app performance: Track performance in real-time to identify issues early, with tools like AWS CloudWatch or Azure Monitor
  
  

3. Data engineer

Data engineers are like the stewards of data. They work with large collections of data and set up automated systems that move data from one place to another, preparing it to be analyzed and used for reports.

The role of data engineer exists purely because the cloud made Big Data possible.

Big Data refers to the massive amounts of information collected from interconnected apps and devices. Storing and processing all this data would have been nearly impossible using only pre-cloud technology like physical servers, but now, the cloud now enables both processing and analysis to drive decision-making. Data engineers play a key role in organizing and preparing data to provide accurate insights for leaders.

Data engineers take advantage of cloud tools to:

• Process large amounts of data quickly: Handle and analyze datasets faster than a regular computer or server, with tools like AWS EMR or Google BigQuery.

• Automate how data moves between systems: Set up automated processes to prepare data for analysis with tools like AWS Glue or Google Cloud Dataflow.

• Automatically adjust resources: Leveraging cloud services like AWS Lambda or Azure Data Factory to ensure the right amount of computing power is available when needed. These tools scale up when there’s a lot of data to process, and scale down when there's less, so you don’t have to manage it manually.

Fun fact: Data engineering is a somewhat newer role, compared to web development – it exists primarily because of the rise of cloud computing!

Get your head in the cloud(s)

The cloud is a career multiplier, offering countless ways and roles where developers interact with cloud technology. While it may still seem a little abstract at this stage, adding the right cloud skills to your developer toolkit is one of the most powerful steps you can take.

In next week’s post, I'll give actionable tips on how you can learn cloud skills that help you excel in your career (and how to get some hands-on practice)

In the meantime, you can keep building cloud computing foundations with Educative's hands-on course: Cloud Computing Fundamentals. 

Happy learning!

— Fahim

Today, the paradigm shift is AI. However, today's AI boom would be impossible without the cloud — AI systems rely on cloud infrastructure for the computing power, scalability, and storage that complex AI models require. As it turns out, the cloud is integral to nearly all internet technology today as we know it. Whether you're streaming shows on Netflix or working in Google Drive, you're likely interacting with the cloud every day, whether or not you realize it.

Cloud technology is such a cornerstone of modern software development, that any new developer should have at least a working understanding of cloud computing fundamentals (eventually, you should also learn how to leverage the cloud for your applications, too). That's why I'm spending the next three posts focusing on the cloud, and cloud-related skills you'll need to succeed.

This week is the groundwork. I'll introduce cloud fundamentals, and why the cloud is important:

• What is cloud computing?

• A quick history of the cloud

• How the cloud affects everyday life

• Cloud computing 101  

Let's get started. 

What is cloud computing?

Cloud computing is a model that lets us access compute resources — like storage and processing power — over the internet, rather than on a local machine. 

Before the cloud, companies had to own and maintain their own servers (large, expensive computers) to store data and run applications. This meant only the biggest companies could afford these resources. Luckily, the cloud has democratized access to those powerful resources, making them available to more people. 

The term "cloud computing" is used interchangeably with "cloud."

To understand the cloud a little better, let's look at the stages that led to the cloud era.

A quick history of the cloud

It took roughly 4 stages for us to reach the cloud era. 

1) Mainframes

In the early days of computing, we used mainframe computers. Mainframes were huge, expensive machines that filled entire rooms and required experts to operate them. 

People and companies had to rent time slots to run their programs on a mainframe, a concept called time-sharing.

2) Networks and personal computers

As technology progressed, networks were created to connect computers over distances. This allowed users to access computers remotely—without having to be physically near the machine. Around the same time, personal computers (PCs) became affordable, so individuals could have their own machines at home or work instead of relying on mainframes.

3) Virtualization

Eventually, businesses started using virtualization, a technology that lets you create virtual machines (VMs). A VM is software that acts like a real computer, and runs inside another physical computer. Rather than buying several computers, virtualization allowed companies to run multiple VMs on one computer, which could each be rented out to clients or used for different tasks.

4) The cloud era

Cloud computing took virtualization to the next level. In cloud computing, cloud service providers (CSPs) like Amazon, Google, and Microsoft operate massive data centers full of physical computers. Through virtualization, these data centers run thousands of virtual machines among their computers, which they rent to companies or individuals. Cloud computing shifted the responsibility of managing and maintaining physical infrastructure to CSPs, rather than developers. 

Instead of renting time on mainframes, the cloud era gives us the option of renting more accessible and scalable virtual machines in the cloud.

How does the cloud affect everyday life?

The cloud powers much of what we do daily. Whether you're ordering food through DoorDash or getting real-time traffic updates through Maps, the cloud makes essential tools more fast, accessible, and flexible.

Cloud services benefit both users and developers, and can consist of storage, networks, apps, and more. 

Now, anyone can access the massive computing power of cloud providers to run applications, host websites, or store data. As a dev, the cloud lets you create and publish apps without needing physical servers. As a user, you can access your favorite apps and services from anywhere, provided you have internet access.

By allowing us to drop worries about hardware limitations, the cloud has allowed developers to focus their attention on building highly effective solutions. 

Now that we’ve covered the basics, let’s dive into how the cloud is structured and the services it offers.

Cloud computing 101

Cloud environments: Where is the cloud?

There are three main types of cloud environments, which describe the different ways we access and use cloud services:

1. Public clouds consist of services provided over the internet by third-party providers like AWS, Google, or Microsoft Azure.  

2. Private clouds are each dedicated clouds for a single organization, either managed internally or hosted by a third-party provider. These are more common for businesses with strict security or compliance requirements.

3. Hybrid clouds combine both public and private clouds, allowing data and applications to move between them. This allows for more flexibility and resource optimization. Hybrid clouds are common for businesses that want to maintain control over certain systems due to regulatory requirements while benefiting from the scalability provided by the cloud.

Cloud service models: What is offered on the cloud?

Cloud providers offer different services, under the following categories:

1. Infrastructure as a service (IaaS)
   Think of IaaS as renting computing power. The cloud provider manages the hardware, while you handle what runs on it. For example, Netflix uses AWS (Amazon Web Services) to power its streaming service.

2. Platform as a service (PaaS)
   Similar to renting office space that's ready for you to work in, PaaS lets you rent a platform where you can immediately build applications. All you have to do is work on your applications – the provider does the rest. For instance, Shopify runs its e-commerce work on Google Cloud’s App Engine so their devs can focus on building features.

3. Software as a service (SaaS)
   SaaS is when you use software that’s hosted in the cloud. You access it via a web browser or other devices, without needing to install anything. Apps like Gmail or Google Docs are examples of SaaS.

4. Serverless computing
   Serverless computing means you write code, and you don’t need to worry about having enough servers for low or high traffic. Instead, the cloud provider automatically scales to handle changes in demand. For example, AirBnB is one of many companies using serverless computing.

So, which cloud skills should you learn?

From collaboration to innovation, the cloud opens doors to possibilities that were unimaginable just a few decades ago. Thanks to the cloud, cutting-edge technology is more accessible and affordable, which makes it easier for you to make great solutions as a developer.

Once you've started building apps with confidence, you can start to add cloud skills. For example: 

• Web developers might add to their app's functionalities with cloud service APIs

• Systems engineers can use services like Elastic Beanstalk to more efficiently scale systems

It can be a bit abstract to imagine how devs use something as ubiquitous as the cloud to do their work. To clarify this, I'll introduce just how developers use the cloud next week, so that you can understand which cloud skills you’ll eventually need to learn.

If you want to learn more about cloud computing, I recommend checking out Educative's course, which takes today's discussion much further: Cloud Computing Fundamentals. 

Happy learning!

- Fahim

That simple decision-making process mirrors how conditionals work in programming.

Learning conditionals was something of an “aha!” moment for me as a student. I felt like I had unlocked a new dimension in programming. Suddenly, my code could do more than follow a linear sequence – it came alive and could adjust to different inputs. That’s when I knew I could create things capable of solving complex, real-world problems. What a feeling!

Learning conditionals will do that for you, too. Conditionals are a fundamental part of computer programming that allow your code to respond dynamically to different situations. Instead of following fixed instructions, your code can change behavior depending on specific circumstances – making it more intelligent, flexible, and responsive.

Today, I’ll explore how conditionals can help you solve real-world challenges, using examples in Python. Then I'll give you some next steps to start practicing your use of conditionals. 

When is it time to learn conditionals?

So, when would you be ready to learn conditionals? Once you’ve gotten the hang of programming basics like sequential code, variables, data types, and handling input and output.

As you encounter more complex situations where your code needs to make decisions, conditionals are your next logical step.

Types of conditionals

Conditionals come in various forms, allowing you to:

• Specify actions if a condition is met

  • Specify alternative actions if said condition isn't met

• Specify actions if certain combinations of conditions are met

Conditionals check for a condition and evaluate as either True or False. Depending on that result, the program can run different blocks of code. 

In Python, basic conditionals include:

• if: Checks if a condition is True, and runs if True

• elif: Checks for a second condition if previous one is False

• else: Executes if the previous if or elif are False

We can also use logical operators like and, or, and not to achieve combinations of conditions (but we won't cover that for today's introduction).

For example, you can see if , elif, and else working together below. 

x=4

if x>4:
     print("x is greater than 4")
elif x==4:
     print("x is equal to 4")
else:
     print("x is less than 4") 

While these conditionals consist of two lines, as a whole they are referred to as blocks (e.g., "if block"). For statements like if and elif, the indented block will only run if the checked condition is True. The else block, on the other hand, runs only if all preceding conditions are False.

In this blog, we'll focus on if and else. Let’s get started with a real-world example.

Coding for the real world

As the problems you solve become more complex, your code will have to adapt. Let's look at an example where conditionals make a simple program capable of handling bigger questions.

Picture a ticketing kiosk at an event. First, we’ll explore how the program operates without conditionals, and then we’ll dig into how it changes once we add them.

In a basic sequential program, everyone is charged the same ticket price, regardless of any unique factors. 

Here’s what that looks like in a flow chart:

In coding, that flow chart translates to three lines of code, all executed in order from line 1 to 3. Here’s what that code would look like in Python:

This sequence is pretty straightforward! But coding, like real life, is rarely that simple. 

Sometimes, events charge customers a different price for their tickets. For example, prices are sometimes conditional upon the age of the attendee (e.g., children, adults, and seniors).

Enter: conditionals.

For the different ticket prices, conditionals will help our program decide ticket prices based on the customer’s age. 

Here’s how it works:

• If the customer is older than 12, they’ll pay the full adult ticket price.

• Else, if the customer is 12 or younger, they’ll pay half the adult price.

Next, let’s update our ticket pricing program using these conditionals. 

Here’s the updated program sequence:

1. It checks if age > 12.

2. If the condition is true, the if block runs.

3. If the condition is false, the else block runs.

In a flow chart, that looks like this:

And in Python code, that translates to:

Each time this program runs, either the if condition or the else condition will be executed — but never both. 

The do’s and don’ts of using conditionals

Getting comfortable with conditionals

Mastering conditionals will greatly expand the kinds of programs you can write – your whole brain will light up when they click and you realize that you’ve written flexible, intelligent code that can make a real-world difference.

Now that you understand what conditionals are and how they work, it’s time to get some practice in. A great way to work on what you’ve learned is to modify small programs and make them more dynamic. 

Some beginner-friendly examples of conditionals you can build are:

• Using conditionals to check if a number is even or odd:

• Checking the temperature for weather advice (rain boots again!)

• A simple password checker

Conditionals are just the foundation to learn more advanced concepts later on in your learning journey. And remember, programming is all about practice and improvement.

For more in-depth learning, Educative's Learn to Code resources are a great place to get hands-on with programming fundamentals like conditionals in various programming languages.  

As always, happy learning!

- Fahim

Here's what I mean by that.

When I was hiring software engineers at Meta and Microsoft, we saw many exceptionally talented candidates apply. When evaluating sometimes dozens of technically proficient candidates, we had to look to other skills as differentiators.

So what was the key difference between those who got hired versus those who didn't? It wasn't their technical skills — it was their soft skills.

Soft skills are personal traits, which differ from technical skills like knowing Python basics. While some may argue that soft skills are innate qualities that you either have or don't, I believe many of these qualities can be cultivated over time. 

Whether you're hunting for your first job or you're learning to code, I wanted to share 6 surprising traits that can give you a leg up in your coding journey.

The best part? I promise you that these qualities will be differentiators when applying and interviewing to industry jobs.

1. You have a knack for collaboration

If you hoped programming would bring you a quiet career spent solo at your desk, well, I have some bad news: collaboration is essential to being a successful developer. 

Crafting simple and effective solutions is all about teamwork. You will always need to rely on junior and senior developers alike for new ideas, feedback, and support. And that’s a good thing: more perspectives make for better software.

Everyone can, and should, nurture their collaboration skills. Being a good collaborator involves various sub-skills, such as being open to feedback, communicating proactively, and treating colleagues with respect.

Once you're in the workforce, you can grow by taking advantage of collaborative activities that are built into developer workflows, like:

• Code reviews, which provide an opportunity for peers to exchange feedback before changing a software’s code

• Pair programming, where two developers look at the same screen and share thoughts as they write new lines of code

As a student, you can flex your collaboration skills by working with peers on projects.

2. You’re a creative problem-solver

Do you enjoy the process of discovering the right answer just as much as knowing it? If so, you’re a creative problem-solver.

Programming is all about problem-solving: a developer's core task is to find optimal ways to approach a solution to a problem. But add creativity to the mix, and you get innovation. 

Creative problem-solvers have a knack for crafting intuitive or overlooked solutions to pressing problems. If you have this trait, you can bring an irreplaceable perspective to your team, pointing out solutions that others may have missed.

Creative problem-solvers also make for excellent entrepreneurs, because they’re capable of finding fresh ways to address persistent challenges through transformative technologies.

The great news here is that you can strengthen your creative problem-solving skills over time. The better you get at problem-solving, the more prepared you'll be to identify unique and novel approaches to problems (one of the best ways to do this is by practicing logic problems, which I talked about more in last week's post on problem-solving).

3. You enjoy building things

Which of these sounds better to you: exploring the theory of why something works, or seeing something you’ve created in motion?

If you picked the second one, you're certainly going to be fulfilled by your coding career. 

Many developers (myself included) aren't satisfied with learning theory or abstract concepts alone. They have an itch to get hands-on and build something. Luckily, being a developer lets you work on projects that lead to tangible outcomes that change how people interact with technology every day.

The aptitude for building things is less of a soft skill and more of a trait, but it’s still something you can grow to enjoy over time, and you’ll have lots of opportunities to practice and experiment in your career.

Whether you're optimizing code or improving a user's experience, everything you do as a developer will play a role in getting something great into the hands of the people who need it (and if that's not rewarding, I don't know what is).

4. You’re empathetic

At its core, effective software development is about understanding people. Ultimately we are building software with and for people. And of course, nothing human-centered will succeed without empathy.

As a teammate or a leader, empathy equips you to better appreciate or relate to your team’s feelings, allowing you to better support them or guide them toward success. As a developer, empathy helps you better understand the genuine needs of your end user to create a tailored solution for them.

Among other things, empathy means you have these abilities:

• Active listening, or the art of being fully present in a conversation. People with this skill recognize a speaker’s emotions and intent, give their undivided attention, and let speakers finish before responding

• Switching perspectives, or the ability to understand someone else’s viewpoint and its nuances

• Proactive foresight, or the mindfulness to anticipate the needs of colleagues and end users alike

Whether empathy and its related skills come naturally to you or not, cultivating them over time can help you become a conscientious, trustworthy developer people want to work with.

Here’s a real-world example of empathy’s impact in coding: through perspective-switching, you can help your teammates better understand your code through effective code comments, the notes you leave in your code to explain your reasoning. Comments are most effective if you are skilled at anticipating your reader's thoughts. The impact of good code comments can range from helping onboard new developers to making debugging easier.

5. You're a student at heart

Development is a practice of lifelong learning. We all have something new to learn, and something to learn from each other.

If you love learning, you’ll never feel stagnant in a coding career. The tech industry changes fast and there are always new technologies to keep up with. The developers that excel are always ready to stretch their technical skills so they can keep up with the industry and stand out in the market — and they do this through constant practice.

Of course, this learning goes beyond tech skills. With every experience, you'll also get to nurture your soft skills to grow and advance over time.

6. You're bold enough to fail

I can’t tell you how many times I’ve encountered the unexpected or made mistakes in my career. So have Steve Jobs, Bjarne Stroustrup, and all the colleagues I respect. 

Everybody fails — but what separates great coders from good ones is that they persist anyway.

Failures are inevitable, but they're also learning opportunities — if you embrace them as such, each mistake will only make you a stronger developer. Failing forward is all about humility and a growth mindset.

Growth doesn’t happen in safe, routine environments: it happens when you step outside your comfort zone. 

No matter how big or small the task, we'll always face challenges and failures. But learning to reframe those failures as teachable moments will make a world of a difference.

You’re at the beginning of a long and exciting journey 

The traits I shared today are commonalities I've seen in the most accomplished developers in my circle. Having any number of these traits will only help your coding career keep growing and going — and make you an unforgettable team member and hire. 

Even if you don’t have the skills I’ve touched on here, it doesn’t mean your career is destined for failure. While you'll be able to develop some of these traits over time, the truth is that developers come in all shapes and sizes — ultimately, the only traits you need to succeed are determination and a willingness to grow. 

As a reminder, you can learn everything you need along the way with Educative’s Learn to Code courses, from writing your first line of code, to strengthening your problem-solving skills, to practicing for your first interview.

Happy learning!

- Fahim

I'm hoping this post will help you become a strong developer by pointing you first toward the most important foundations of coding. 

Let's dive in!

Many aspiring coders start their journey with questions like, "Which programming language should I learn?" or "Which code editor should I use?"

While these are valid questions for someone who's just decided to learn to code, there's a more foundational skill that they could be building right off the bat: problem-solving. 

From Meta to Microsoft, problem-solving was the core skill behind all of my developer roles. Similarly for you, problem-solving will determine your success in any role or specialization you choose to pursue (whether that's being a web developer or a systems engineer). 

Today, I'll explain why it's worth taking the time to strengthen your problem-solving skills, and how you can do it. 

I'll cover: 

• What is problem-solving in programming? 

• Strengthening your problem-solving skills

• Preparing for long-term success

• Learning to think like a programmer

What is problem-solving in programming?

Problem-solving is the core skill of a developer. 

Put simply, we can break down the developer’s problem-solving process in 3 steps:

1. Understanding the problem

2. Considering the best solution for the problem

3. Translating the problem into something the computer can understand (i.e., writing code)

Note: it's not until the last step of this problem-solving process that you'd be writing code. To add, writing code is just a small fraction of a programmer's job — which means that problem-solving is about a whole lot more than coding.

In reality, developer problem-solving can involve more than the 3 simple steps I’ve outlined. For example: research, comparing solutions, evaluating downsides of each solution, considering constraints, and so on. Generally, the more complex your problem is, the more complex finding the solution becomes. 

Learning to code without covering logic and problem-solving is like wading into waters without knowing how to swim. It’s not enough to know how to build a program. Knowledge of syntax, algorithms, or programming languages alone won't help you decide on an optimal solution for your specific scenario… but problem-solving skills will.

You'll do plenty of coding in your career — but before you ever write a line of it, you should grow your ability to understand a problem and the implications of its potential solutions. Once you can do that, you'll be better able to find optimal solutions to any coding problem (and finally, translate them into code).

Strengthening your problem-solving skills 

Here's the thing: you're already solving problems every day. You're organizing your room. Navigating traffic. Planning your budget. Mundane as these tasks may seem, you're already using a core developer skill to tackle them. 

That said, we all have room to strengthen those problem-solving skills — and the sooner you work on yours, the more quickly you'll become a strong developer. 

The best way to get started? Practice logic problems. 

Let's try one out as an example. 

Logic problem: The Farmer's Dilemma

Problem: A farmer must transport a duck, fox, and corn across a river. 

Rules:

• The farmer can only take one item at a time.

• The fox and duck can't be left alone together (the fox will eat the duck)

• The duck and corn can't be left alone together (the duck will eat the corn)

At any step, the farmer has to choose between these options: 

• Take fox

• Take duck

• Take corn

• Go alone

With these rules in place, take a moment to write down the step-by-step instructions to transport the duck, fox, and corn across the river. 

If you're not sure where to start, spend some more time understanding the problem. For instance, you can deduce more information through the rules you've been provided:

• The duck can't be alone with either the fox or corn, which implies that the duck can be with the farmer or left completely alone

• The corn can't be alone with the duck, which implies that the corn can be with the fox, the farmer, or left completely alone

By solving the farmer's dilemma step-by-step, you're already practicing a key aspect of coding. Sharpening these analytical abilities will only help you handle more complex challenges down the road. 

You can find problems like the Farmer's Dilemma in Educative’s Skill Path: Computer Science Bootcamp. 

Preparing for long-term success

Change is constant in software development. New languages, frameworks, and methodologies emerge every year. However, what remains unchanged is the importance of strong problem-solving skills in developers. To keep up with the industry, being a proficient problem-solver is essential.

When I graduated and entered the workforce, the major shift in tech was the rise of distributed systems. My generation of developers navigated uncertainty as we helped build what would become the discipline of System Design: the practice of designing scalable distributed systems. This new territory came with entirely new challenges, and yet: everything we did to navigate and establish that new discipline still boiled down to problem-solving.

It’s safe to say that problem-solving will remain the constant through every technological shift.

Let's consider the most recent shift — the rise of Generative AI tools like ChatGPT in developer workflows — and whether it’s impacted the need for problem-solving skills. 

Developers are using Generative AI for various tasks, from testing code to writing documentation. According to the latest Stack Overflow Developer Survey, its most popular use case is writing code (at 82%).

With all these use cases for Gen AI, did developers have to do less problem-solving? No — quite the opposite. Generative AI has only emphasized the importance of strong human problem-solving skills. 

Remember: writing code is just the final step in the problem-solving process. Generative AI may assist in this stage, but it cannot handle the critical thinking required in the earlier steps.

Why? AI tools lack the context and nuanced judgment needed to understand a problem, as well as the human creativity needed to find innovative solutions. Gen AI tools can only assist when guided by well-crafted prompts, and even then, they're prone to errors and biases.

As Generative AI becomes more integrated into software development, developers' roles as critical thinkers and problem-solvers will only become more important. Developers will have to guide and supervise AI in the right direction. As Gen AI tools help reduce tedium, developers will be able to spend more time solving the complex problems that are unique to the AI era.

Problem-solving skills will always be crucial for developer success. The earlier you start building yours, the better prepared you'll be for whatever changes lie ahead.

Learning to think like a programmer

Thinking like a programmer means thinking sequentially, breaking complex problems into small chunks, and understanding how each component interacts with each other. Doing this successfully all boils down to problem-solving and logic skills. 

Problem-solving is the universal prerequisite to all programming languages and specialities. There's a lot to learn when it comes to programming, but you can start building problem-solving skills before you even decide between Python or Java (or whichever language you're considering).

As a reminder, you can learn to think like a programmer with Learn to Code resources at Educative. With a bottom-up learning approach, you can cover all your bases from problem-solving skills to landing your first job (in various programming languages).

Happy problem-solving!

– Fahim

You can't write good code without being prepared to test it. Unit testing is one of the primary ways to ensure you've got quality code.

Once you've started writing code, you can learn to write unit tests. While other forms of testing often fall on quality assurance engineers, unit testing is most often your responsibility as a developer. This is because you'll have the best understanding of how the code you wrote was intended to behave. 

Today, I'll explain best practices of unit testing so you can hit the ground running with unit tests that help improve your code. 

What is unit testing?

Unit tests ensure that the different parts of your application work as intended. They focus on units: the smallest parts of your program that can be independently tested. Units can include functions, methods, classes, or more.

By focusing on these small, individual components, unit testing helps identify and resolve problems before they cause larger issues in your application. Unit testing can't guarantee that your application will be entirely free of bugs after deployment, but it can help catch issues early in the process. 

Why do we unit test?

There are several advantages to unit testing:

• Smoother debugging: By testing individual units, you can catch bugs before they spread to other parts of the application.

• Encourages loosely coupled code: Unit testing encourages you to write code where different parts are less dependent on each other, which is a best practice in software development.

• Minimizes code regression: Code regression refers to bugs that occur when new code interferes with existing functionalities. After modifying or extending your code, you can rerun unit tests to ensure the changes don't break existing functionality.

Increasing test coverage

The amount of our code that has been tested is a metric we call test coverage. By focusing testing on each small component, unit testing helps ensure higher test coverage.

Test coverage can consist of:

• Function coverage: The percentage of functions that have been tested.

• Statement coverage: The percentage of individual statements in your code that have been tested.

• Path coverage: The percentage of different paths or branches in your code that have been tested. 

Generally, we want to maximize test coverage, however, 100% test coverage is neither practical or achievable. Full coverage can require more time and resources than available, and it's also theoretically impossible for complex systems. This being the case, it's enough to strive for the highest coverage possible within your constraints.

5 unit testing best practices

1. Test names should be descriptive

Your test names should clearly state what the test is meant to check. 

This is the difference between the names: 

• test_1

• test_user_login_with_valid_credentials

“test_1” does not provide any context about what is being tested. Meanwhile, “test_user_login_with_valid_credentials” clearly indicates that the test is checking if a user can log in with valid credentials. (I think you can draw the conclusion about which is the better test name.)

Consistent naming conventions help make your tests easier to understand and maintain. This practice also supports code readability, which is crucial for long-term project sustainability (and the sanity of fellow developers working in the same codebase).

2. Tests should be deterministic

False positives and negatives are common in software testing, so you have to be diligent to avoid them. This is done by writing deterministic tests.

Deterministic unit tests behave the same way every time they are run, assuming the code hasn't changed. This consistency helps ensure that test results are reliable. 

3. Follow the Arrange, Act, Assert (AAA) Protocol

The AAA protocol is a recommended approach for structuring unit tests. AAA improves your test’s readability by giving it a logical flow. 

The AAA protocol is a structured approach that organizes unit tests and enhances test readability.

You can use the AAA protocol to structure your unit tests with the following steps:

• Arrange: Arrange the conditions needed for your test

• Act: Act on the unit you're testing

• Assert: Assert or verify if the outcome was as expected

Here's an example of the AAA structure in Python, testing the absolute value function:

def test_abs_for_negative_number():
 
  # Arrange
  negative = -4
   
  # Act
  answer = abs(negative)
   
  # Assert
  assert answer == 4

 4. Test a single use case per unit test

Each test should concern a single use case, ensuring that a specific method or function behaves as expected in that scenario. This makes it easier to locate the cause of a failure if a test doesn't pass.

 5. Avoid logic in tests

The more logic in your tests, the higher the chance of introducing bugs into the tests themselves. Keep your test code simple by minimizing logic, such as conditionals or string manipulations. 

Consider this test with logic:

def test_user_access():

    if user_is_admin(user_id):

        assert has_access_to_admin_panel(user_id)

    else:

        assert not has_access_to_admin_panel(user_id)

This test combines two different scenarios (admin and non-admin users) into one, making it more complex and difficult to maintain.

You can improve this by breaking it into two simpler, more focused tests:

def test_admin_user_has_access():

    assert has_access_to_admin_panel(admin_user_id)

def test_non_admin_user_does_not_have_access():

    assert not has_access_to_admin_panel(non_admin_user_id)

By separating the tests, each one becomes easier to understand and less prone to errors, as they focus on a single condition or behavior.

Unit testing frameworks

To get started, I recommend picking a testing framework for your given language. A unit testing framework provides tools to help you write, run, and manage your tests efficiently. If a test fails, the framework can capture the results or raise an alert.

These frameworks offer several useful features:

• Test suite: A collection of related test cases that can be run together, making it easier to test multiple similar units.

• Test runner: A tool that automates the execution of tests and reports the results.

• Test fixture: A consistent setup for your tests, ensuring they run in a controlled environment every time.

There are many unit testing frameworks available, each suited to different programming languages. Some popular ones include:

• PyUnit (Python)

• CUnit (C)

• Mocha (JavaScript)

• JUnit (Java)

Great developers are avid test writers

…And if you're here, I'm sure you want to be a great developer. 

By testing your code as you write it, you can reduce bugs and ensure your project progresses smoothly. Be sure to carry the best practices we learned today as you begin your foray into unit testing.

If you work with Java, you might consider diving into unit testing with our course, Pragmatic Unit Testing in Java 8 with JUnit 5. In this course, you'll learn how to use JUnit to write tests, automate their execution, handle test failures with assertions, and record results.

Happy learning!

- Fahim

You're ready to start learning about algorithms once you've learned some programming basics in one language. If you feel intimidated by algorithms, the truth of the matter is that you already know a few from elementary school. In fact, algorithms have been used for thousands of years, before programming ever existed. 

Today I'll give a gentle introduction to algorithms, covering:

• What are algorithms?

• How to use and combine algorithms

• Which algorithm is “best”?

• Your secret weapon: Big O notation

Consider this “lesson 0” on algorithms. Let’s dive in!

What are algorithms?

Put simply, algorithms are a set of steps we take to solve a problem or perform a particular task. While data structures are ways we store data, algorithms are the proven methods we use to solve problems with that data. 

For example, this is an algorithm for making an omelet:

1. Crack eggs into bowl

2. Whip eggs

3. Heat pan

4. Cook eggs in pan

The simplest algorithms are those we learn without even knowing they’re algorithms. In fact, you might be surprised to learn that math formulas are algorithms. 

Consider the Pythagorean theorem, which you've likely encountered before. The Pythagorean theorem is a simple algorithm for calculating the length of the hypotenuse of a right triangle (and it has been used since ancient Mesopotamian times). 

Imagine: if we didn't have the Pythagorean theorem, we'd have to measure triangles manually. In a similar way, algorithms allow us to efficiently apply mathematical principles like the Pythagorean theorem to solve problems efficiently as programmers.

Math formulas are the inspiration for the algorithms used in modern computing. That said, math formulas have to be turned into machine algorithms (i.e., translated into algorithms that computers understand). This task is the responsibility of a programmer.

> Fun fact: Ada Lovelace is considered the first programmer to have written a machine algorithm.

How to use and combine algorithms

While many algorithms are tried-and-true, new algorithms are constantly being developed.

On your day job, you'll most frequently be using known algorithms to solve problems. With enough experience, you can even make your own algorithms. Being able to write algorithms specific to your problem will help you solve problems even more efficiently than a cookie-cutter algorithm that wasn't written specifically for your job at hand.

If this seems intimidating, just know that you won't be expected to create your own algorithms as a beginner. But when you do, it doesn't have to be as hard as inventing a circle. In fact, you can create new algorithms by simply building upon an established algorithm.

Many algorithms build on each other to solve bigger, more specific problems. 

For example, remember the area of a circle (A=𝜋𝑟²)?

We build upon the area of a circle to solve a more complex problem: finding the volume of the cylinder (𝑉=𝜋𝑟²ℎ). What we did here was to extend the algorithm for calculating the area of a circle (A=𝜋𝑟²) to create a more complex algorithm that solves the volume of a cylinder. (𝑉=𝜋𝑟²ℎ)

This is all to say that you don't have to be writing a new theorem as a mathematician to create an algorithm: you can simply build upon what you know, factoring in the needs of your specific problem.

Which algorithm is “best”?

You will start your journey with some basic, introductory algorithms, often focusing on sorting and searching algorithms.

For example:

• How to sort an array of numbers

• How to search within an array efficiently

• How to traverse different data structures quickly. 

And here's the thing: often, you can get the same end result from various algorithms. 

This means you have to choose which one is the most efficient. And this choice is always subjective to the particular problem at hand.

For example, consider the following algorithms for moving furniture between two houses.

Algorithm 1

1. Take one piece of furniture from house 1

2. Transport it to house 2

3. Return to house 1 

4. Repeat steps 1 & 2 until all furniture is moved

Algorithm 2

1. Take all furniture from house 1

2. Transport it to house 2

At first glance, it may seem that algorithm 2 is better. You take less trips between houses, so you should be done faster. However, the best algorithm isn't always the one that has the least steps. 

Algorithm 2 may take less time, but it will require a massive moving truck to fit the entire house's contents, which might be costly, especially if you're on a budget. 

These problems each have different needs, whether material needs (vehicles, money) or time. And this is analogous to what we refer to as different complexities for algorithms. 

Early in your journey, you'll be using what's called Big O notation to understand each algorithm's complexity, and compare them to pick the best choice for your problem.

Your secret weapon: Big O notation

Big O notation is a way to describe how an algorithm's efficiency changes as the amount of data grows. It helps us understand the worst case scenario for:

• How many steps an algorithm might take (time complexity)

• How much memory it might use (space complexity)

We use Big O to compare algorithms and choose the best one for our needs, ESPECIALLY when dealing with large amounts of data. 

When we're dealing with large amounts of data, our algorithms tend to get more complicated. Indeed, the complexity of an algorithm usually depends on the number of inputs.

For instance, if we have to sort just three numbers in order from smallest to largest, there are only three inputs: a, b, and c.

We can use the following algorithm to sort a, b, and c:

1. Compare the first two (a and b) to see which is greater.

2. Swap a and b if necessary 

3. Compare the greater of the two with c.

4. Swap b and c if necessary

   1. If c is greater, we know enough to sort from lowest to highest

   2. If c is NOT greater:

      1. Compare c with the smaller of a and b.

So, we can solve this problem with three inputs with no more than five steps. But if we try to sort five numbers from lowest to highest, the algorithm becomes more complex. 

Even the most efficient algorithm, when applied to millions of numbers, will become complex. Whether it's how fast it will be or how much memory it will need, understanding how an algorithm's efficiency will change over time is crucial to making a fully informed choice on which algorithm to opt for. 

This is why Big O notation becomes an essential, everyday tool for programmers — but it's not a lesson 0 topic, so we'll wrap up our discussion here.

Ready to build your knowledge of algorithms?

Computers excel at one thing: executing simple instructions. Programmers excel at another: choosing the best algorithm for a given task. Once we give the computer some data (packaged in a data structure), we can use algorithms to elegantly solve problems with that data. 

To get hands-on with algorithms, you may want to try the Educative course, A Visual Introduction to Algorithms. This interactive course trains you on the foundations of algorithms, where you'll dive deeper into Big O notation and learn introductory algorithms in your preferred language (e.g., Java, Python, C++ or Javascript). 

Happy learning!

- Fahim

My hope is that this post will answer your most burning questions about AI and coding — and even get you excited about the possibility of solving even more interesting and exciting problems in your future career.

Let’s dive in!

Aspiring developers are facing an unnerving tech climate.

Generative AI tools like ChatGPT have flourished, with specialized AI software engineers like Magic.dev and Cognition's Devin on the horizon. At the same time, layoffs and hiring freezes have made finding a secure job difficult.

Recently, a reader wrote to me with a question that's weighing on the minds of many new coders.

"Will the world stop needing junior developers?"

Many developers are worried that AI is a threat to their job security, but new coders are most vulnerable to this concern.

The possibility of AI replacing junior developers has massive implications. For that reason, many aspiring coders are wondering if it's still worth learning to code. They also worry about how they could possibly compete in an AI-powered world, when the supply of junior developers exceeds the demand.

Today, I'll talk about why the world still needs new coders, and why we should embrace Generative AI rather than fear it:

• If AI isn't the end, what is it?

• Why we still need (human) junior devs

• What skills do junior devs need in the AI era?

• How to stand out in the job market

If AI isn't the end, what is it? 

For those feeling nervous about an AI takeover, let’s try a quick perspective shift. 

Throughout programming history, the technologies we've used have changed immensely — and for the better. Before the 1970s, most computer programmers used punch cards to write and store computer programs. They then moved on to assembly language, and eventually modern programming languages, like C++, Python, Java, and so on. 

Each advancement in technology has helped reduce tedium and made software engineers more productive. As a result, we were able to tackle bigger problems and build more complex and powerful solutions. Early technologies like punch cards and assembly languages were very difficult to work with — and we certainly couldn't have built modern apps like Facebook with them. 

These advancements in technology did not make programmers obsolete. In fact, they made learning programming accessible to more people.

Similarly, AI tools aren't going to stop the demand for developers. They are just the next step in the evolution of programming technologies. 

As AI integrates into more products and services, it's going to create more jobs for developers. As advanced developers move into senior roles or AI roles, we still need entry-level developers to do more generalized tasks. Along the way, we'll have to solve new problems. For example, Generative AI tools require close attention to matters of privacy and data integrity. 

Having the option of using Generative AI tools is a luxury we should celebrate. But just like how power drills didn't replace the need for a handyman, AI tools won't replace the need for developers — they'll only help you be more effective and efficient. 

Let's talk about why.

We still need (human) junior devs

While Generative AI tools will continue to be popular, they aren't replacing the need for human developers. This is because these tools have several limitations.

AI lacks nuanced human judgment

Entry-level engineering tasks, like integrating APIs and UI components, may appear simple. However, creating a delightful experience that solves a problem for the user requires a human touch. And we can't write optimized, maintainable, scalable code without human intelligence. 

Writing software is a complex task that requires context. Incidentally, one of AI's greatest limitations is its lack of context. The context for a given problem determines what will be a functional solution and impacts what code gets written and run. Without it, we can only get as far as writing small snippets of code. That necessary context can't be found in the codebase itself, but is in the head of the human being. 

For example, if we're developing a health monitoring application, its success relies not just on the algorithms for monitoring health metrics, but also on understanding healthcare expertise, user diversity, cultural dietary norms, and privacy laws. These are all necessary details that AI can't pull from the codebase itself.

While AI tools reduce the grunt work, they aren't able to fully comprehend a problem or evaluate solutions. The real value of developers, including those at the junior level, lies in their ability to discern the best application of solutions in the context of a situation.

AI only performs one part of the developer's core process

Underneath the programming syntax and algorithms, a developer's core task lies in problem-solving. 

We can break down problem-solving as 3 steps:

1. Understanding the problems and the user's needs

2. Thinking of an approach to solving the problem

3. Translating the problem into computer-readable form (writing code)

Of this process, AI can only help with the last step of writing code. In fact, in the latest Stack Overflow Developer Survey, 82.55% of developers reported using Generative AI for writing code. However, a developer's work encompasses so many more tasks than writing code, from debugging to code documentation and so on. 

Generative AI tools can't help us solve problems without human supervision and guidance. They can take a prompt and generate code (which is great for streamlining your work). But they don't have the full context and human judgment needed to reliably perform the steps that come before it. And even the AI-generated code needs careful review and edits. 

AI is a closed loop

The key to good problem-solving is creativity, and for that, we need human imagination. Without human innovation and creativity, your code will be stuck in the patterns it has already seen. 

As it turns out, Generative AI, and the Large Language Models (LLMs) that power them, are only able to generate code that reflects what they've seen before. They function by predicting the next word or sequence based on the data they've been trained on. For example, if a user inputs "file open," the model predicts the next word based on the probability derived from its training data, which might include several instances where "file open" is followed by particular commands or phrases.

This ability to think outside the box is another skill with which Generative AI simply can't compete with humans. Their underlying models operate within a "closed loop" of existing knowledge. On the other hand, human creativity isn't as bound by patterns. In thinking of new approaches to problems, we can draw from various sources outside of existing codebases and documentation.

Human imagination is the same reason that great literature won't die just because of AI. Even if you feed all literature books to an AI, it won't generate anything new. It will be somewhat formulaic. 

What skills do junior devs need in the AI era?

What's new: AI readiness & prompt engineering

I've hired junior developers at Microsoft, Facebook, and now here at Educative. Over the last year alone, what makes junior developers stand out is signs that they're "AI ready." After all, the investment in AI initiatives isn't going to go away anytime soon. If you're someone who's going to climb up the ladder in my company, you need to show that you're willing to embrace these new technologies.

What I mean by "AI ready" is not that you're ready to start working on AI models directly (especially if you're entry-level). Rather, what I'm looking for is a curiosity and demonstrated willingness to learn how to leverage AI — especially Generative AI.

Every developer today eventually needs to learn AI skills. Beginners should be learning prompt engineering, so they can learn how to write effective prompts for Generative AI tools like ChatGPT to help write their code. But they should also be able to edit that AI-generated code… after all, we know these tools aren't perfect. 

That said, don't jump to AI skills if you haven't mastered programming fundamentals. After all, you can't properly advise an AI tool on how to solve problems if you don't have relevant experience yourself. Besides, you need to have the right expertise to edit that AI-generated code too… as we know, these tools are far from perfect.

All the other prerequisites still apply

The fundamentals of learning math didn't change just because we were able to use calculators. So the rest of the junior developer skill set remains the same. 

New coders still need a strong foundation on programming fundamentals. You still need to know how to write code, which data structures and algorithms to use for particular scenarios, and how to implement them. 

So yes, for those wondering: It's not only worth learning to code in the AI era — you also shouldn't be skipping any steps. Even if tools like ChatGPT can technically help you, you shouldn't rely on them. If the power goes out and you can't access an AI assistant, you should still know what to do with a given problem. 

Again, while you'll likely use AI tools to be more productive in your job, you still need to instruct them on what to do. They are not self-driving vehicles, and they will go off-course if you're not behind the wheel.

How to stand out in the job market

Generative AI tools are a great advancement, and we should celebrate them. By helping us with the tedious tasks, we'll be able to focus more of our time and focus on problem-solving in new and effective ways. 

No matter where you're at, remember that the only threat to your job security is other developers who have AI skills. 

Beginners should focus on prompt engineering to start, while more experienced developers can move on to learning about machine learning and LLMs to leverage other tools like LangChain.

And if you're looking for your first dev job soon, you can't afford to slack on job preparation in today's market. You'll need to prepare for your job hunt by building a strong portfolio of diverse projects and cracking down on interview prep. Participate in as many opportunities to showcase your work and meet new people — from open-source collaborations to coding competitions to networking events.

You can learn everything you need to know about writing your first program to acing your first System Design Interview with our hands-on courses and projects on programming foundations, interviews, and more: 

• Learn to Code

• Interview Prep

Good luck out there, and remember — AI is a tool that will help you, rather than replace you.

As always, happy learning!

– Fahim

A common mistake I see from beginners when starting to learn about data structures is that they focus more on the what than the why.

In other words, they over-index on learning the syntax of each data structure, without taking the time to understand the characteristics that make certain data structures better for certain scenarios. Having the proper syntax for a data structure won't help you much if you're using that data structure in the wrong situation!

Today, I'm not even discussing syntax. Instead, I'll share a process for how to choose the right data structure for any use case.

I'll cover:

• What are data structures? (A simple example)

• Understanding trade-offs

• A 4-step process to choosing the right data structure

What are data structures? (A simple example)

Data structures are indispensable tools that help you organize and manage information in a computer program. You can think of them as storage tools that help you code more efficiently. 

Let's start with an introduction to one of the simplest data structures: arrays. 

An array is a row of items or "elements" in a certain order. The items can be any type: numbers, words, or even more complex things.

Imagine an egg carton that has one row and holds 4 eggs. Each slot in the carton holds one egg. This is equivalent to saying we have an array with 4 elements. The positions where items are stored in an array are referred to as "indices" (plural for index). The indices of an array start at 0, where the first element is stored.

Arrays are one of the simplest ways to organize and manage collections of items in coding. You'll find arrays in programs for nearly any application you can think of, like keeping track of game scores, listing names in a contact book, etc. 

Voila! You now know your very first data structure. But really understanding a data structure is more complex than this.

Understanding trade-offs

Every data structure has its own way of storing things, which affects how you can work with that data. For example, arrays make it very efficient to retrieve data. However, they're impractical if you want to rearrange the order of your data often.

When you're coding, you can choose from a variety of data structures for a given problem. Choosing a suboptimal data structure can make life unnecessarily difficult for you. To make a smart choice about which structure to use, you need to understand each data structure's pros and cons. 

Just like the array, different data structures will be better optimized for certain scenarios, such as:

• Updating (or changing) data quickly

• Retrieving data quickly

• Processing data quickly

• Navigating data quickly

There's no such thing as a perfect data structure that can be optimized for all scenarios. You'll have to choose a data structure that has downsides that you're willing to accept. Any compromises made in the process are what we call trade-offs. Ultimately, a strong problem-solver knows how to make wise trade-offs.

A 4-step process for choosing the right data structure

When making a choice, the needs of your problem will guide you to the appropriate data structure. 

Here's a 4-step process that you can use to choose data structures. (We'll explore this process through a simple analogy of storing new shoes.) 

1. Understand your problem & its constraints

   1. E.g., Computer has limited memory

   2. Real-world example: You need to store new dress shoes, but have limited closet space.

2. Evaluate requirements for data you're storing 

   1. E.g. Data must be easy to update

   2. Real-world example: Shoes must be easy to access once in a while, but not cause clutter.

3. Identify data structures that meet key requirement(s)

   1. Real-world example: Two storage options are boxes under the bed, or a hanging rack behind the door. 

4. Select the data structure with the most acceptable trade-offs

Real-world example: Because the hanging door rack causes clutter, the shoes can be stored under the bed. The trade-off of under-bed storage is that it takes effort to pull it out, but this is acceptable since you don't need the shoes often.

Learning how to choose data structures is just a matter of learning when to make acceptable trade-offs. You're never just picking a structure based off its pros — you need to remember its cons, and assess which con is most tolerable for the given scenario at hand.

You'll have better judgment over time

Becoming a strong programmer requires you to make strategic choices when solving problems. This is true whether you're deciding on data structure, algorithm, or more complex matters like software or system design. 

How do you make the "right" choice? This is something you'll perfect over time. You will make "wrong" or non-optimal choices as you're learning, and that's ok! When you do, you may still be able to solve your problem — just less efficiently. These "wrong choices" are some of the best learning opportunities, as long as you assess why your choice wasn't practical, and take that lesson with you for the future. 

As a reminder, you can find what you need to get from your first line of code to your first day on the job with Educative's Learn to Code subscription, including 30+ hands-on courses and projects in the industry’s most popular programming languages.

Happy learning!

– Fahim

8.5 million Windows devices crashed and were unable to boot up. This crash affected everything from flights to university classes to surgeries. Even Times Square was illuminated with the ghostly blue of the "Blue Screen of Death" on its big screens.

The outage wasn't a cybersecurity issue, as was initially suspected. However, it was caused by an update to the cybersecurity software, CrowdStrike. Unfortunately, this update contained some bad code. 

Today, I'll break down exactly what happened with the CrowdStrike crash, and why it serves as a warning for developers and companies alike:

• The consequences of bad code

• Why CrowdStrike's code caused crashes

• How we can prevent this from happening again

Let's get started.

The consequences of bad code

In cybersecurity, we use terms like bad actors and malicious code when we're talking about individuals and code with the intent to harm users. But when we say bad code, what we simply mean is that the code had a bug. 

Bugs come from various sources. They can be logic errors, syntax errors, semantic errors, etc. They can lead to programs crashing, or otherwise unexpected results. The particular bug that led to the CrowdStrike crash involved a logic error.

The bad code in the July 19 update was in a particular configuration file. A configuration file is basically a set of instructions that tells the software what to do in certain scenarios. For CrowdStrike's update, the configuration file contained new information intended to protect from new threats. Unfortunately, it instead caused CrowdStrike to crash — along with the devices on which it was installed.

Why CrowdStrike's code caused crashes

We've all had programs crash on our computers, and it usually doesn't take the whole computer down with it. So why would CrowdStrike's crash cause an entire device to fail?

The short answer is the type of permissions that security software like CrowdStrike. We can visualize CrowdStrike's permissions on the protection ring.

The protection ring determines the level of control a program has over a device's CPU (Core Processing Unit). The CPU is like the heart of a computer. Programs that run in Ring 0 have the greatest access to CPU, while programs in Ring 3 have the least access.  

If a program running in Ring 3 were to fail, it wouldn't impact the rest of the system. However, a failure in a program running in Ring 0 can take down the entire device. This is exactly what happened when CrowdStrike's bug occurred. 

Cybersecurity software like CrowdStrike has to run in Ring 0. This is because the protective software needs to be active before any other processes start. If not, malicious code could take over before the software can stop it. Unfortunately, millions of Windows devices simply couldn't boot up because of CrowdStrike's crash.

How we can prevent this from happening again

Bugs are inevitable. That's why debugging is an essential skill. However, it isn't failproof, and debugging alone is not enough to prevent bugs from happening. 

The good news is that there are several well-established best practices that can catch and resolve bugs. Most organizations implement these practices. (As you may expect, there has been some question as to whether CrowdStrike has been implementing them, and I'll get to that in a moment.)  

Before discussing those practices, let's take a look at the software development life cycle (SDLC).

If you're not familiar with it, SDLC is a plan that organizations follow to develop and maintain their software. Leadership can coordinate everything from new software to updates using the roadmap outlined by the SDLC. The SDLC is not only designed around efficiency and effective solutions, but also around the goal of yielding high quality software. The tasks that really begin to target bugs are seen in the later stretch of the SDLC cycle, once the building has begun. 

Some of the most helpful practices for spotting and resolving bugs are found in the Build, Test, and Deploy phases. These include:

• Code reviews: Developers review code to catch errors and inconsistencies

• Version control: Keeping a log of recent changes and previous versions

• Testing: Ensuring the software works in different situations

• Staged rollouts: Releasing software or updates in stages, instead of all at once

• Rollback mechanisms: The ability to undo changes and revert to previous versions of software, if needed

Some of these practices help catch bugs before they are sent out to users. However, that's not always possible. No matter how rigorous we are, some bugs can slip past safeguards, or will happen in unexpected scenarios we haven't tested for. When that happens, practices such as staged rollouts and rollback mechanisms help us bounce back with minimal impact on users.

There has been significant concern about how closely CrowdStrike has been adhering to these best practices. For instance, it's clear that CrowdStrike did not implement staged rollouts. Staging rollouts means we release an update gradually, starting from a small portion of users and ending with every user. This gradual release would help us become aware of any bugs in an early stage, at which point we would stop releasing the update to more users. If CrowdStrike had staged rollouts, they would have known the update was crashing Windows devices earlier, and stopped before it affected 8.5 million users. 

Unfortunately CrowdStrike didn't adhere fully to several best practices, and this outage is a grave demonstration of the consequences of ignoring these tried-and-true safety measures.

What CrowdStrike teaches us about software development

In a world that depends on technology, developers and organizations have a huge responsibility to ensure their software is as good as it can be. This doesn't mean we have to achieve perfection. Mistakes are inevitable. But we can prevent major mistakes such as the CrowdStrike bug by adhering to all these standards at an individual and organizational level. 

When it comes to ensuring software quality, you will likely work with other specialists like DevOps engineers. But even if you do, certain key tasks will always be your responsibility. These include code reviews, writing tests, and following the coding best practices and guidance within your organization. 

Every software development practice has a good reason behind it. While they may seem tedious, don't take them for granted. Your team, your software's users, and the world will be counting on you!

Happy learning!

You can be the best in your class. You can have an amazing, elegant solution to any problem school throws at you. And yet, once you enter the workforce, you might be in for a rude awakening.

Why? There's a big difference between academic and practical solutions.

As a student, many of the problems you encounter in your coursework will have clearly defined starting and ending points. You will be learning concepts in an academic setting – often outside of their real-world context – building self-contained toy problems that don’t resemble the complex applications you will be working on as a pro.

On the job, the problems you will encounter are messy. You will rarely (if ever) build an entire application from start to finish yourself.

That said, while real-world problems are a lot more complex, you can still find a path through them. Today, I'll show you how to problem-solve like a professional, so you can hit the ground running in your first job.

Let’s dive in!

The limits of academic solutions

Imagine that while you learned to code, you practiced each new concept by adding upon the same program you built for your very first coding project. This approach would lead to a far more complex program than starting from scratch. Now imagine that very first program codebase was written by 300 developers over the course of 20 years... Welcome to the real world. 

Whether in a university program or a tutorial, academic solutions and their corresponding problems are designed purely for learning. No matter how elegant it may be, you can't usually bring your solution from a student project to your first developer job. 

This is because academic environments offer a blank slate, unlike real-world work environments. Blank slates are excellent for learning. They give us opportunities to apply our learnings by building projects from scratch. But once we enter the real world, the best practices and techniques that worked on our blank slates may not be relevant for our new situations. This is because we now have to work around existing code and its bugs or constraints.

At work, you'll be dealing with codebases that could be decades old. The old code (i.e. "legacy code") can be completely incompatible with what would otherwise be an academically sound solution. 

When working with an existing program, you'll have to make compromises between your ideal state and the existing codebase. For example, let's say you're writing a program that can store someone's name. You have names with different characters and accents (e.g. é). Instead of removing the accents, you might want to keep them in their correct form. You could do this by creating a unicode string, which can support names with various characters. However, the unicode standard was not supported in many languages two decades ago. If you were to try to store these names in an older program, and an older part of the program tried to parse it, it would yield unintended results. It would be safer to opt for non-accented characters instead.

The difference between an academic solution and a workplace solution is like the difference between building a new house and renovating an old house. When building from scratch, you have the freedom to apply any practices you'd like. But an existing building has its own constraints and history you'd have to work around. 

This may look like a disastrous renovation, but trust me, some of the solutions you'll have to implement in legacy code will seem just as questionable!

Even if you wanted to add the most efficient technologies to an old building, it might have constraints that could make that difficult, impossible, or even disastrous. For example, if you wanted to install a modern HVAC system, an old building may not have the necessary electrical infrastructure and structural support. Worse yet, its walls and layout could be unable to support the weight or configuration of such a system. Installing a modern HVAC without considering these constraints could lead to inefficient heating and cooling or, at worst, structural damage.

Applying best practices to existing codebases is similar. Even if the engineering community has generally understood a best practice or new technique to be beneficial, their implementation in a legacy codebase could yield unpleasant results. 

For instance, you can't just decide to use modular architecture when your codebase is a monolith. Similarly, implementing new, touted security protocols could result in vulnerabilities if you don't understand the legacy code's dependencies. 

This all being said, it's not the case that every coding best practice can be risky in a codebase. Some practices are certainly safe to apply regardless of the legacy code you're working with, such as code commenting or the DRY principle (Don't Repeat Yourself).

Learning to work with legacy code

If legacy code is what's preventing us from using more efficient solutions, why not just overhaul it and start over? Rewriting may seem like an obvious solution, but it's not practical. 

When I was working at Microsoft, the codebase we were dealing with was written using C99, a standard that was created when I was in high school. It was 15-year-old code, and there was so much in the codebase that upgrading all of it would have been difficult… so we just continued to build the software in C99. (There were other teams at Microsoft with legacy that was even older than this code, and they had to stick with it, too).

It may seem like a worthwhile investment to just start over and rewrite code. Truthfully, it isn't. 

For one, it's incredibly costly. The development time and costs that would be involved would be immense. Meanwhile, services can't afford to cease running while we rebuild them. There are still users who need them, and bugs that pop up everyday. You would need to hire an entire development to rewrite the software in parallel to the team that maintains it.

If development teams are expensive, we might have an urge to simply write a converter and just convert and upgrade everything. But you don't know what unintended consequences changes can have. These kinds of mega upgrades will often uncover hidden bugs that were there for decades, but for some reason didn't manifest themselves before they were changed. This alone holds us back. It would create a lot of problems for customers and developers alike. 

There's unimaginable complexity that comes with attempting to rewrite codebases, and the scale of the code that would have to be rewritten can be immense. In most cases, it's not worth taking the risk to take on such an endeavor. As a developer working in a codebase, this means you have to learn to live with the decisions someone has already made — sometimes decades ago.

As always, success comes down to problem-solving

How do you make strong choices and smart moves in an imperfect world? Consider the nuances, and let your problem-solving skills do the rest.

After all, it’s not the specific coding skills you learn as a student that will serve you most in your career — it’s the problem-solving skills you build.

When solving problems, you are always dealing with constraints. Legacy codebases will give you various constraints themselves. From your first job onward, you'll have to consider that code's constraints and requirements as you consider optimal solutions. As a student, you may have jumped to a textbook example of a best practice… but as a professional, your solution may instead be a more creative compromise between the goal you want to achieve, and the legacy code you're striving to maintain. 

As a reminder, you can build your programming career from the basics on up with our Learn to Code courses and projects at Educative. These hands-on courses are designed to help you build and practice the real-world problem solving skills that will enable you to thrive as a professional developer.

Happy learning!

– Fahim

Specifically, I wondered, "How does a word in English translate into something a computer understands?" I would type in a command in human-readable language (e.g. "print()"), and somehow it would run. However, I knew that computers really only understand machine language, which only consists of binary numbers (0s and 1s). 

Turns out that the key player working behind the scenes here is the compiler (or interpreter, depending on the language). Once you learn how the compiler works in tandem with other key components, you'll better understand how your code can create a fully functional program. And with that, will come a deeper appreciation for the technologies you'll be using on a daily basis.

Let’s dive in!

The role of the compiler in program execution

In simplest terms, we can think of the compiler as a translator.

The compiler converts high-level programming languages ( human-readable code) into binary numbers (machine-readable code), which is a set of instructions for the computer to understand. 

This set of instructions is then executed by the processor, which we can think of as the "brain" of the computer that does all the thinking and math (e.g. Intel, M4).

Nearly every programmer today uses one of countless high-level programming languages (Python and Java are two popular examples). These high-level programming languages allow us to use more human-readable code, and distance ourselves from the low-level, machine-readable code that consists of binary numbers. As humans, writing in binary code is both a cumbersome and error-prone process (and quite frankly, it's not for everybody).

To aid its translation, the compiler has a static list of english commands and its binary counterparts. These lists are called instruction sets. Each processor has its own distinct machine language, and your compiler will translate your language into the machine code of the target computer hardware using its given instruction set.

Human translators don't just translate words — they also understand many semantic nuances. Similarly, compilers also have the capacity to understand the intention of the program and syntax, allowing us to more easily write sophisticated programs. For example, if you're running a loop, and you want to print something ten times, the compiler is not going to print ten print instructions. Instead, it will tell the computer that it wants to execute something ten times, which is far more efficient.

What comes after translation?

What we've learned about compilers applies to how programs are written and executed in almost all modern computers. But what comes next?

Before we get to that, let's just discuss the von Neumann architecture that applies to most modern computers today, which consists of these main components: 

1. Processor: The core component responsible for executing logical instructions and performing arithmetic calculations. 

2. Memory: Where the computer stores information and instructions, like a big filing cabinet.

3. Input devices: How we tell the computer what to do (e.g. keyboard or mouse).

4. Output devices: How the computer presents results after processing the data (e.g. screen or printer).

Each of these components are essential players in the execution of a program. The processor, in particular, takes center stage after receiving instructions from the computer, orchestrating the entire process from code to tangible results.

(Depicted above: von Neumann Architecture - The Stored Program Concept)

Once translated, programs can then be loaded into the computer memory. From there onwards, the processor executes them through what we call the read-execute-store cycle. In this process, each instruction is read, executed, and the results are stored back in memory for later use. This process continues until the last instruction is executed. 

A practical example

Let's imagine we want to build a program that can follow recipes to prepare meals in a simulated game environment. 

The following table shows a sample instruction set, or numeric codes for instructions and ingredients:

Note that different instructions require varying numbers of items to operate upon. For example, MIX requires two things to be mixed whereas BAKE requires only one item to be baked. Thus, the length of each statement corresponding to a recipe step will vary accordingly.

We can utilize this instruction set and ingredients to construct a recipe. A sample recipe for baking a cake follows:

But we wouldn't actually want to write our program this way — that's the compiler's job. To make it user-friendly, the translator will take our instructions in a human readable language and automatically convert it to the machine code.

Conclusion

There is unimaginable complexity hidden behind programming. But thanks to advancements in technologies such as compilers, more of us can enjoy programming without having to dive into its technical depths. 

We can be incredibly grateful to the generations before us that have worked to develop the thousands of high-level programming languages that allow us to work in human-readable code as opposed to machine language.

No matter where you're at in your learning journey, understanding the "why" behind what we're doing is just as important as getting plenty of hands-on practice. As a reminder, you can find various hands-on, beginner-friendly courses and projects to build a strong foundation in programming with our hands-on Learn to Code resources. 

Happy learning!

– Fahim

Note: This post is adapted from a blog I wrote for CS students over at Educative. If you’re currently a student, you can get 6 free months of access to Educative via our GitHub Student Pack (including our AI Mock Interviewer tool). If you are able to take advantage, definitely do!

The internet is full of horror stories about take-home assignments in coding interviews. Some candidates report spending 50+ hours building an application, only to submit it and be ghosted by the interviewer.

While these experiences are unfortunate, they're not typical. 

I've conducted hundreds of interviews at Microsoft, Meta, and now Educative. I don't ask candidates to spend more than a few hours on a take-home project. Plus, if you spend much more, it won't help your chances — I have time to review a couple hundred lines of code, not a few thousand.

So, what are most take-home coding projects actually like?

For the most part, companies want to see how you approach a small project in one workday or less. Project specifications vary widely across companies and roles, which is a good thing! A well-designed assignment offers a glimpse into the type of work you'd do on that team. It also enables interviewers to assess your technical and problem-solving skills, without the pressure of a live coding session. 

Today, I want to provide a roadmap for tackling the take-home coding project so that you can advance in your technical interview. Whatever your project, these guidelines will help you build an effective solution in a reasonable timeframe.

First, let's address what to expect from the take-home project.

How do take-home projects work?

Take-home assignments present a task for you to complete asynchronously in a limited timeframe. Companies may assign a task at any stage of the coding interview. It can be an early screening tool, or an assessment later in the process.

Projects can vary widely by role. For example, front-end candidates may be asked to replicate a reference design given in Figma, while full-stack candidates may need to create an appointment scheduler application. You may receive starter code, or be asked to build from scratch in a language of your choice. Some companies even allow you to pick your own project.

Depending on the complexity of your task, you typically have a day or two to work on it, sometimes with a cap of a few hours.

You may wonder if it's worth investing time in a take-home project, especially if you're not yet a serious candidate. To that point, I'd encourage you to keep 2 things in mind:

1. The software engineering job market is highly saturated.

Software engineering is a more popular field than ever, but there aren't enough roles to meet this demand. Companies often screen hundreds, sometimes 1,000+ candidates for each position.

Think of it this way. About 5% of candidates are selected for initial screening. In a pool of 1,000 candidates, that's still 50. Managers may not have time to speak with all 50 candidates.

Take-home assignments give interviewers a better sense of your skills and help narrow the candidate pool to a manageable number.

In a saturated market, take-home assignments can actually help you stand out —as long as you're prepared to tackle them efficiently.

2. Reasonable coding assignments should only take a few hours.

As we discussed earlier, it's possible you'll encounter an unreasonable coding assignment. But most companies understand that you're juggling interview prep for multiple roles.

Well-designed coding assignments aren't a test of who's willing to work the hardest. They do show interviewers how you build practical solutions under a deadline, using whatever setup and resources you find most helpful.

Remember: time limits on assignments exist for a reason. In one quick scan, interviewers want to get a sense of the core skills you used to solve the problem. It's okay to spend 6 hours on a 4-hour assignment. But if you spend 40, it will be obvious that you did (and more difficult to assess your core skills).

I received my assignment… now where do I start?

If you've received a take-home assignment from a company, congratulations! It's difficult to stand out from the pack, so any progress in your application is worth celebrating.

It can be tempting to dive into building right away. However, rushing into your project can lead you to miss key requirements and work inefficiently. You don't want to realize several hours in that you've started something too complicated to finish, or failed to address core requirements.

You only have a few hours, so it's critical that you take a measured and strategic approach. I've outlined 5 tips to guide you through the take-home project, so that you can focus on what matters, minimize anxiety, and advance in your technical interview.

5 tips to ace your coding take-home project

1. Clarify requirements

Descriptions for take-home projects are typically very brief. To ensure you understand the task, read the instructions two or three times and take notes. You'll probably have all the information you need. However, if it's unclear which frameworks, libraries, or data sources you should use, ask for clarity as soon as possible.

2. State the assumptions

Part of being a developer is making sound decisions in ambiguous contexts. Some aspects of the assignment will leave room for interpretation — this is likely intentional.

Avoid asking tons of clarifying questions. Instead, make reasonable assumptions whenever possible and state them in your code comments. Providing insight into your assumptions helps interviewers understand your work. Plus, it reflects well on your communication skills. 

3. Focus on core requirements

To make efficient use of your time, it's important to focus on the core requirements rather than “nice to have” features. As you decide what to build, divide your planned tasks into "core functionality" and "optional." Only return to the "optional" category if you finish earlier than expected.

Some candidates struggle to complete the functionality of their project because they spend too much time laying the groundwork. Boilerplate code and directory structures are important. However, don't get carried away — you'll be more successful if you start by creating what's absolutely necessary.

4. Test

As a professional developer, you'll need to write unit tests to ensure your code works as expected. These standards apply to your take-home project.

There's no need to write a comprehensive battery of tests, but I recommend writing a few unit tests and including some edge cases. It will improve your code quality and show that you know what it takes to write great software.

5. Write clean code

You may have a creative idea for how to solve a problem. But if your code is inefficient or difficult to follow, interviewers will doubt your technical abilities. 

These best practices can help you write clean code and catch mistakes:

• Use tools like prettifiers, linters, and memory leak detection tools

• Read your code carefully — tools don't catch everything

• Write modular code and follow the SOLID principles

• If you create a database (instead of using a JSON file), be sure to normalize it

• Keep scalability and robustness in mind

• Validate all inputs

• When in doubt, add code comments

To be clear, interviewers aren't expecting perfect code in your take-home project. However, incorporating these guidelines shows that you have the technical skills and discipline to do production-quality work.

Don't forget to enjoy the process!

If you've completed a degree or bootcamp to become a software engineer, I'm guessing it's because you love solving complex problems with code. To land a role where you can do this, there are many hoops you need to jump through, from writing your resume and submitting applications to preparing for interviews.

Only a small portion of the process involves what you enjoy most — building stuff!

So, if you're feeling anxiety or dread about the take-home project, remember why you want a software engineering job in the first place. You've spent months or years studying so that you can solve tasks like this one. The more you're able to connect to the joy of coding, the less arduous your take-home project will feel.

Remember: there's no need to overthink it! The skills you've honed in your studies, plus the tips I've shared today, are more than enough to help you complete a successful project.

Good luck, and stay tuned for more tips on how to ace your coding interview.

Happy learning!

– Fahim

I sincerely hope you have found value in these letters so far. I will say, writing every week has certainly been a fantastic learning experience for me.

So today, to commemorate the 2-month milestone (and celebrate the hundreds of you who have already subscribed), I want to do two things:

1. Count down the top three most popular posts so far (and share the background story and inspiration for each)

2. Invite you to ask any burning questions you have about learning to code!

Most of the newsletters I have written thus far were inspired directly by questions I have personally been asked by new coders. In my opinion, that makes for the most useful and valuable content. Plus, odds are that if you’re thinking it, someone else is too — so I really looking forward to hearing from you.

You are welcome to just respond or comment here, and I will plan on addressing your questions in upcoming newsletters!

Now without further ado, I’ll count down the three most-read letters so far:

#3

Why this letter?

I have been asked this question more times than I can count lately. New coders, CS students, and early-career developers can see the writing on the wall, and are concerned about their long-term career prospects. I don’t blame them for feeling this way.

That said, I stand by what I wrote in this piece. The reality is that with AI coding tools becoming more commonplace and powerful , it becomes even MORE important to master the fundamentals than ever before. Of course, there is plenty more to say on this topic — so stay tuned for more AI + Learn to Code discussions in upcoming newsletters!

Note: This is also a question I’ve been thinking about at Educative in terms of our own AI-enabled Learn to Code resources. The goal is to use AI to your advantage, while not letting it become a crutch in the learning process. If you are curious to get hands-on with foundational coding concepts with the help of AI, we have some cool courses over there that you might enjoy.

#2

Why this letter?

I have always loved coding lessons that show up when and where you least expect them. Here’s a bit of a counterintuitive one:

At the start of your learning journey, learning how to program is as much about training your brain to think like a developer as it is about actually learning literal code.

I count this particular story as one of those perfect little problem-solving lessons — and one of the first times I started to really understand how to “hack” a problem like a developer would. I hope you find it useful in your own journey!

#1

Why this letter?

I don’t know a single great developer who hasn’t struggled with fears around feeling smart enough at one point or another.

This topic clearly struck a chord, even helping spark this fantastic Reddit thread, which asked the question of “do you have to be smart to be a developer?”.

I absolutely love seeing the community weigh in and share their insights. To quote one of the posters:

In order to stay the course on a long journey of software development, the question is not, "am I smart?", the question is, "am I prepared to be made to feel stupid on a regular basis?"

I couldn’t have said it better myself!

That’s all for this week. Please comment with your questions if you have them, and I look forward to responding to them in the coming weeks! Until then…

Happy learning!

– Fahim

"Is learning to code hard?" (In fact, the last time I was asked this was less than 24 hours ago). 

It’s a popular question, but it’s also a misguided question. It's impossible to objectively claim whether learning to code is hard. Everything is subjective. Of course, it’s safe to expect that learning to code will have its challenging moments. But learning to code is also very attainable.

So if someone asked me “is coding hard,” I would tell them this:

Your personal learning journey is a function of the skills you need to learn and the time you have to study. 

Or, to put it more simply: all it takes is time and effort.

Today I want to go back to the question “is learning to code hard,” and unpack a few assumptions.

Whether they realize it or not, anyone asking this question is most likely trying to grapple with another question — and I'll share what that question is at the end of this blog.

But first, I want to share what you can expect from your learning journey based on your personal background.

Your learning curve = Time x Skills

Learning to code is all about building new skills, and it takes time to obtain those skills.

Depending on your background, you will have a different learning journey (and curve) than other aspiring programmers. Let’s break down what that could mean for you.

Skills you’ll need to become a developer

Some skills will differ depending on your specialization, but apart from that, the coding fundamentals remain the same. 

Many people start immediately by trying to learn a programming language, but I personally believe that starting with foundational problem-solving skills is the way to go.

Problem-solving is the core of what developers do. We understand problems and learn how to tell computers how to implement optimal solutions. Every successful developer has highly developed problem-solving skills, so you'll want to strengthen these skills from the start.

This involves training your brain to think like a coder, i.e. learning to solve problems algorithmically by breaking them down into their component parts.

Either after or alongside problem-solving, you'll learn a programming language and its basics: its syntax, functions, variables, and so on. From there, you'll learn the specialized tools that developers use to solve problems: data structures and algorithms. 

Another essential skill is debugging. As unpleasant as it may be, your code will suffer from bugs for various reasons. It's either going to behave unexpectedly or it won't even run. This is normal and to be expected. Debugging is just as essential as learning to code. (In case you missed it, check out my recent post on debugging secrets).

At this point, you've covered the coding basics, but the rest of your skill acquisition depends on your goals for career specialization.

Certain specializations will require more advanced skills than others. For example, let's zoom in on the math requirements. While a front-end web developer can do well with just basic algebra, machine learning engineers will need to learn Linear Algebra, etc.

Time it takes to become a developer

Learning to code could take anywhere from 12 weeks to six years. That's a big range because there are significant variables that can affect your learning progress. The biggest variable of all is simply the time you can commit to learning and practicing.

The person who has only 2 hours to study every week simply won’t learn as quickly as someone with 40 hours of study time. If you have less time to spare due to other commitments, it's more effective to practice often for shorter periods of time, than to fit your studies into infrequent cram sessions (e.g., 1 hour twice a week is better than 2 hours once a week).

If you're fortunate enough to have a lot of time and happen to pick up programming quickly, you might be able to build decent sized programs in as little as 12 weeks. However, you'd still need a lot more time to secure a job or become truly proficient as a programmer.

Are there other variables?

Skills and time are the most easily predictable variables. However, there are various other circumstances that may slow or accelerate your learning journey.

Just as with sports, there may be skills (or in the case of sports, genetics) that can help you learn coding more quickly. For instance, you may find that thinking like a programmer comes more naturally if you come from a background in analytical thinking, such as math, philosophy, logic, engineering, or even science. And of course, if you already have exposure to seeing code or programming languages, that will also help you ramp up more quickly.

Because they can either accelerate or slow down our learning process, it can be easy to think of unique circumstances as advantages or disadvantages, but I think that’s an oversimplification. 

To me, there's no benefit in attaching a positive/negative value statement to circumstances that you cannot change. These words are a product of comparing oneself with your perception of others — perceptions that may not be grounded in reality. (In fact, I would even argue that the more obstacles you overcome, the stronger programmer you will be in the long run).

Just as with learning any new skill, everyone will face unique challenges when learning certain aspects of programming. Some topics will come easier to you while others won't. This is true for every developer, no matter how “talented” they may be.

These challenges that lead to difficulty are what I like to call roadblocks.

There's truly no way to predict exactly when you will hit roadblocks, but you should expect that they will arise at various points along your journey. And while roadblocks may seem to slow your progress, just know that these dips or plateaus in your learning are actually the precedent to having breakthroughs. (In fact, this process is what educators call a productive struggle, something I talked about in a post a couple weeks back).

No matter our circumstances, the only difference between skilled developers and beginners is persistence and time.

Let’s answer the REAL question in your head

Now let’s revisit our original question: “is learning to code hard?”

I believe what people are really wondering when they ask this question is this:

Can I really manage to become a programmer?

And to answer that question, there's really only one way to find out.

How can we tell if someone can manage to become a chef? There's no diagnostic test that tells us this information. Even if there were a diagnostic test, what would it assess? A person's textbook knowledge of ingredients, food allergies, and the difference between stainless steel and cast iron isn't enough to make them a great chef. Neither is it enough to simply have them cook something and taste it.

The final product or the presentation can't tell us whether someone's a great chef because it's what happens behind the scenes that proves their greatness.

Excellent chefs deliver your meal despite any challenges they encounter in the inevitable chaos of the kitchen. They may have burnt the food, used salt instead of sugar, or gotten new oil stains, but you still wouldn't know the difference based on the quality of the dish in front of you. 

The only true way to know if you can become a programmer is to try it and stick with it. This means persisting despite any struggle along the way. Only when you get past that baking period (pun intended) can you know if you have what it takes to be a programmer. 

On that note, you can take your first steps at the problem-solving foundations of coding with a Taste of Code. And if you're ready for more, we have plenty more hands-on, AI-powered courses for beginners looking to build a strong foundation in their career. 

Happy learning!

– Fahim

Today, I want to give a gentle introduction to one of the most effective debugging strategies that will be relevant throughout your career: print statement debugging.

If you have already written an entire program, then you're ready for this tutorial. If you haven't, feel free to join us and get a sneak peek of this skill that's waiting for you later in your learning journey.

What is print statement debugging?

Print statement debugging is a fantastic way to trace the behavior of a program to understand where an error occurred, and how to fix it. (Another perk: it requires no additional tools or complex setups.)

This debugging technique involves placing print statements at various positions in your program. 

These print statements help elucidate your code's behavior by generating outputs that reflect:

• The values of variables

• Flow of execution

• The state of your program at various points

These print statements are additional lines that you write into your program. If you owned a coffee shop, you can think of print statements as shift supervisors who are present at the shop, keeping you updated on the status of operations. 

Of course, print statements are not placed randomly throughout code. You should place statements strategically at key areas where the state changes or important operations occur, such as:

• Before and after loops

• Inside conditional blocks

• At the beginning, middle, and end of functions

For example, suppose we have written a program that calculates the sum of numbers in a list but it’s not returning the expected result. Here’s the code:

We can add a print statement in the code to help us notice what's happening in the program. 

This added print statement will show us the value of the number being added and the intermediate value of the total. This helps us trace the execution and verify if the logic inside the loop is correct.

Using print statements for debugging

In its simplest form, the steps to using print statements for debugging are: 

1. Identifying key areas

2. Inserting print statements

3. Running the program

4. Analyzing the output

5. Identifying the issue

6. Fixing the bug

7. Removing the print statement 

Here are some best practices to keep in mind:

Use descriptive messages

Instead of just printing variable values, include context about what those values represent. For example:

Track execution flow

Use print statements to trace the flow, especially in complex logic with multiple branches. For example:

Be strategic (don’t overdo it!)

Overdoing print statements can affect the performance of your application — especially when you're working in the professional environment.

In professional development, you'll be working on massive codebases where performance is likely a priority. Instead of using print statements, you may be using a related technique called logging, however you'll still need to decide where to place logging to help monitor a program. Figuring out exactly where to put print statements without overdoing is not so much a science as it is an art. But the more you do it, the better your judgment will get.

Example: Code with a logical error

Let's try with an example.

Suppose we have a function that checks if a list of numbers contains any even number(s). The code is intended to return True if there is at least one even number and False otherwise. 

However, there is a logical error:

Expected output: True
Actual output: False

To debug this, we can add print statements to understand the flow of execution and the values being checked:

Analyzing the output

By running the modified code, we get the following output:

The output shows that the function returns False after checking only the first number, 1. This indicates that the else branch is causing an immediate return of False, even if there might be even numbers later in the list.

Corrected code

To fix this logical error, we should only return False after checking all numbers in the list:

Corrected output

Now, the output correctly identifies that there is an even number in the list:

Using print statements, we traced the execution flow and identified that the function was returning False. This allowed us to correct the logic and ensure the function worked as required.

Becoming a professional debugger 

Becoming a developer means becoming a debugger too. And print statements are a great way to start getting methodical with debugging. Once you've understood print statements and strengthened your debugging skills, you'll be able to move on to logging for the professional development environment. 

Either way, the best way to grow your debugging skills is by making mistakes and getting your hands dirty with debugging.

If you'd like to learn more about debugging, we've launched a great beginner-friendly course that covers various debugging strategies: Mastering Debugging: Techniques for Efficient Code Diagnosis.

Happy debugging!

– Fahim

This is a classic case of beginner's luck: when circumstances grant an inexperienced person success that is disproportionate to their novice skill level. 

Beginner's luck usually gives people a false sense of confidence. As a new coder, imagine you solved your first 10 coding challenges with 100% success rate, or you wrote your first five programs without a single bug. This is all well and great, but it's circumstantial — and it does run out before too long. 

Losing your beginner's luck can be disheartening. Things don't come easily anymore, and unfortunately, this is the point when some beginners quit. It may seem counterintuitive, but losing your luck means you've entered a more productive part of your learning journey.

Today I'll talk about the idea of the productive struggle — and explain why losing your luck is actually one of the most important parts of the learning curve:

1. Why beginner's luck ends (and why that’s a good thing)

2. Embracing the entire learning curve

3. Setting up for long term success

Why beginner’s luck ends

The only way to master any skill is with time and plenty of practice (and failures). This is especially true for coding.

When I first started learning to use pointers in C, it seemed easy. But over the course of a few weeks, I realized pointers were a significant and even mind-bending concept that would take months and years to master. 

As soon as beginner's luck starts running out, you may feel that you don't know what you're doing wrong. You can feel stuck and lose momentum. You may even feel your progress is moving backwards. 

What you may not realize is that this shift is not a matter of luck at all — you’ve just reached a new phase of the learning curve.

Learning to program is like hiking up a mountain with different paths. All the paths reach the same summit, but you'll experience steepness in different parts of the journey. Every path has its own challenges. You may not know when you'll encounter a steep incline, but when you do, it's going to be an arduous climb (and you'll have to persist despite it).

The steeper part of the learning curve

Some developers hit dips in their learning and think, "Coding isn't for me." But this is far from the truth. Everyone encounters obstacles. It may feel counterintuitive, but struggling in the learning process is actually very effective for your learning. 

There's actually a term educators use for this: productive struggle. By actively engaging in challenging (even uncomfortable) learning activities, our brains even produce myelin, which encourages skill retention and effective signaling in the brain.

There's a sweet spot between ease and overwhelm, where you need to be challenged by a concept in order to make a breakthrough in your learning. However, to make the most of that sweet spot, it's essential that you:

• Remain clear on what your goal is

• Get support when you need it

• Have a healthy relationship with failure 

A lot of people even give up programming prematurely because they hit an incline and don't have mentors to tell them they're a healthy part of the learning process. Imagine someone started to lift weights and gave up because they were sore, and thought this meant they weren't good. This is when a coach should be there to tell you, "Hey, becoming sore is part of the process. It's normal and means you're growing — that’s literally the feeling of your muscles breaking down and growing back stronger. In some cases, the soreness won't go away for a week, but you'll still keep getting better."

Any professional developer gets stuck on countless concepts and bugs throughout their coding journey. The only difference is that successful programmers persisted. And sometimes, persistence just means taking a nap (in other words, taking a break).

It’s not the wrong path. Keep pushing ahead.

When you hit a roadblock and lose momentum, it's best to stick to that path that you’re already on than to abandon your progress for a different one.

I've seen many new developers switch programming languages just because they lost momentum. This can be tempting if you're self-taught and have an abundance of choices available when it comes to learning your first programming languge. 

Switching tracks like this ultimately slows your growth, making you the jack of all trades and master of none. If you take up Python and get stuck, you might think, “Maybe I would've been better off with Java,” and switch over. At first, you might find that you’re picking up Java faster, further validating your belief that Python was the wrong choice. In reality, the only reason you'd feel more comfortable with the new language in this situation is because you’re repeating the beginner steps in another language. (After all, the skills you learn in one language do transfer over to the other, which is why it doesn’t really matter which programming language you learn first). 

No matter which language, skill, or concept you're learning, you can expect to hit a steep incline sooner or later (and several times). When you do, your key to success is maintaining resilience and embracing the struggle.

Luck alone won’t make you a pro

When I learned my first programming language, I was confident that I could build complex apps like Microsoft Word quickly. After all, this program would just need a few functionalities, of which I already knew a few (how to get input and save a file).

As soon as I tried building a text editor myself, the reality hit quickly that it wasn't that easy. In reality, every successful product is a complex software backed by a lot of engineering. And while building basic programs is a good start, it's only the beginning of building job-ready skills.

It can be easy to believe that if you've picked up a language quickly, you can become a professional developer quickly, too. The truth is that successful developers have gone much farther and spent more time not only learning a language. They've understood the core of data structures and algorithms that help them solve problems optimally. As a professional developer, your main task is not even using a programming language: it's problem-solving. In the problem-solving process, you really only use the programming language at the very end, to translate your solution into executable instructions for the computer.

Coding is an amazing career, and it will constantly challenge you. Once you're in the professional world, you'll need to learn to leverage more complex computer science skills to apply your current tools to the fullest. You can worry about these more complex skills later down the line, but in the meantime, I hope you enjoy the learning process — even when you have to move uphill.

Braving the summit

You don't need luck to succeed in your coding journey. The true key to success is persistence. 

Inclines in the learning curve can be frustrating and demoralizing, yet we all encounter them — and they're a good thing. Every professional programmer I've talked to can recount days where they were stuck because of an obstacle in their learning, despite endless Googling and nail-biting. 

Even if you're stuck, remember that you're still on the same path as the greats. Take a break, ask for help, or retrace your steps to find the root that's tripping you up. When you're making mistakes or feeling stuck, breakthroughs are just around the corner. You will find the way forward as long as you try. 

As a reminder, you can learn everything you need, from your first line of code to your first job with Educative's Learn to Code courses. 

Happy learning!