Consistent practice is one of the most effective ways to improve your coding skills. So in addition to the core coding curriculum, you can now keep your programming skills sharp by solving a fun new coding challenge every single day.

Each day at midnight US Central time, a new programming puzzle will unlock on freecodecamp.org and the freeCodeCamp mobile app that you can solve in JavaScript and Python.

How to Start Solving Daily Coding Challenges

On the freeCodeCamp Mobile App:

1. Download the freeCodeCamp mobile app from the Google Play Store or the Apple App Store and open it.

2. Don’t forget to sign in if you want to save your progress. Then find todays challenge at the top and click “Start the challenge”:

3. Choose your preferred language:

4. Read the challenge instructions:

5. Write the code:

6. Pass the tests:

And voilà! You’ve completed the challenge.

On the Website:

1. Go to freecodecamp.org and make sure you’re logged in if you want to save your progress. Then scroll down to find the coding challenge of the day and click “Start”:

2. Choose your preferred language at the top

3. Read the challenge instructions, write the code, and pass the tests:

What if I Missed a Day?

Don’t worry if you miss a challenge. Both the mobile app and website include an archive page, where you can browse and complete past challenges at your own pace:

Start Your first Challenge Today

Today’s challenge is waiting for you. Open the freeCodeCamp app or head to freecodecamp.org to complete it. 🚀

The truth is, you cannot truly learn programming without writing code. It is through this process that you learn new things and discover how small errors, like missing a quote or space, can frustrate you for hours.

No course can teach you the intricacies of Python the way finding and solving errors does.

That's why coding challenges are important if you are starting your coding journey. They help you implement your knowledge in practice and boost your confidence.

So to help you start coding more, here are eight Python challenges you can try as a beginner.

And here's a tip: really try to solve the challenge on your own after reading through the question/prompt. If you get stuck, then you can look at the code below and the explanation to help you figure it out.

Here Are the Challenges:

1. Python Challenge #1: Check if a List is Sorted
2. Python Challenge #2: Convert Binary number to decimal
3. Python Challenge #3: Loves Me, Loves Me Not
4. Python Challenge #4: The Tribonacci Sequence Challenge
5. Python Challenge #5: Hide a Credit Card Number
6. Python Challenge #6: SpongeCase
7. Python Challenge #7: Caesar Encryption
8. Python Challenge #8: Is the Product Divisible by the Sum?

All of these challenges help you in enhancing your problem-solving and algorithmic thinking skills. You'll also gain experience with writing and testing code to ensure correctness and efficiency.

Python Challenge #1: Check if a List is Sorted

The challenge: Write a function that checks whether a given list of numbers is sorted in either ascending or descending order.

Here's the code solution:

def is_sorted(lst):
    asc, desc = True, True
    for i in range(len(lst) - 1):
        if lst[i] > lst[i + 1]:
            asc = False
    for i in range(len(lst) - 1):
        if lst[i] < lst[i + 1]:
            desc = False
    return asc or desc

Code explanation:

In the above code, we define a function is_sorted that takes in a list as a parameter. We initialize two booleans, asc (for ascending) and desc (for descending) to True.

We then iterate through the list. If the ith element of the list is greater than the (i+1)th element, the asc flag is set to False, indicating that the list is not sorted in ascending order.

Then we iterate through the list again. If the ith element of the list is smaller than the i+1 th element, the desc flag is set to False, indicating that the list is not sorted in descending order.

If any element is found to be greater than the next element, the asc flag is set to False. Within the loop, we check to see if the ith element of the list is greater than the i+1 th element.

for i in range(len(lst) - 1):
    if lst[i] < lst[i + 1]:
        desc = False

We return True if either asc or desc is True. This means that the list is sorted, either in ascending or descending order.

Python Challenge #2: Convert Binary Numbers to Decimal

The challenge: Write a function that converts a binary number to its decimal equivalent.

Here's the code solution:

def binary_to_decimal(binary):
    decimal, i = 0, 0
    while(binary != 0):
        dec = binary % 10
        decimal = decimal + dec * pow(2, i)
        binary = binary//10
        i += 1
    return decimal

Code explanation:

In the above code, we define a function binary_to_decimal that takes a binary number as a parameter. We then initialized the variables decimal and i to 0.

The variable decimal is used to store the resulting decimal value and the variable i represents the current position when processing a binary number, starting from 0.

We loop through each binary digit until all digits of the binary number become 0.

while binary != 0:

Now, we extract the least significant digit of the current binary number using the modulus operator.

dec = binary % 10

And then we convert the extracted digit to its decimal equivalent by multiplying it by 2 power raised to i.

decimal = decimal + dec * pow(2, i)

Then we remove the processed digit:

Binary = binary // 10

And increment the position i to process the next binary digit:

i += 1

Finally, we return the calculated decimal value.

Python Challenge #3: Loves Me, Loves Me Not

The challenge: Given an integer n, print a string that alternates between the phrases "Loves me" and "Loves me not" for each number from 1 to n.

The sequence should start with "Loves me" and alternate accordingly.

Here's the code solution:

def phrase_loves_me_not(n):
    phrases = []
    for i in range(1,n+1):
        if i % 2 != 0:
            phrases.append("Loves me")
        else:
            phrases.append("Loves me not")
    return ", ".join(phrases)

Code explanation:

We define a function phrase_loves_me_not that takes a single parameter n.

Then, we initialize an empty list, phrases, which stores the result for each number from 1 to n.

We iterate from 1 to n inclusive:

for i in range(1, n+1):

We then check for odd indices. If the number is odd, we append “Loves me” to the list ‘phrases’.

if i % 2 != 0:
    phrases.append("Loves me")

For even indices, we append “Loves me not” in the list ‘phrases’.

else:
    phrases.append("Loves me not")

We then use the join method to concatenate all the elements in the ‘phrases’ list into a single string and return that string.

Finally we return the resulting string.

return ", ".join(phrases)

Python Challenge #4: The Tribonacci Sequence Challenge

The "Tribonacci sequence" challenge is a twist on the famous Fibonacci sequence, where each number is the sum of the preceding three numbers.

For example, 0, 1, 1, 2, 4, 7 …

The challenge: Write a function that returns the nth number in the Tribonacci sequence.

Here's the code solution:

def find_nth_tribonacci(n):
    # Base cases for n = 0, 1, 2
    if n == 0:
        return 0
    elif n == 1 or n == 2:
        return 1
    # Initialize the first three terms of the Tribonacci sequence
    a, b, c = 0, 1, 1
    for i in range(3, n + 1):
        next_term = a + b + c
        a, b, c = b, c, next_term
    return c

Code explanation:

First, we define a function named find_nth_tribonacci which takes a number n as a parameter.

We then define base cases as:

• If n is 0, the function returns 0.
• If n is 1 or 2, the function returns 1.

Note: These conditions handle the starting values of the Tribonacci sequence.

We then initialize the first three values of the Tribonacci sequence, from n = 0 to n = 2.

a, b, c = 0, 1, 1

Then, we iterate from 3 to the number n, where we calculate the next term by summing the three preceding terms (a, b, and c). We also update the values of a, b, and c to the next set of three terms in the sequence.

for i in range(3, n + 1):
    next_term = a + b + c
    a, b, c = b, c, next_term

At the end of the loop, c holds the value of the nth term in the Tribonacci sequence, so we return c.

return c

Python Challenge #5: Hide a Credit Card Number

Write a function that takes a credit card number and transforms it into a string where all digits except the last four are replaced with asterisks.

Here's the code solution:

def mask_credit_card(card_number):
    card=str(card_number)
    return "*"*(len(card) - 4) + (card[-4:])

Code explanation:

We define a function mask_credit_card that takes card_number as a parameter.

First, we convert the number into a string.

card = str(card_number)

Then to mask the card_number, we generate a string of asterisks with a length equal to the total number of digits in the credit card minus four. This masks all digits except the last four digits.

"*"*(len(card) - 4)

Then, we use the slice operation to retrieve the last four digits of the credit card number.

card[-4:]

Finally, we return the concatenated result of the asterisk string and the last four digits of the card number.

return "*"*(len(card) - 4) + card[-4:]

Python Challenge #6: SpongeCase

SpongeCase is a style of text where letters alternately appear in lower and upper case. For example, the word in spongeCase would be sPoNgEcAsE.

The challenge: Write a function that converts the given string into spongcase.

Here's the code solution:

def to_spongecase(text):
    result = []
    i = 0
    for char in text:
        if char.isalpha():
            if i % 2 == 0:
                result.append(char.lower())
            else:
                result.append(char.upper())
            i += 1
        else:
            result.append(char)

    return "".join(result)

Code explanation:

We define a function to_spongecase that takes a string text as a parameter.

Then we initialize an empty list result, and counter i to 0.

We iterate the function over each character char in the input string and check if the current character is alphabetic.

for char in text:
    if char.isalpha():

If the character at index i (adjusted for only alphabetic characters) is even, we append the result with the character converted to lowercase.

if i % 2 == 0:
    result.append(char.lower())

If the index is odd, we append the result with the character converted to uppercase.

else:
    result.append(char.upper())

After processing an alphabetic character, the index i is incremented.

In case of non-alphabetic characters, append them to the result list as they appear, without alternating their case.

After all characters have been processed, we combine them back into a string using join .

return "".join(result)

Python Challenge #7: Caesar Encryption

Caesar Encryption (also known as the Caesar Cipher) is a simple encryption technique that works by shifting the letters in the plaintext message by a certain number of positions.

The challenge: Create a function that has two parameters – a string to be encoded and an integer representing the number of positions each letter should be shifted.

Here's the code solution:

def caesar_encryption(text, shift):
    result = ""
    for char in text:
        if char.isalpha():
            start = ord('A') if char.isupper() else ord('a')
            shifted = (ord(char) - start + shift) % 26 + start
            result += chr(shifted)
        else:
            result += char
    return result

Code explanation:

We define a function caesar_encryption that takes two parameters: a string text and an integer shift.

Then we initialize an empty string to accumulate the encoded characters.

result = ""

Next, we loop through each character in the input string text.

For alphabetic characters, we calculate the new character after applying the shift.

Then we add the non-alphabetic characters like numbers to the result unchanged.

for char in text:
    if char.isalpha():
        start = ord('A') if char.isupper() else ord('a')
    shifted = (ord(char) - start + shift) % 26 + start

So how do we calculate the new character?

We determine the ASCII value of 'A' for uppercase or 'a' for lowercase letters.

First, convert the character to its ASCII code, normalize to a 0-25 range by subtracting the start and adding the shift, and then wrap it around using modulo 26 to ensure it stays within alphabet bounds.

Finally, we add the start back to map it to the correct ASCII range.

Convert the shifted value back to a character using chr() and add to the result.

result += chr(shifted)

After all characters are processed, return the encoded string.

return result

Python Challenge #8: Is the Product Divisible by the Sum?

The challenge: Create a function that takes a list of integers and returns whether the product of those integers is divisible by their sum or not.

The function should return True if the product of all the integers in the list is divisible by their sum and False otherwise.

Here's the code solution:

def is_product_divisible_by_sum(numbers):
    if not numbers:
        return False

    product = 1
    summation = 0
    for num in numbers:
        product *= num
        summation += num

    if summation == 0:
        return False

    return product % summation == 0

Code explanation:

First, we define a function is_product_divisible_by_sum, which takes a list of integers, numbers, as a parameter.

Then, we check if the input list numbers is empty. If it is empty, return False.

if not numbers:
    return False

Else, initialize two variables: product to 1 and summation to 0.

product = 1
summation = 0

Iterate over each number in the list to calculate the total product and sum of all numbers in the list.

for num in numbers:
    product *= num
    summation += num

After calculating the sum, check if the sum is zero. Dividing by zero is undefined in mathematics and would raise an error in programming, so return False.

if summation == 0:
    return False

Finally, check if the product is divisible by the sum using the modulus operator %.

Here, if the remainder is zero, that is the product is perfectly divisible by the sum, return True. Otherwise, return False.

return product % summation == 0

Wrapping Up

These are just a few challenges that can help you build your problem-solving skills. I would suggest you try these challenges on your own.

If you want to solve more challenges, you can try out the following platforms:

• Leetcode
• Programiz PRO Community Challenges
• Exercism

They are free and help you build your logical skills with hands-on experience.

Happy Coding!

If you are a programmer, then this is something you should do for yourself. Programmers need to deal with all sorts of problems almost every day.

Most importantly, solving problems in an efficient manner can make you much more productive. And solving challenging problems helps us do that.

You can watch this complete video on YouTube as well if you like 🎥

Why Should You Develop Your Problem-Solving Skills?

These days, technology is developing rapidly, and we are seeing some amazing changes and improvements almost every day.

Whenever we talk about technology, a buzzword appears in our mind – and that is coding or programming. Now, coding/programming isn't just about solving different kinds of problems using different programming languages, but it's a large part of what you'll do as a developer.

The fields of Web development, Machine Learning, Artificial Intelligence, Augmented Reality, App Development, and many others require strong problem-solving skills.

There are many popular websites that help you do that by providing various types of problems where you need to apply your analytical and mathematical skills to solve each problem using programming languages.

I am going to provide you with a list of coding challenge websites that will help you become more advanced day by day.

Keep in mind that these websites are useful for everybody, whether you are new to coding challenges or you are a professional programmer and so on.

Contents

1. beecrowd
2. HackerRank
3. Codeforces
4. LeetCode
5. Kaggle
6. CodeChef
7. AtCoder
8. Topcoder
9. Coderbyte
10. Project Euler
11. Codewars
12. SPOJ
13. CodinGame
14. GeeksforGeeks
15. Toph
16. LightOJ
17. Exercism
18. Online Judge
19. HackerEarth
20. Code Jam - Google's Coding Competitions
21. ICPC

Best Coding Challenge Websites

1. beecrowd (Formerly URI)

beecrowd is perfect for those who have just started solving coding challenges and are looking for a beginner-friendly website. It used to be named URI, so there is a chance that you are already familiar with this site as URI.

If you want to solve problems in a specific category, then you're in luck as this website also offers that.

Here is an image of a Strings problem set. You can also filter the problems by the ID (#), name (NAME), Subject (SUBJECT), solved (SOLVED), and so on. Beginners like these features very much.

On this website, you can also take part in different programming contests, and check your global ranking, country-wide ranking, and university-wide ranking.

Also, you can check your progress, how many days have passed after signing up, how many problems you have solved, how many points you have got, and more.

You will also get a nice profile page that looks beautiful as well. 😊 I used to practice solving problems on this website when I was just starting out my CP (Competitive Programming) journey. Not to mention, I got the 3rd position among 1250 students back then at my university. 🎉

You can also check out my beecrowd profile here.

2. HackerRank

HackerRank is one of the most popular coding practice websites out there. This is a nice platform for everyone, especially beginners.

The website looks nice and polished, and the users who come here the first time don't struggle when navigating throughout the website, so that is definitely a positive thing here.

HackerRank offers different portals for companies and developers. If you are learning to solve problems, then you will choose the For Developers section.

If you want to learn any specific topics or programming languages, then this website is the perfect place to get started in that. You can prepare yourself by topics. You can also take their certification exam and stand out from the crowd. I have already passed their Python (Basic) certification exam.

You can also choose preparation kits from there, and prepare yourself before your interview if you want. Moreover, you can take part in programming contests.

Here, you will also get a nice personal profile page. You can check out my profile from HackerRank here.

3. Codeforces

Codeforces is one of the most used and well-known coding challenge and practice websites in the world, and it is sponsored by Telegram. Especially if you know about CP (Competitive Programming), then there is a high chance you have heard a lot about this website.

Although the website might look a little bit different to newcomers, you won't need much time to get used to it. You can train yourself by solving problems of different categories, difficulty levels, and so on.

Competitive programmers have ranks based on their successful results in programming contests. If you have heard about the RED coder / PURPLE coder, etc, then it is definitely from Codeforces.

You can get the idea of the ranking system on Codeforces from the image above. For more details, you can check out this blog entry.

Codeforces arranges contests regularly each week, and they are categorized into div 1, div 2, div 3 and div 4. They also arrange global round and educational round contests. You can get the timeline of the contests directly from here.

Codeforces also provides a nice user profile on their website. You can check mine here as well.

4. LeetCode

If you are familiar with the FAANG (Facebook, Apple, Amazon, Netflix, Google) buzzword, then you should definitely know about this website! If you want to practice for your coding interview for the big giant tech companies like FAANG, then they all do leetcoding.

You might think that I have made a typo in the above paragraph. No, I didn't. LeetCode has become this popular among people who target FAANG and those who are working on their problem solving skills. Taking part in contests on LeetCode has become common, and people call it leetcoding!

Here, you can solve a lot of problems, and filter the problems by the lists, difficulty levels, status, and tags.

You can also choose problems regarding Arrays, Strings, Hash Tables, Dynamic Programming, and many other categories.

As I mentioned above, you can also take part in programming contests. The only thing that makes LeetCode different is that it is based on Algorithm practice. Yeah, LeetCode is not like any other coding website, because it focuses on algorithm practice alone.

You do not need to provide the full code for solving a problem here, you just need to crack the solution by providing a valid algorithm using any popular language that can solve the problem.

You also get to see how your code performs among others, how much space and time it takes, and so on.

Most importantly, LeetCode has an amazing discussion group where people talk about their problems, solutions, how to improve their algorithms, how to improve the efficiency of their code, and so on. This is one of the most powerful features of LeetCode.

One sad part about LeetCode is that you will not get every feature for free! Yeah, it's true. You have to pay for it monthly or yearly to unlock all its features. There are a lot of problems you will find locked on the website. You can not unlock them if you do not purchase the premium plan.

If you are just starting your algorithm journey on LeetCode, then actually you don't need to worry about their premium plans as the free version will be more than enough for you.

Later, if you want to become more serious, then paying for their premium subscription will be a big deal actually as you'll get a ton more features. This is very much helpful, and includes things like top interview questions, top FAANG questions, video explanations, and more.

You also get a nice profile page on LeetCode. You can check out mine here.

5. Kaggle

I was pretty confused before writing this section, as Kaggle is not a typical website for coding practice. This website is basically for Data Science, and it's one of the most popular websites out there for this.

Kaggle is an online community platform for data scientists and machine learning enthusiasts.

It is a popular crowd-sourced platform to attract, nurture, train, and challenge Data Science and Machine Learning enthusiasts from all around the world to come together and solve numerous Data Science, Predictive Analytics, and Machine Learning problems.

So if you are interested in Data Science, then you should check this website. Here you can check others' notebooks, submit your notebook, join in the contests, improve datasets, and so on.

Kaggle allows users to collaborate with other users, find and publish datasets, use GPU integrated notebooks, and compete with other data scientists to solve data science challenges.

Also, if you are interested in data science, but don't know where to start, then don't worry! Kaggle has got you covered. You can check their learning section where they have many free courses which will teach you a lot of stuff from the beginning.

✨ BONUS: If you want to learn more then I'd suggest that you complete the data science playlist from freeCodeCamp's YouTube channel.

Kaggle also provides rankings and a nice user profile. You can check out my profile here.

6. CodeChef

CodeChef is another popular Indian website like HackerRank where you can solve a lot of problems, take part in contests, and so on.

You can filter the problems based on different categories and solve them using any of the most popular programming languages.

They also have a learning section on their website where you can learn how to solve problems in a systematic way. This is super helpful, especially for beginners.

In their learning section, you can choose self-learning, mentored learning, and doubt support. Some of them are free of charge, but in some courses, you have to pay before you can start them.

This website also provides user ranking including the global ranking and country-wide ranking. They also provide a user profile on their website. You can check out mine here although I am not active on most of the websites right now. 😅

7. AtCoder

AtCoder is a programming contest website based in Japan. Makoto Soejima (rng_58) who is one of the former admins and problem writers from Topcoder is a founding member of AtCoder.

On this website, you can take part in different programming contests. They held regular programming contests on Saturdays and Sundays. Also, you can solve problems from previously held programming contests.

I have seen a lot of people regularly participate in the programming contests and solve problems previously used in the contests regularly by solving problems on AtCoder. I also tried that for a while to check the efficiency, and truth to be told, it was really effective.

Here you can also check the global ranking. Here you will also get your own profile page where you and others can see your global ranking and so on.

8. Topcoder

Topcoder (formerly TopCoder) is a crowdsourcing company with an open global community of designers, developers, data scientists, and competitive programmers. Topcoder pays community members for their work on the projects and sells community services to corporate, mid-size, and small-business clients.

Here you can earn, learn, and do a lot more in their MVP program. For earning, you can participate in five different tracks, become a copilot, become a reviewer, and also get a freelance contract gig through Topcoder Gig Work.

Personally, I feel this website is a little bit overwhelming for beginners. You can get more details in the YouTube videos I have made for you.

9. Coderbyte

Coderbyte has a huge collection of problems that you can solve. They also offer a challenging library, starter courses, interview kits, career resources and so on.

To get all the features, you need to buy a subscription plan from them. I personally liked their interview kit a lot.

Here you will also get a personal profile page.

10. Project Euler

Project Euler is a series of challenging mathematical/computer programming problems that will require more than just mathematical insights to solve.

Project Euler is a great website for solving mathematical challenging problems. But solving a problem on this website requires more than just simple mathematical knowledge.

If you want to solve mathematical problems in a more analytical way, then this website will come in handy.

11. Codewars

Codewars is a coding challenge website for people of all programming levels. It claims to have a community of over 3 million developers.

One of the biggest benefits of this website is that it is highly focused on algorithms like LeetCode. Moreover, if your goal is to get very good at writing clean and efficient programs, then this website can be a great asset to you.

In Codewars, you will see Kata and Kyu a lot.

Kyu (or Kyū) indicates the number of degrees away from master level (Dan). This is why they count downward. Once you reach master level, we count upward. Black belts in martial arts are Dan level.

On Codewars, kata are code challenges focused on improving skill and technique. Some train programming fundamentals, while others focus on complex problem solving. Others are puzzles meant to test your creative problem solving, while others are based on real world coding scenarios.

If you want to know more about how the ranking system works on Codewars, then simply check their docs here.

On Codewars you will also get a nice profile page like mine. Keep in mind that I haven't solved that much on this website; therefore my profile page would seem empty. 😅

Additionally, I find their leaderboard page quite amusing.

12. SPOJ

SPOJ is a website that contains huge problems for solving. It claims to have 315,000 registered users and over 20,000 problems.

According to GFG,

You can start solving problems with maximum submission and follow or check the submission of good coders here. Once you solved around 50-70 problems and build some confidence, you can participate in different contests.

Their problem set is also quite amusing.

You will also get a nice user profile page here which you can use to showcase your problem solve skills.

13. CodinGame

In CodinGame, you can improve your coding skills with fun exercises in more than 25 programming languages.

It is a good website for intermediate and advanced software engineers to have fun while continuing to keep their skills sharp. Also, the challenges are gamified and the multiplayer access means that users can challenge friends and coworkers.

14. GeeksforGeeks (Popularly known as GFG)

You might wonder why I am including GFG in this article as it only provides algorithms, tutorials, and so on.

Well, that's not all they offer. Yes, GFG is pretty popular for its tutorials, algorithms, and so on, but they also provide a nice problem-solving platform here.

You can also filter the problems as you see fit for yourself.

You will also get your profile page where you can show your progress in problem solving on the GFG website.

15. Toph

Competitive programmers participate in programming contests and solve many problems on this website. This website is kind of special to the Bangladeshi people as the Bangladeshi universities arrange many programming contests through it.

You can solve problems in different categories on this website, and they also offer you a nice profile page. They also provide rankings based on your performance in the programming contests.

If you are a complete beginner in problem solving, then this website can help you a lot in starting your problem solving journey.

16. LightOJ

In LightOJ, you can solve a lot of categorized problems. It is highly based on solving algorithmic problems. Their problems are categorized as below:

• LightOJ Volumes
• Warm-Up
• Advanced Search Techniques
• Database
• Data Structures
• Divide And Conquer
• Dynamic Programming
• Fast Fourier Transform
• Flow/Matching
• Game Theory
• Geometry
• Graph Theory
• Greedy
• Math
• Matrix
• Parsing/Grammar
• Recursion/Branch and Bound
• String

They also provide you with a nice profile page where you can see your activities. It might seem odd, but sometimes I find this website better than LeetCode in some cases. Moreover, everything you do on this website is completely free of cost!

17. Exercism

You can develop your programming fluency in 57 different programming languages with their unique blend of learning, practice and mentoring.

Exercism is completely free of cost, and it's built by people like us. You can also contribute or donate to them to support their amazing service for free.

They also provide a very nice user profile page which also shows everything you have done on their website, starting from publishing to maintaining.

On their tracks page, you will get a list of 57 different programming languages where you can start your practice.

Solving problems on their website seems super fun to me. I really liked the way they manage their website.

18. Online Judge (Commonly known as UVa)

This is one of the oldest websites out there for solving programming-related problems. I still find it to be a very hard website for beginners. The UI and navigation of the website are also very old.

All of the questions come with a PDF here. You need to download the PDF file of the problem if you want to solve problems as they do not offer a direct preview of the questions.

They have a lot of problemsets on their website. I still find a lot of users using this website nowadays. Therefore, I mentioned it here.

19. HackerEarth

HackerEarth is an Indian software company headquartered in San Francisco, US, that provides enterprise software that helps organisations with their technical hiring needs. HackerEarth is used by organizations for technical skill assessment and remote video interviewing.

You can practice your problem solving skills from their practice page. Also, you can participate in programming challenges and hackathons from their challenges page.

Their interview prep section is quite amazing. You can take part in the mock assessments for the Adobe Coding Test, Facebook Coding Test, and Amazon Coding Test.

They also provide a nice user profile for everyone.

20. Code Jam - Google's Coding Competitions

Google Code Jam is an international programming competition hosted and administered by Google. The competition began in 2003. The competition consists of a set of algorithmic problems which must be solved in a fixed amount of time.

If you are interested in taking part in the Code Jam contests, then their archive section is full of amazing resources for you where you can get the earlier questions and practice them.

They also offer a lot of prize money in their contests. An example can be:

Out of thousands of participants, only the top 25 will head to the World Finals to compete for the title of World Champion and cash prizes of up to $15,000. And there will be plenty of other prizes to go around — the top 1,000 competitors will win an exclusive Code Jam 2022 t-shirt.

21. ICPC - International Collegiate Programming Contest

ICPC is one of the most prestigious programming contests in the world.

The International Collegiate Programming Contest, known as the ICPC, is an annual multi-tiered competitive programming competition among the universities of the world.

Who is eligible for ICPC?

ACM/ICPC is a team-based competition with certain requirements to the participants: only post-secondary students and first-year post-graduate students no older than 24 are eligible; each team consists of three members. One can participate in the finals no more than twice and in the regionals no more than five times.

Personal Opinion

If you are a complete beginner, then start with beecrowd. If you want to start problem solving along with learning a specific programming language, then start with HackerRank.

After solving almost 50+ problems on beecrowd or HackerRank, start solving problems on Codeforces. The first time, you won't be able to do that well in the programming contests on Codeforces, and that is completely okay – it is natural. You just need to try regularly. The questions might seem pretty hard to you, but it'll become easier day by day after solving problems continuously.

You can participate in AtCoder the day you start solving problems on Codeforces. You can also try CodeChef, but I find Codeforces is enough in this case.

This will prepare you for the ICPC and Code Jam. Don't forget to solve the earlier questions on Code Jam.

If you want to gain expertise in Data Science, then simply go for Kaggle.

If you want to gain expertise in Algorithms, then LeetCode, and LightOJ are your only places. GeeksforGeeoks will also help you in this aspect.

For LeetCode, get some help from Nick White. His LeetCode Solution playlist has 189 videos as of today, and you will learn a lot from him, trust me!

Another good resource is Neetcode where you can get curated problems and their solutions from LeetCode. The official YouTube channel of Neetcode is also a great channel.

Additional Websites

You might find the websites below useful too!

⭐ StopStalk

This website retrieves your friends' recent submissions from various competitive websites (Such as Codeforces, SPOJ, HackerRank, Timus, and so on) and shows all of them in one place. You can check my StopStalk profile from here.

⭐ CodersRank

This is a platform made to help developers in job-seeking and professional growth. Here, your CodersRank profile serves as a proven track record of your coding knowledge.

You have to connect your private and public repositories here from GitHub to generate your true CodersRank profile. You can also check my CodersRank profile from here.

Conclusion

Thanks for reading the entire article. If it helps you then you can also check out other articles of mine at freeCodeCamp.

If you want to get in touch with me, then you can do so using Twitter, LinkedIn, and GitHub.

You can also SUBSCRIBE to my YouTube channel (Code With FahimFBA) if you want to learn various kinds of programming languages with a lot of practical examples regularly.

If you want to check out my highlights, then you can do so at my Polywork timeline.

You can also visit my website to learn more about me and what I'm working on.

Thanks a bunch!

By popular demand, we built a Discord bot that helps people track their progress in the challenge.

Today I am going to show you how to build your own 100 Days of Code bot.

Note that discord.js has released version 14, which includes breaking changes. For compatibility with this tutorial, you will want to ensure you are using discord.js 13 - you can install this with npm install discord.js@13. If you have any questions, feel free to join my discord server.

Create a Discord Bot Application

Your first step is to set up a Discord bot application. Head over to the Discord Developer Portal, sign in if needed, and select "Applications" from the sidebar.

Screenshot of the Developer Portal. If this is your first bot, you will not have any applications here.

Click the "New Application" button. Give it a name, and set it as a "Personal" application. You will now be taken to the application's settings. Here you can change the name, or give it an avatar.

Select "Bot" from the side bar, then click the "Add Bot" button. This will create a Discord Bot account for your application.

Screenshot of the Bot settings page. If you did not set an avatar, you will see a default based on your bot's name.

This is the screen where you will get the bot token. It is very important to keep this token secret, as the token allows your code to connect to your bot. Keep it safe and do not share it with anyone.

Now you need to add the bot to a server to interact with it. Click the "OAuth2" option on the sidebar, then select "URL Generator".

Under "Scopes", select bot and application.commands. The bot scope allows your bot account to join the server, and the application.commands scope allows you to update the slash commands (more on this later).

When you select bot, a new section for "Bot Permissions" will appear. Select the following permissions:

• Send Messages
• Embed Links
• Read Messages/View Channels

Screenshot of the OAuth screen with the required settings.

Copy the generated URL, and paste it into your browser. This will take you through Discord's process to add your new bot to a server.

Note that you must have the Manage Server permission in the server you want to add the bot to. If you do not have this permission, you can create a server to test your bot in.

Now you are ready to write some code!

Set Up Your Project

You will first need to set up the infrastructure and tooling for your project.

Ensure that you have Node.js version 16 and npm installed. Note that the packages you will use do not support earlier versions of Node.

Prepare the package.json

Create a directory, or folder, for your project. Open your terminal pointing to that new folder. Run the command npm init to set up your package.json file. For this tutorial, the default values are sufficient, but feel free to edit them as you wish.

You should end up with a package.json similar to this:

{
  "name": "100doc-tutorial",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}

Now you need to make a couple of changes to get ready for the TypeScript implementation.

First, replace the main value of index.js with ./prod/index.js – you will be setting your TypeScript to compile to a prod directory.

Then remove the test script and add the following two scripts:

"build": "tsc",
"start": "node -r dotenv/config ./prod/index.js"

The build script will compile your TypeScript into JavaScript so Node can run it, and the start script will run the index.js entrypoint file.

Adding the -r dotenv/config here will dynamically import and run the config method in the dotenv package, which loads your environment variables from the .env file.

Speaking of packages, your next step is to install dependencies. Using npm install, install these dependencies:

• discord.js – this is the library that will handle connecting to the gateway and managing the Discord API calls.
• @discordjs/builders – the discord.js package for constructing application commands
• @discordjs/rest – a custom API client for interacting with the Discord REST API.
• discord-api-types – Type definitions and handlers for the Discord REST API.
• dotenv – a package that loads .env values into the Node process.
• mongoose – A wrapper for the MongoDB connection which offers tools for structuring your data.

Finally, install the development dependencies with npm install --save-dev. Development dependencies are packages that are required for working on your project in a development environment, but not required for running the codebase in production.

• typescript – This is the package for the TypeScript language, which includes everything needed to write code in TypeScript and compile it into JavaScript.
• @types/node – TypeScript relies on type definitions to understand the code you write. This package defines the types for the Node.js runtime environment, such as the process.env object.

With these packages installed, you should now have a package.json similar to this:

{
  "name": "100doc-tutorial",
  "version": "1.0.0",
  "description": "",
  "main": "./prod/index.js",
  "scripts": {
    "build": "tsc",
    "start": "node -r dotenv/config ./prod/index.js"
  },
  "author": "",
  "license": "ISC",
  "dependencies": {
    "@discordjs/builders": "^0.11.0",
    "@discordjs/rest": "^0.2.0-canary.0",
    "discord.js": "^13.6.0",
    "dotenv": "^14.2.0",
    "mongoose": "^6.1.7"
  },
  "devDependencies": {
    "@types/node": "^17.0.10",
    "typescript": "^4.5.4"
  }
}

Prepare TypeScript

TypeScript's compiler offers a number of different settings to maximise your control over the resulting JavaScript.

You can typically modify the compiler settings through a tsconfig.json file at the root of your project. You can generate the default boilerplate for this file with npx tsc --init, use an existing one if you set one up in another project, or even write one from scratch.

Because the compiler settings can significantly change the behaviour of TypeScript, it is best to use the same settings when following this tutorial. Here are the settings you should use:

{
  "compilerOptions": {
    "target": "ES6",
    "module": "CommonJS",
    "rootDir": "./src",
    "outDir": "./prod",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true
  }
}

The most important settings here are the rootDir and outDir settings. These tell the compiler that all of your code will be in the src directory, and the resulting JavaScript should go in the prod directory.

If you would like to test your settings, create a src directory and place an index.ts file inside. Write some code (such as a console.log statement) and run npm run build in your terminal. You should see a prod directory get created, with an index.js containing your compiled code.

Additional Setup Notes

If you are using git as a version control, you want to avoid pushing secrets and unnecessary code to your repository. Create a .gitignore file in your root project directory, and add the following content:

/node_modules/
/prod/
.env

The .gitignore file tells git not to track files/folders that match the patterns you enter. Ignoring the node_modules folder keeps your repository from becoming bloated.

Pushing the compiled JavaScript is also unnecessary, as your project is typically compiled in production before runtime. .env files contain secret values, such as API keys and tokens, so they should not be committed to a repository.

Create the Discord Bot

Your next step is to prepare the initial bot connection. If you did not do so earlier, create a src directory and an index.ts file within.

Start with an anonymous immediately-invoked function expression (IIFE) to allow for top-level await use:

(async () => {

})();

Within this function you are going to instantiate your Discord bot. At the top of the file, import the Client class with import { Client } from "discord.js";. The Client class represents your Discord bot's session.

Inside your function, construct a new Client instance and assign it to a BOT variable with const BOT = new Client();. Now the BOT variable will represent your bot.

To connect your bot to the Discord gateway and begin receiving events, you will need to use the .login() method on your bot instance. The .login() method takes a single argument, which is the token for the bot application you created earlier.

Many of the methods in discord.js are asynchronous, so you will need to use await here. Add the line await BOT.login(process.env.BOT_TOKEN); to your IIFE.

Your index.ts file should now look like this:

import { Client } from "discord.js";

(async () => {
  const BOT = new Client();

  await BOT.login(process.env.BOT_TOKEN);
})();

If you try to run npm run build, you will see an error: An argument for 'options' was not provided.

In discord.js 13, you are required to specify Gateway Intents when you instantiate your bot. Gateway Intents tell Discord what events your bot should receive.

In your src folder, create a config folder - then in config, create an IntentOptions.ts file.

Within that new file, add the line export const IntentOptions = ["GUILDS"]. This will tell Discord your bot should receive the Guild events.

Then, back in your index.ts file, add an argument to your new Client() call: new Client({intents: IntentOptions}). You'll need to import it at the top of your file with import { IntentOptions } from "./config/IntentOptions;.

It seems you still have an error: Type 'string' is not assignable to type 'number |${bigint}| IntentsString | Readonly<BitField<IntentsString, number>> | RecursiveReadonlyArray<number |${bigint}| IntentsString | Readonly<...>>'.

TypeScript is inferring your IntentOptions array as a string, but the Client constructor is expecting more specific types.

Head back to your config/IntentOptions.ts file and add another import: import { IntentsString } from "discord.js". Then update your variable with the new type definition: export const IntentOptions: IntentsString[] = ["GUILDS"];.

Now npm run build should be successful. If you have added your new bot to a Discord server, running npm start will show your bot come online in that server. However, the bot is not going to respond to anything yet, because you have not started listening to events.

Gateway Events in Discord

Gateway "events" are generated when an action happens on Discord, and are typically sent to clients (including your bot) as JSON payloads. You can listen to those events with the .on() method, allowing you to write logic for your bot to follow when specific events occur.

The first event to listen to is the "ready" event. This event fires when your bot has connected to the gateway and is ready to process events. Above your .login() call, add BOT.on("ready", () => console.log("Connected to Discord!"));.

For your changes to take effect, use npm run build again to compile the new code. Now if you try npm run start, you should see "Connected to Discord!" print in your terminal.

Connect to the Database

You'll be using the mongoose package to connect to a MongoDB instance. If you prefer, you can run MongoDB locally, or you can use the MongoDB Atlas free tier for a cloud-based solution.

If you do not have a MongoDB Atlas account, freeCodeCamp has a great tutorial on setting one up.

Grab your connection string for your database and add it to your .env file as MONGO_URI="", with the connection string going between the quotes. For the database name, use oneHundredDays.

Create a directory called database to hold the files that contain your database logic. Within that directory, create a file called connectDatabase.ts. You will be writing your logic to initiate the database connection here.

Start with an exported function declaration:

export const connectDatabase = async () => {

}

mongoose offers a connect method for connecting to the database. Import it with import { connect } from "mongoose"; at the top of your file.

Then use the method inside your function with await connect(process.env.MONGO_URI);. Add a console.log statement after that so you can identify that your bot has connected to the database.

Your connectDatabase.ts file should now look something like this:

import { connect } from "mongoose";

export const connectDatabase = async () => {
    await connect(process.env.MONGO_URI);
    console.log("Database Connected!")
}

Now, within your index.ts file, import this function with import { connectDatabase } from "./database/connectDatabase" and add await connectDatabase() to your IIFE, just before the .login() method. Go ahead and run npm run build again.

A compiler error, indicating that: Argument of type string or undefined is not assignable to parameter of type string.

Oh no – an error!

Environment Variable Validation

The problem with environment variables is that they can all be undefined. This often happens if you make a typo in your environment variable name, or mix the name up with another name (a mistake I made when writing this tutorial, using TOKEN instead of BOT_TOKEN in some places).

TypeScript is warning you that the connect method takes a string, and that an undefined value will break things. You can fix this, but first you will want to write a function to handle validating your environment variables.

Within your src directory, create a utils directory to contain your utility functions. Add a validateEnv.ts file there.

Create a function in the file called validateEnv. This function will be synchronous and does not need the async keyword. Within that function, add conditions to check for your two environment variables. If either one is missing, return false. Otherwise, return true.

Your code might look something like this:

export const validateEnv = () => {
  if (!process.env.BOT_TOKEN) {
    console.warn("Missing Discord bot token.");
    return false;
  }

  if (!process.env.MONGO_URI) {
    console.warn("Missing MongoDB connection.");
    return false;
  }
  return true;
};

Head back to your index.ts file and import this validation function with import { validateEnv } from "./utils/validateEnv". Then at the beginning of your IIFE, use an if statement to return early if the function returns false. Your index.ts should look like:

import { Client } from "discord.js";
import { connectDatabase } from "./database/connectDatabase";
import { validateEnv } from "./utils/validateEnv";

(async () => {
  if (!validateEnv()) return;

  const BOT = new Client();

  BOT.on("ready", () => console.log("Connected to Discord!"));

  await connectDatabase();

  await BOT.login(process.env.BOT_TOKEN);
})();

If you try npm run build again, you will see the same error message as before. This is because while we know the environment variable exists, TypeScript still cannot infer it. The validation function is set up to exit the process if the environment variable is missing, so we are going to tell TypeScript that it is definitely a string.

Back in your connectDatabase.ts file, within the connect function use process.env.MONGO_URI as string to coerce the type into string. The error should go away, and you can now run npm run build and npm start.

You should see the messages you wrote for both the Discord and MongoDB connections print in your terminal.

The "interaction" Event

While you are making great progress on your bot, it still does not do anything. In order to receive commands, you will need to create another event listener.

Discord rolled out slash commands, featuring a new UI and a new gateway event. The interactionCreate event is triggered when someone uses a slash command with your bot. This is the event you will want to listen to. Because the logic is a bit more complicated than the ready event, you will want to create a separate file.

Within your src directory, create an events directory, and an onInteraction.ts file in there. Start by defining an exported function onInteraction. This should be an asynchronous function, with a single parameter called interaction.

export const onInteraction = async (interaction) => {

};

To provide a type definition for your parameter, import the Interaction type from discord.js.

import { Interaction } from "discord.js";

export const onInteraction = async (interaction: Interaction) => {

};

The interaction event actually triggers on any command interaction, which includes things like button clicks and select menus, as well as the slash commands we want.

Because you will only be writing slash commands for this bot, you can filter out any other interaction type and help TypeScript understand the data you are working with.

In your new function, add a condition to check interaction.isCommand(). You will be writing logic within this block later.

import { Interaction } from "discord.js";

export const onInteraction = async (interaction: Interaction) => {
  if (interaction.isCommand()) {
  }
};

Now, back in your index.ts file, you can mount another listener. Next to your .on("ready") listener, add a BOT.on("interactionCreate") listener. For this event, the callback takes an interaction argument which you can pass to your new onInteraction function.

  BOT.on(
    "interactionCreate",
    async (interaction) => await onInteraction(interaction)
  );

Great! You can run npm run build to confirm that TypeScript doesn't throw any errors, but without actual commands to use you can't quite test this code yet.

Prepare for Commands

I maintain a few Discord bots, and one thing I've discovered that helps keep code maintainable and readable is making the components modular.

Define an Interface

You will first need to define a common structure for your commands. Create an interfaces folder in src. Then inside interfaces create a file called Command.ts.

Now you are going to create an interface. In TypeScript, an interface is often used to define the structure of an object, and is one of many tools available for declaring a variable's type.

In your Command.ts file, create an exported interface called Command:

export interface Command {

}

Your interface will have two properties – data, which will hold the command data to send to Discord, and run, which will hold the callback function and command logic.

For the data property, import SlashCommandBuilder and SlashCommandSubcommandsOnlyBuilder from @discordjs/builders. Define the data property as either one of those two types.

For the run property, import the CommandInteraction type from discord.js. Define run as a function which takes a CommandInteraction typed parameter and returns a void Promise.

import {
  SlashCommandBuilder,
  SlashCommandSubcommandsOnlyBuilder,
} from "@discordjs/builders";
import { CommandInteraction } from "discord.js";

export interface CommandInt {
  data: SlashCommandBuilder | SlashCommandSubcommandsOnlyBuilder;
  run: (interaction: CommandInteraction) => Promise<void>;
}

Create a Command List

Next you need a place to store all of your commands. Create a folder called commands in the src directory, and add a file called _CommandList.ts. The underscore here will keep this file at the top of the list.

The _CommandList.ts file will need two lines. First, import your Command interface, then declare a CommandList array. The array will be empty for now, but give it a Command[] type so TypeScript knows it will eventually hold your command objects. The file should look like:

import { Command } from "../interfaces/Command";

export const CommandList: Command[] = [];

The purpose of this file is to create an array of your bot's commands which you will iterate over in the interaction event listener. There are ways to automate this, but they tend to be unnecessarily complex for smaller bots.

Check for Commands

Back in your onInteraction.ts file, you should start working on the logic for finding and running a command.

In your interaction.isCommand() condition block, loop through the CommandList array (remember to import it!) with a for...of loop.

for (const Command of CommandList) {

}

The interaction payload received from Discord includes a commandName property, which you can use to find the command that a user has selected. To check this, compare interaction.commandName with the Command.data.name property.

if (interaction.commandName === Command.data.name) {

}

Now, if you have found the command the user has chosen, you need to run the logic for that command. This is achieved with a Command.run(interaction) call – passing the interaction payload into the command.

Your final file should look like this:

import { Interaction } from "discord.js";
import { CommandList } from "../commands/_CommandList";

export const onInteraction = async (interaction: Interaction) => {
  if (interaction.isCommand()) {
    for (const Command of CommandList) {
      if (interaction.commandName === Command.data.name) {
        await Command.run(interaction);
        break;
      }
    }
  }
};

Database Model

There's one more step before you are ready to start writing commands. This bot will track your community members' 100 Days of Code progress. And you need to store that progress in the database.

mongoose helps structure your MongoDB records to prevent you from passing malformed or incomplete data into your database.

Start by creating a models folder in your database directory. In that models folder, create a CamperModel.ts file. This will be your structure for the user objects.

You first need to import the necessary values from the mongoose library. Add import { Document, model, Schema } from "mongoose"; at the top of the file.

Because you are using TypeScript, you need to create a type definition for your database objects. Create another interface, like you did for your commands, named CamperInt.

export interface CamperInt extends Document {

}

Your database model will have four properties. Add these to your interface:

• discordId: string; – Every user object in Discord has a unique identifier, called a Snowflake, which is used to distinguish them from other users. Unlike a username or discriminator (the four digit number after the username), the id value cannot be changed. This makes it the ideal value for linking your stored data to a Discord user.
• round: number; – This will represent the "round" the user is on in the challenge. When someone completes 100 days of the challenge, they may choose to undertake the challenge again. When they do, they often refer to it as "round 2", for example.
• day: number; – This represents the day the user is on in the challenge.
• timestamp: number; – You will use this value to track when the user last submitted a 100 Days of Code post.

Great! Now you need to define the Schema for your database entries. mongoose uses a Schema object to define the shape of the documents that go in to your database collection. The Schema import has a constructor, which you will assign to a variable.

export const Camper = new Schema();

This constructor takes an object as its argument, and that object defines the database keys and types. Go ahead and pass in an object similar to what your interface looks like.

export const Camper = new Schema({
    discordId: String,
    round: Number,
    day: Number,
    timestamp: Number,
})

Next you need to create the model. In mongoose, the model object serves to create, read, and update your documents in the MongoDB database. Add export default model(); at the bottom of your file.

The model function takes a few parameters. The first is a string, and is the name to use for the documents in your database. For this collection, use "camper". The second argument is the schema to use for the data – use your Camper schema there.

By default, mongoose will use the plural version of your model name for the collection. In our case, that would be "campers". If you want to change that, you can pass in a third argument of { collection: "name" } to set the collection to name.

If you were using JavaScript, this would be enough to get your database model set up. However, because you are using TypeScript, you should take advantage of the type safety. model() by default returns a Document type of any.

To resolve this, you can pass a generic type into the model function. Generic types serve as variables for type definitions, in a sense. You need to set the generic type for your model to use your interface. Add the generic type by changing model to model<CamperInt>.

Just one more step here. Your CamperInt interface only defines the properties you set in the MongoDB document, but doesn't include the standard properties.

Change your export interface CamperInt to export interface CamperInt extends Document. This tells TypeScript that your type definition is an extension of the existing Document type definition – you are essentially adding properties to that structure.

Your final file should look like this:

import { Document, model, Schema } from "mongoose";

export interface CamperInt {
  discordId: string;
  round: number;
  day: number;
  timestamp: number;
}

export const Camper = new Schema({
  discordId: String,
  round: Number,
  day: Number,
  timestamp: Number,
});

export default model<CamperInt>("camper", Camper);

As a safety check, use npm run build again. You should not see any errors in the terminal.

Write Bot Commands

You are finally ready to start writing some commands! As this is a 100 Days of Code bot, you should start with the command for creating a 100 Days of Code update.

100 Command

Within your commands folder, create a oneHundred.ts file. This will hold your 100 Days of Code command. Import your command interface with import { Command } from "../interfaces/Command;.

Now declare an exported variable oneHundred and give it the Command type:

import { Command } from "../interfaces/Command";

export const oneHundred: Command = {

};

First, create the data property. You will be using the @discordjs/builders package to build a slash command.

Start by importing the SlashCommandBuilder() from the @discordjs/builders package. Then, construct a new instance in the data property with new SlashCommandBuilder(). You're going to chain some methods here to pass the information you want into the builder.

The .setName() method allows you to set the name of your slash command. Set the name to "100". The setDescription() option allows you to display a description of the command in Discord's UI. Set the description to "Check in for the 100 Days of Code challenge.".

Slash commands can also accept option values. These are used to take arguments from the user, and come in various types. For this command, you'll want a string option with the addStringOption() method. Option methods take a callback function, with an option parameter.

You can then chain methods on the option parameter to configure the information for the argument. Use the .setName() method to give the option a name of "message", and the .setDescription() method to give it a description of "The message to go in your 100 Days of Code update.". Finally, use the .setRequired() method to set the option to be required.

Here's what you should have now:

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
};

If you are coding in an IDE with Intellisense enabled, you may have noticed that this will throw a type error on the data property. This is because the SlashCommandBuilder actually returns an Omit type! An Omit type is used to tell TypeScript that the type is almost the same as another type, but with specific properties removed.

Head over to your interfaces/Command.ts file to update the type. Replace the SlashCommandBuilder type with Omit<SlashCommandBuilder, "addSubcommandGroup" | "addSubcommand">. This will tell TypeScript that data should be a SlashCommandBuilder, but without those two specific properties.

import {
  SlashCommandBuilder,
  SlashCommandSubcommandsOnlyBuilder,
} from "@discordjs/builders";
import { CommandInteraction } from "discord.js";

export interface Command {
  data:
    | Omit<SlashCommandBuilder, "addSubcommandGroup" | "addSubcommand">
    | SlashCommandSubcommandsOnlyBuilder;
  run: (interaction: CommandInteraction) => Promise<void>;
}

Great! Now that your type error is resolved, head back over to your oneHundred.ts command file – it is time to write the command logic.

All of your bot's logic for responding to the command will go in the run property. As you did in your interface, start by creating an async function which takes an interaction argument. Then, let the first line of your function be await interaction.deferReply();.

Discord expects a bot to respond to a command within three seconds. Because this command may take longer to process, using the .deferReply() method sends an acknowledgement response that gives you a full 15 minutes to send the actual response.

Next, you need to extract some data from the command. First, destructure the user object out of the interaction payload with const { user } = interaction;. The user object represents the Discord user that called the command.

Then get the message option you sent with const text = interaction.options.getString("message", true);. With this line, you are accessing the options property of the interaction. The .getString() method specifically grabs a string option (remember that you created the option in data), and "message" is the name of the option. The true argument indicates that this is a required option, so TypeScript won't consider it nullable.

Your file should look like this:

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const text = interaction.options.getString("message", true);
  },
};

The next step in this command would be to fetch data from your database. Because many of your commands will need to do this, you should create a module for it.

Handling the Database Logic

Create a src/modules directory, and add a getCamperData.ts file within. Create an exported async function named getCamperData, and give it a string parameter named id. Then, within the function, you can query the database.

Import your CamperModel from the database directory, and use the findOne() method to query by the camper's id: const camperData = await CamperModel.findOne({ discordId: id });.

import CamperModel from "../database/models/CamperModel";

export const getCamperData = async (id: string) => {
  const camperData = await CamperModel.findOne({ id });
};

We still have one more step here. If the camper has not used the bot before, they won't have an existing database record. findOne() would return null in this case – so you can add a fallback value.

import CamperModel from "../database/models/CamperModel";

export const getCamperData = async (id: string) => {
  const camperData =
    (await CamperModel.findOne({ discordId: id })) ||
    (await CamperModel.create({
      discordId: id,
      round: 1,
      day: 0,
      date: Date.now(),
    }));
};

Finally, you need to return your data. Add return camperData at the end of the function. For extra type safety, define the return type of your function as Promise<CamperData>.

import CamperModel, { CamperInt } from "../database/models/CamperModel";

export const getCamperData = async (id: string): Promise<CamperInt> => {
  const camperData =
    (await CamperModel.findOne({ discordId: id })) ||
    (await CamperModel.create({
      discordId: id,
      round: 1,
      day: 0,
      date: Date.now(),
    }));
  return camperData;
};

You now have a way to get camper data from the database, but you need a way to update it as well. Create another file in your /src/modules directory called updateCamperData.ts. This will handle the logic to increment a camper's progress.

Start with an exported async function called updateCamperData. It should take a Camper parameter, which would be the data you fetch from MongoDB.

import { CamperInt } from "../database/models/CamperModel";

export const updateCamperData = async (Camper: CamperInt) => {

};

The only time you will update data is within the /100 command – where you'll want to increment the camper's day count, check if they have started a new round, and update the timestamp.

First, increment the day count with Camper.day++;. With the way the 100 Days of Code challenge works, if a camper has passed day 100 then they have started a new "round". You'll need a condition to check if Camper.day > 100, and if so, reset the day to 1 and increment the round.

After that condition, update the timestamp with Camper.timestamp = Date.now(); and save the data with await Camper.save();. Finally, return the modified data object so you can use it in the command.

Your final file should look like:

import { CamperInt } from "../database/models/CamperModel";

export const updateCamperData = async (Camper: CamperInt) => {
  Camper.day++;
  if (Camper.day > 100) {
    Camper.day = 1;
    Camper.round++;
  }
  Camper.timestamp = Date.now();
  await Camper.save();
  return Camper;
};

100 Command Continued

Now that your database logic is ready, return to your oneHundred.ts file. As a reminder, that file should look like this:

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const text = interaction.options.getString("message", true);
  },
};

Import your two new modules at the top of the file. Then, after your logic that extracts the values from the interaction object, fetch the camper's data from the database with const targetCamper = await getCamperData(user.id);. Update the data with const updatedCamper = await updateCamperData(targetCamper);.

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";
import { getCamperData } from "../modules/getCamperData";
import { updateCamperData } from "../modules/updateCamperData";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const text = interaction.options.getString("message", true);

    const targetCamper = await getCamperData(user.id);
    const updatedCamper = await updateCamperData(targetCamper);
  },
};

Now you need to construct the response to send back to the camper when they use the command.

For this, you'll be using Discord's message embed feature. Start by importing the MessageEmbed constructor from discord.js, and creating a new embed with const oneHundredEmbed = new MessageEmbed();. The MessageEmbed class has a few methods to use for building the content of the embed.

Use the .setTitle() method to set the title of the embed to "100 Days of Code".

Use the .setDescription() method to set the description of the embed to the message the camper provided in the command (remember that you extracted this to the text variable earlier). The author of the embed can be set, and will display at the top of the embed.

Use the .setAuthor() method to pass an object with a name property set to user.tag (which will display the camper's username and discriminator, like nhcarrigan#0001), and an iconURL property set to user.displayAvatarUrl() (which will attach the camper's avatar to the embed).

Embeds also accept fields, which are smaller blocks of text that have their own title and description. The .addField() method takes two or three arguments, the first being the field title, the second being the field description, and the third being an optional boolean to set the field as inline.

Use the .addField() method to add two fields. The first should have the title set to "Round" and the description set to updatedCamper.round.toString(). The second should have the title set to "Day" and the description set to updatedCamper.day.toString(). Both fields should be inline.

For the last part of your embed, use the .setFooter() method to add small footer text. Pass an object with a text property set to "Day completed: " + new Date(updatedCamer.timestamp).toLocaleDateString() to show the time the camper reported their progress.

Finally, you need to send this new embed back to the camper. Because you have already sent a response with the interaction.deferReply() call, you cannot send another response. Instead, you need to edit the one you sent.

Use await interaction.editReply() to edit the response. The .editReply() method takes an object with various properties – in this case, you are sending an embed. Pass an object with an embeds property set to [oneHundredEmbed].

Note that this is an array containing your embed. Discord messages can contain up to 10 embeds, and the API expects an array of embed objects to match.

Your final command file should look like this:

import { SlashCommandBuilder } from "@discordjs/builders";
import { MessageEmbed } from "discord.js";
import { Command } from "../interfaces/Command";
import { getCamperData } from "../modules/getCamperData";
import { updateCamperData } from "../modules/updateCamperData";

export const oneHundred: Command = {
  data: new SlashCommandBuilder()
    .setName("100")
    .setDescription("Check in for the 100 Days of Code challenge.")
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const text = interaction.options.getString("message", true);

    const targetCamper = await getCamperData(user.id);
    const updatedCamper = await updateCamperData(targetCamper);

    const oneHundredEmbed = new MessageEmbed();
    oneHundredEmbed.setTitle("100 Days of Code");
    oneHundredEmbed.setDescription(text);
    oneHundredEmbed.setAuthor({
      name: user.tag,
      iconURL: user.displayAvatarURL(),
    });
    oneHundredEmbed.addField("Round", updatedCamper.round.toString(), true);
    oneHundredEmbed.addField("Day", updatedCamper.day.toString(), true);
    oneHundredEmbed.setFooter({
      text:
        "Day completed: " +
        new Date(updatedCamper.timestamp).toLocaleDateString(),
    });

    await interaction.editReply({ embeds: [oneHundredEmbed] });
  },
};

Registering Commands

If you run npm run build and npm start, everything starts up – but you have no way to actually use your new command. This is because Discord requires that commands be registered so they are made available in the application UI. There are a few steps we'll need to take to do this.

First, head over to your _CommandList.ts file and import your oneHundred command. Add this to your CommandList array so it's available elsewhere.

import { Command } from "../interfaces/Command";
import { oneHundred } from "./oneHundred";

export const CommandList: Command[] = [oneHundred];

Now it is time to add the logic to send the command information to Discord. In your src/events directory, add an onReady.ts file. We'll be using this with the "ready" event.

Create an exported async function named onReady, and give it a single parameter called BOT. Import the Client type from discord.js and set the BOT typedef to Client.

import { Client } from "discord.js";

export const onReady = async (BOT: Client) => {};

Now import the REST module from @discordjs/rest. This will allow you to instantiate an API client, which you'll use to send the commands. Construct a new instance with const rest = new REST();.

There are a couple of things you'll need to configure with your REST client. First, pass an object into the REST() constructor with a version property set to "9". This tells the client to use version 9 of Discord's API, which is currently the latest version.

Then, chain a .setToken() call on the constructor to set the API token to process.env.BOT_TOKEN – you'll have to coerce this to a string.

import { REST } from "@discordjs/rest";
import { Client } from "discord.js";

export const onReady = async (BOT: Client) => {
  const rest = new REST({ version: "9" }).setToken(
    process.env.BOT_TOKEN as string
  );
};

The API expects command data to be sent in a specific JSON format, but thankfully the slash command builder we are using has a method just for that. Import your CommandList, then create a new array and map your command data.

const commandData = CommandList.map((command) => command.data.toJSON());

Before you send the commands to Discord, it's important to note that there are two types of commands. "Global Commands" are available everywhere your bot is used, but take about an hour to update. "Guild Commands" are available only in a single server, but update immediately. Because this bot is designed to run in a single server, we're going to use guild commands.

You'll need to get the ID of the server you are using the bot in. To do this, make sure you have enabled developer mode in your Discord application, then right click on your server icon and select "Copy ID". In your .env file, add a GUILD_ID variable and assign it the ID you copied. It should look something like GUILD_ID="778130114772598785".

Back in your onReady.ts file, start your API call with await rest.put(). Sending a PUT request will update any existing commands, where a POST will attempt to create new commands and error if commands share a name. Import Routes from discord-api-types/v9, and within the rest.put() call pass a Routes.applicationGuildCommands() call. This will be used to construct the API endpoint to send the commands to.

The applicationGuildCommands() call will take two arguments.

The first is the application ID to associate the commands with. You can get this from the BOT.user.id value – but user is potentially undefined, so you'll need to optionally chain it. Use BOT.user?.id || "missing id" to add a fallback value that will error out – this will allow us to know if the bot's ID is missing.

The second argument is the server ID, which you set up as process.env.GUILD_ID (remember to coerce the type!).

The .put() call needs a second argument as well, which is the data you want to send. Pass this as { body: commandData } to match the expected format.

Finally, add a console.log("Discord ready!") at the end of the file to indicate your bot is online.

import { REST } from "@discordjs/rest";
import { Routes } from "discord-api-types/v9";
import { Client } from "discord.js";
import { CommandList } from "../commands/_CommandList";

export const onReady = async (BOT: Client) => {
  const rest = new REST({ version: "9" }).setToken(
    process.env.BOT_TOKEN as string
  );

  const commandData = CommandList.map((command) => command.data.toJSON());

  await rest.put(
    Routes.applicationGuildCommands(
      BOT.user?.id || "missing id",
      process.env.GUILD_ID as string
    ),
    { body: commandData }
  );

  console.log("Discord ready!");
};

Switch to your index.ts file and locate your "ready" event listener. Replace the console.log call with your new onReady function – remember to import it, and make the callback asynchronous.

import { Client } from "discord.js";
import { IntentOptions } from "./config/IntentOptions";
import { connectDatabase } from "./database/connectDatabase";
import { onInteraction } from "./events/onInteraction";
import { onReady } from "./events/onReady";
import { validateEnv } from "./utils/validateEnv";

(async () => {
  if (!validateEnv()) return;
  const BOT = new Client({ intents: IntentOptions });

  BOT.on("ready", async () => await onReady(BOT));

  BOT.on(
    "interactionCreate",
    async (interaction) => await onInteraction(interaction)
  );

  await connectDatabase();

  await BOT.login(process.env.BOT_TOKEN);
})();

Now run npm run build and npm start, and head to your server in Discord. If you type / you should see your new /100 command show up. Try using the command and checking the response.

If you see this response, then you've successfully created your first command!

Congratulations! You have your first successful command. With all of the infrastructure you've built, adding additional commands will be much smoother. Let's go ahead and do that now.

Edit Command

What happens if a camper makes a typo in their /100 message? Because the bot sends the response, the camper cannot edit it (Discord does not allow you to edit messages you did not send). You should create a command that will allow a camper to do this.

Create an edit.ts file in your src/commands directory. Like you did with the /100 command, import your SlashCommandBuilder and Command interface, and export an edit object with the Command type.

Use the SlashCommandBuilder to prepare the data property. Give the command the name edit and the description Edit a previous 100 days of code post., then add two string options. The first string option should have a name embed-id and a description of ID of the message to edit., and the second should have a name of message and a description of The message to go in your 100 Days of Code update.. Both options should be required.

Your code should look like this:

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const edit: Command = {
    data: new SlashCommandBuilder()
    .setName("edit")
    .setDescription("Edit a previous 100 days of code post.")
    .addStringOption((option) =>
      option
        .setName("embed-id")
        .setDescription("ID of the message to edit.")
        .setRequired(true)
    )
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
}

Create your run property with an async function and an interaction parameter. Destructure the channel and user from the interaction, and grab the embed-id and message options. Don't forget to defer the response!

    run: async (interaction) => {
        await interaction.deferReply();
        const { channel, user } = interaction;
        const targetId = interaction.options.getString("embed-id", true);
        const text = interaction.options.getString("message", true);
    }

The channel property is nullable (in cases where an interaction is sent via a DM, for example), so you'll want to check that it exists. If it does not, respond with a message that the command is missing parameters.

    if (!channel) {
      await interaction.editReply({
        content: "Missing channel parameter.",
      });
      return;
    }

Now that you know the channel exists, you can fetch the message that the camper wants to edit based on the ID they provided. Use channel.messages.fetch() to do this, passing in the targetId as the argument.

Because it is possible that the target message does not exist, you need to account for that in your code. Add a condition that checks for this, and if the message is not found respond with an explanation.

    const targetMessage = await channel.messages.fetch(targetId);

    if (!targetMessage) {
      await interaction.editReply({
        content:
          "That does not appear to be a valid message ID. Be sure that you are using this command in the same channel as the message.",
      });
      return;
    }

The last thing you need to check is that the message the camper is editing actually belongs to them. You can access the embed with the .embeds property – much like how you sent it, the property is returned as an array of embed objects.

Grab the first embed from the array, and then check that the embed author matches the user's tag. If not, let them know they cannot edit this post.

    const targetEmbed = targetMessage.embeds[0];

    if (targetEmbed.author?.name !== user.tag) {
        await interaction.editReply({
            content: "This does not appear to be your 100 Days of Code post. You cannot edit it."
        })
    }

Now that you have confirmed everything is correct, you can use .setDescription() on the embed to update the text. Then, edit the message with the new embed, and respond to the interaction with a confirmation.

Your full code should look like this:

import { SlashCommandBuilder } from "@discordjs/builders";
import { Command } from "../interfaces/Command";

export const edit: Command = {
  data: new SlashCommandBuilder()
    .setName("edit")
    .setDescription("Edit a previous 100 days of code post.")
    .addStringOption((option) =>
      option
        .setName("embed-id")
        .setDescription("ID of the message to edit.")
        .setRequired(true)
    )
    .addStringOption((option) =>
      option
        .setName("message")
        .setDescription("The message to go in your 100 Days of Code update.")
        .setRequired(true)
    ),
  run: async (interaction) => {
    await interaction.deferReply();
    const { channel, user } = interaction;
    const targetId = interaction.options.getString("embed-id", true);
    const text = interaction.options.getString("message", true);

    if (!channel) {
      await interaction.editReply({
        content: "Missing channel parameter.",
      });
      return;
    }

    const targetMessage = await channel.messages.fetch(targetId);

    if (!targetMessage) {
      await interaction.editReply({
        content:
          "That does not appear to be a valid message ID. Be sure that you are using this command in the same channel as the message.",
      });
      return;
    }

    const targetEmbed = targetMessage.embeds[0];

    if (targetEmbed.author?.name !== user.tag) {
      await interaction.editReply({
        content:
          "This does not appear to be your 100 Days of Code post. You cannot edit it.",
      });
    }

    targetEmbed.setDescription(text);
    await targetMessage.edit({ embeds: [targetEmbed] });
    await interaction.editReply({ content: "Updated!" });
  },
};

Add your new edit command to your CommandList array, then build and run your bot and you should see the new command. Try editing the embed you sent earlier.

You should see your embed update, and a confirmation from the bot!

View Command

Campers should have a way to view their current progress, so we'll need to create a command to do so. By now, you should be comfortable with the command structure – we encourage you to follow these instructions but attempt to write the code without looking at the final result.

Create a view.ts file in your commands directory, and set up your command variable. Create the data property with a command that has the name view and the description Shows your latest 100 days of code check in. This command does not need any options.

Set up your async function in the run property, and defer the interaction response. Extract the user object from the interaction. Use your getCamperData module to fetch the camper's data from the database. Then, check if the data's day property has a non-zero value. If it does not, let the camper know that they have not started the 100 Days of Code challenge, and can do so with the /100 command.

Create an embed with a title set to My 100DoC Progress. Set the description to Here is my 100 Days of Code progress. I last reported an update on: and add the camper's timestamp. Add a Round and Day field, and set the author for the embed. Then send the embed in the interaction response.

Remember to add your new command to the CommandList, then try building and starting your bot. You should see the command available, and be able to get a response from it.

If you did not get the response, here is what your code should look like.

import { SlashCommandBuilder } from "@discordjs/builders";
import { MessageEmbed } from "discord.js";
import { Command } from "../interfaces/Command";
import { getCamperData } from "../modules/getCamperData";

export const view: Command = {
  data: new SlashCommandBuilder()
    .setName("view")
    .setDescription("Shows your latest 100 Days of Code check in."),
  run: async (interaction) => {
    await interaction.deferReply();
    const { user } = interaction;
    const targetCamper = await getCamperData(user.id);

    if (!targetCamper.day) {
      await interaction.editReply({
        content:
          "It looks like you have not started the 100 Days of Code challenge yet. Use `/100` and add your message to report your first day!",
      });
      return;
    }

    const camperEmbed = new MessageEmbed();
    camperEmbed.setTitle("My 100DoC Progress");
    camperEmbed.setDescription(
      `Here is my 100 Days of Code progress. I last reported an update on ${new Date(
        targetCamper.timestamp
      ).toLocaleDateString()}.`
    );
    camperEmbed.addField("Round", targetCamper.round.toString(), true);
    camperEmbed.addField("Day", targetCamper.day.toString(), true);
    camperEmbed.setAuthor({
      name: user.tag,
      iconURL: user.displayAvatarURL(),
    });

    await interaction.editReply({ embeds: [camperEmbed] });
  },
};

Help Command

The last thing you need to build is a help command, which will explain how campers can interact with the bot.

Create your help.ts file in the command directory, and create your data property. Give the command the name help and the description Provides information on using this bot.

Set up your run property with the async function, and remember to defer the reply. Create an embed, and use the description and fields to provide the information you would like to share with your campers. Send the embed in the interaction response.

Load your new help command into the CommandList, and build + start your bot to test it. You should see a response with the embed you created.

Your embed might look different, depending on what information you chose to share. Here's the code that we used for the above embed:

import { SlashCommandBuilder } from "@discordjs/builders";
import { MessageEmbed } from "discord.js";
import { Command } from "../interfaces/Command";

export const help: Command = {
  data: new SlashCommandBuilder()
    .setName("help")
    .setDescription("Provides information on using this bot."),
  run: async (interaction) => {
    await interaction.deferReply();
    const helpEmbed = new MessageEmbed();
    helpEmbed.setTitle("100 Days of Code Bot!");
    helpEmbed.setDescription(
      "This discord bot is designed to help you track and share your 100 Days of Code progress."
    );
    helpEmbed.addField(
      "Create today's update",
      "Use the `/100` command to create your update for today. The `message` will be displayed in your embed."
    );
    helpEmbed.addField(
      "Edit today's update",
      "Do you see a typo in your embed? Right click it and copy the ID (you may need developer mode on for this), and use the `/edit` command to update that embed with a new message."
    );
    helpEmbed.addField(
      "Show your progress",
      "To see your current progress in the challenge, and the day you last checked in, use `/view`."
    );
    helpEmbed.setFooter({ text: `Version ${process.env.npm_package_version}` });
    await interaction.editReply({ embeds: [helpEmbed] });
    return;
  },
};

Conclusion

Congratulations! You have successfully built a Discord bot for the 100 Days of Code challenge.

If you are interested in exploring further, you can view the source code for the live bot that inspired this tutorial, which includes custom error logging, external error reporting, and a documentation site.

I had fifteen minutes left, and I knew I was going to fail.

I had spent two months studying for my first technical interview.

I thought I was prepared, but as the interview came to a close, it hit me: I had no idea how to solve coding problems.

Of all the tutorials I had taken when I was learning to code, not one of them had included an approach to solving coding problems.

I had to find a method for problem-solving—my career as a developer depended on it.

I immediately began researching methods. And I found one. In fact, what I uncovered was an invaluable strategy. It was a time-tested four-step method that was somehow under the radar in the developer ecosystem.

In this article, I’ll go over this four-step problem-solving method that you can use to start confidently solving coding problems.

Solving coding problems is not only part of the developer job interview process—it’s what a developer does all day. After all, writing code is problem-solving.

A method for solving problems

This method is from the book How to Solve It by George Pólya. It originally came out in 1945 and has sold over one million copies.

His problem-solving method has been used and taught by many programmers, from computer science professors (see Udacity’s Intro to CS course taught by professor David Evans) to modern web development teachers like Colt Steele.

Let’s walk through solving a simple coding problem using the four-step problem-solving method. This allows us to see the method in action as we learn it. We'll use JavaScript as our language of choice. Here’s the problem:

Create a function that adds together two numbers and returns that value.

There are four steps to the problem-solving method:

1. Understand the problem.
2. Devise a plan.
3. Carry out the plan.
4. Look back.

Let’s get started with step one.

Step 1: Understand the problem.

When given a coding problem in an interview, it’s tempting to rush into coding. This is hard to avoid, especially if you have a time limit.

However, try to resist this urge. Make sure you actually understand the problem before you get started with solving it.

Read through the problem. If you’re in an interview, you could read through the problem out loud if that helps you slow down.

As you read through the problem, clarify any part of it you do not understand. If you’re in an interview, you can do this by asking your interviewer questions about the problem description. If you’re on your own, think through and/or Google parts of the question you might not understand.

This first step is vital as we often don’t take the time to fully understand the problem. When you don’t fully understand the problem, you’ll have a much harder time solving it.

To help you better understand the problem, ask yourself:

What are the inputs?

What kinds of inputs will go into this problem? In this example, the inputs are the arguments that our function will take.

Just from reading the problem description so far, we know that the inputs will be numbers. But to be more specific about what the inputs will be, we can ask:

Will the inputs always be just two numbers? What should happen if our function receives as input three numbers?

Here we could ask the interviewer for clarification, or look at the problem description further.

The coding problem might have a note saying, “You should only ever expect two inputs into the function.” If so, you know how to proceed. You can get more specific, as you’ll likely realize that you need to ask more questions on what kinds of inputs you might be receiving.

Will the inputs always be numbers? What should our function do if we receive the inputs “a” and “b”? Clarify whether or not our function will always take in numbers.

Optionally, you could write down possible inputs in a code comment to get a sense of what they’ll look like:

//inputs: 2, 4

Next, ask:

What are the outputs?

What will this function return? In this case, the output will be one number that is the result of the two number inputs. Make sure you understand what your outputs will be.

Create some examples.

Once you have a grasp of the problem and know the possible inputs and outputs, you can start working on some concrete examples.

Examples can also be used as sanity checks to test your eventual problem. Most code challenge editors that you’ll work in (whether it’s in an interview or just using a site like Codewars or HackerRank) have examples or test cases already written for you. Even so, writing out your own examples can help you cement your understanding of the problem.

Start with a simple example or two of possible inputs and outputs. Let's return to our addition function.

Let’s call our function “add.”

What’s an example input? Example input might be:

// add(2, 3)

What is the output to this? To write the example output, we can write:

// add(2, 3) ---> 5

This indicates that our function will take in an input of 2 and 3 and return 5 as its output.

Create complex examples.

By walking through more complex examples, you can take the time to look for edge cases you might need to account for.

For example, what should we do if our inputs are strings instead of numbers? What if we have as input two strings, for example, add('a', 'b')?

Your interviewer might possibly tell you to return an error message if there are any inputs that are not numbers. If so, you can add a code comment to handle this case if it helps you remember you need to do this.

// return error if inputs are not numbers.

Your interviewer might also tell you to assume that your inputs will always be numbers, in which case you don’t need to write any extra code to handle this particular input edge case.

If you don’t have an interviewer and you’re just solving this problem, the problem might say what happens when you enter invalid inputs.

For example, some problems will say, “If there are zero inputs, return undefined.” For cases like this, you can optionally write a comment.

// check if there are no inputs.

// If no inputs, return undefined.

For our purposes, we’ll assume that our inputs will always be numbers. But generally, it’s good to think about edge cases.

Computer science professor Evans says to write what developers call defensive code. Think about what could go wrong and how your code could defend against possible errors.

Before we move on to step 2, let’s summarize step 1, understand the problem:

-Read through the problem.

-What are the inputs?

-What are the outputs?

Create simple examples, then create more complex ones.

2. Devise a plan for solving the problem.

Next, devise a plan for how you’ll solve the problem. As you devise a plan, write it out in pseudocode.

Pseudocode is a plain language description of the steps in an algorithm. In other words, your pseudocode is your step-by-step plan for how to solve the problem.

Write out the steps you need to take to solve the problem. For a more complicated problem, you’d have more steps. For this problem, you could write:

// Create a sum variable.

Add the first input to the second input using the addition operator.

// Store value of both inputs into sum variable.

// Return as output the sum variable.

Now you have your step-by-step plan to solve the problem.

For more complex problems, professor Evans notes, “Consider systematically how a human solves the problem.” That is, forget about how your code might solve the problem for a moment, and think about how you would solve it as a human. This can help you see the steps more clearly.

3. Carry out the plan (Solve the problem!)

The next step in the problem-solving strategy is to solve the problem. Using your pseudocode as your guide, write out your actual code.

Professor Evans suggests focusing on a simple, mechanical solution. The easier and simpler your solution is, the more likely you can program it correctly.

Taking our pseudocode, we could now write this:

function add(a, b) {
 const sum = a + b;
 return sum;
}

Professor Evans adds, remember not to prematurely optimize. That is, you might be tempted to start saying, “Wait, I’m doing this and it’s going to be inefficient code!”

First, just get out your simple, mechanical solution.

What if you can’t solve the entire problem? What if there's a part of it you still don't know how to solve?

Colt Steele gives great advice here: If you can’t solve part of the problem, ignore that hard part that’s tripping you up. Instead, focus on everything else that you can start writing.

Temporarily ignore that difficult part of the problem you don’t quite understand and write out the other parts. Once this is done, come back to the harder part.

This allows you to get at least some of the problem finished. And often, you’ll realize how to tackle that harder part of the problem once you come back to it.

Step 4: Look back over what you've done.

Once your solution is working, take the time to reflect on it and figure out how to make improvements. This might be the time you refactor your solution into a more efficient one.

As you look at your work, here are some questions Colt Steele suggests you ask yourself to figure out how you can improve your solution:

• Can you derive the result differently? What other approaches are there that are viable?
• Can you understand it at a glance? Does it make sense?
• Can you use the result or method for some other problem?
• Can you improve the performance of your solution?
• Can you think of other ways to refactor?
• How have other people solved this problem?

One way we might refactor our problem to make our code more concise: removing our variable and using an implicit return:

function add(a, b) {
 return a + b;
}

With step 4, your problem might never feel finished. Even great developers still write code that they later look at and want to change. These are guiding questions that can help you.

If you still have time in an interview, you can go through this step and make your solution better. If you are coding on your own, take the time to go over these steps.

When I’m practicing coding on my own, I almost always look at the solutions out there that are more elegant or effective than what I’ve come up with.

Wrapping Up

In this post, we’ve gone over the four-step problem-solving strategy for solving coding problems.

Let's review them here:

• Step 1: understand the problem.
• Step 2: create a step-by-step plan for how you’ll solve it.
• Step 3: carry out the plan and write the actual code.
• Step 4: look back and possibly refactor your solution if it could be better.

Practicing this problem-solving method has immensely helped me in my technical interviews and in my job as a developer.

If you don't feel confident when it comes to solving coding problems, just remember that problem-solving is a skill that anyone can get better at with time and practice.

Good luck!

If you enjoyed this post, join my coding club, where we tackle coding challenges together every Sunday and support each other as we learn new technologies.

If you have feedback or questions on this post, feel free to Tweet me @madisonkanna.

In this tutorial, we'll go over how to solve the CodeWars invert values problem in JavaScript.

Instead of just diving into the code, we'll first read through the problem and make sure we understand it. Next we'll write pseudocode that we'll use as our guide to solve the problem. Lastly, we'll write the code itself.

Let's get started!

First, Read Through the Problem

Here's the problem description:

Given a set of numbers, return the additive inverse of each. Each positive becomes negative, and the negatives become positives.

You can assume that all values are integers. Do not mutate the input array/list.

To solve this problem, first we need to make sure we understand it. Let's go over some questions we can ask ourselves to help us understand this problem.

What are the inputs?

What are the possible inputs to this problem? What will this function receive?

The problem description says, 'given a set of numbers.' This tells us that our inputs are a set of numbers.

The problem also tells us to assume that all of these numbers will be integers.

Lastly, from the examples the problem gives, we can see that the set of numbers will be inside of an array:

Gathering this information, we can say that our input will be an array of integers.

What are the outputs?

Next we can ask ourselves, what are the outputs? What will this function return?

We can see from the problem's example that our output is an array with each number changed to its additive inverse.

Now we know the inputs and output. Next we'll go over a few examples of the problem.

What are some examples of the inputs and outputs?

We already have examples of the inputs and outputs from the problem above, but sometimes it can be helpful to write out a few on your own to get a better grasp of what the problem is asking you to do. Here's one example output and input:

//input
[2, 3, -4]

//ouput
[-2, -3, 4]

Now we know our inputs and outputs, and we have some examples of them.

Now we're ready to move on to writing our pseudocode, the final step before we code out our solution. pseudocode is a plain language description of the steps in an algorithm. Pseudocode will help us create a plan for how we’ll solve this challenge.

To write our pseudocode, let's first break the problem down step by step.

How to Break the Problem Down

We need to be able to look at and do something to each number in the input array. We also want to return a new array with each number changed.

To do this, we can use the map method in JavaScript, which returns a new array populated with the results of calling a provided function on every element in the calling array.

We'll write this out in pseudocode as our step one:

//step one: go through each number in the array using map method

For each number in the array, we want to change it to its additive inverse. We need to understand what this means, so we'll clarify the definition of an additive inverse:

In mathematics, the additive inverse of a number a is the number that, when added to a, yields zero. Here are a few examples:

The additive inverse of −10 is +10, because −10 + 10 = 0

The additive inverse of −2 is +2, because −2 + 2 = 0

To get the additive inverse of a number, we can multiply it by -1. We can test this with some examples:

10 * -1 = -10

-2 * -1 = 2

We now know that if we multiply each number by -1, we'll get that number's additive inverse. We can add this to our pseudocode:

/* 
step one: go through each number in the array using the map method
step two: multiply each number by -1
*/

Lastly, we need to return our new array.

/* 
step one: go through each number in the array using the map method
step two: multiply each number by -1
step three: return new array
*/

How to Code the Solution

Now that we've written our pseudocode, we can code our solution using it as our guide.

function invert(array) {
   return array.map(num =>   {
     return num * -1
   })
}

When we test our solution on CodeWars, it works! We create our function, invert, that accepts an array of numbers. We map over our array, and for each number in it, we multiply it by -1. Then we return our new array.

We can see that it passes all tests. If we'd like to make our solution look a bit neater, we can do an implicit return and remove the inner curly brackets and inner return keyword.

function invert(array) {
   return array.map(num => num * -1)
}

That's it! Now we've completed our invert values problem. We made sure we understood the problem first, wrote out our steps for completing the problem in pseudocode, and then coded the solution.

To check out the other solutions to this problem, you can see them here.

Thank you for reading!

If you enjoyed this post, sign up for my email list where I send out my latest articles and announce meetings for my coding book club.

If you have feedback or questions on this post, feel free to Tweet me @madisonkanna.

Software developer interviews are rapidly evolving. Years ago, mastering data structures and common algorithms was enough to ace an interview and get a job. Today though, employers want candidates with real-world experience and skills.

That’s why many interviewers won’t even ask data structure or algorithm questions at all. Instead, they'll focus on proficiencies with full-stack technologies and collaboration skills.

Job seekers would be wise to practice code challenges and take mock interviews to make sure they’re prepared. There are countless books and resources, such as Cracking The Coding Interview, and popular online code challenge websites.

In addition to those resources, here are the best code interview prep platforms for developer candidates.

Coderbyte

Helpful links: Website | Interview Prep | Blog | Pricing

Coderbyte, my website, is the only site to offer full-stack coding challenges, interview prep courses, and mock interviews. With 500+ challenges, articles, and videos across algorithm, front-end, and even database technologies, you can quickly assess and refine your skills for any role. We also showcase user-submitted and official solutions for all challenges.

Interview Cake

Helpful links: Website | Interview Prep | Blog | Pricing

Frequently considered the best source for interview articles, tips, and content, Interview Cake is a crash course in getting a software development job.

They offer courses that are specific to leading technology companies, and provide guidance beyond solving coding problems, such as advice on how to effectively communicate with interviewers even when you don’t know the answer.

AlgoExpert

Helpful links: Website | Interview Prep | Blog | Pricing

AlgoExpert is one of the original coding challenge websites. The site offers tons of video tutorials, certifications, and interview tips. Their interview prep includes a selection of 100 challenges across all types of technologies and roles.

Interviewing.io

Helpful links: Website | Interview Prep | Blog | Pricing

Interviewing.io takes a very unique approach to coding interview prep. Rather than providing content and practice coding challenges, Interviewing.io has a library of actual video interviews that you can watch, and you can pay to anonymously take a mock interview with an engineering hiring manager.

You may still need to practice coding on another site, but this is a great investment to get actionable feedback.

Leetcode

Helpful links: Website | Interview Prep | Blog | Pricing

Like Coderbyte and AlgoExpert, Leetcode is one of the original coding challenge websites. They offer many interview prep courses for tech companies and roles, and display the average scores for different cohorts of developers so you can easily benchmark.

HackerEarth

Helpful links: Website | Interview Prep | Blog | Pricing: all content free

Famous for their coding competitions and hackathons, HackerEarth recently launched a feature for mock interviews.

They have a massive community of international developers and companies, so this is a great site if you are also looking to connect with a potential employer.

HackerRank

Helpful links: Website | Interview Prep | Blog | Pricing: all content free

Known for their recruiting tools, HackerRank also offers code challenges and interview prep for developers. There's no premium version, so you can access their strong library of challenges for free. It’s a good place to start for a job seeker that isn’t sure yet if they are ready to invest in premium interview prep.

Despite the lowest unemployment rate in decades, analysts expect technology hiring to continue growing steadily into the 2020s.

That’s great news for recent computer science graduates and developers currently working in the field, but that doesn’t mean ambitious engineers can get complacent.

While there will likely be growth opportunities in the market overall, there are still significant changes happening all the time, and a sense of urgency to keep up with the latest trends.

Today, there are more types of technical roles than ever before, and a continued proliferation of new languages, frameworks, and technologies. Technical employees that want to get ahead should routinely test and refine their skills.

To that end, I’ve put together the following list of platforms where you can level up your skills for any number of roles, from data science to developer operations.

1. freeCodeCamp

Helpful links: Website | Forum | Challenges

Let's begin with freeCodeCamp, which is a great website for beginners who are just getting into coding. They offer all sorts of resources on learning syntax, practicing coding, building projects, and preparing for interviews.

They don’t have as many interactive coding challenges as other sites, but they do offer some fun challenges and interview prep for beginners learning JavaScript.

Great for

Novices who are just learning to code for the first time. It’s a great place to learn HTML, CSS, and JavaScript in a fun, interactive way.

Pricing / Premium content

freeCodeCamp is completely free.

2. Coderbyte

Helpful links: Website| Blog | Dev.to | Free Challenges | Premium

My platform, Coderbyte, provides 300+ coding challenges you can solve in an online editor using 10 different programming languages. You can then access official solutions, over 1.5 million user solutions, and read articles on how to efficiently solve the challenges.

Coderbyte is recommended by the top coding bootcamps and companies because of its collection of interview prep challenges.

Great for

Coderbyte is perfect for people in the beginner-to-intermediate phase of their careers who are preparing for interviews. There is a library of harder challenges as well for those who like to solve coding problems for fun, but this isn’t primarily a site for competitive programmers.

Pricing / Premium content

There are a handful of free challenges on Coderbyte, and then there are hundreds of premium challenges and over 1 million user solutions that are available to members.

3. LeetCode

Helpful links: Website | Discussion | Free Challenges | Premium

LeetCode has a collection of some of the best algorithm challenges online today. The topics they cover require knowledge of data structures such as binary trees, heaps, linked lists, and so on, which is why their challenges are a bit more advanced than some other websites. But the challenges are great if used to prepare for a software engineering interview.

They also have a Mock Interview section that is specifically for job interview preparation. They also host their own coding contests, and they have a great discussion board where people talk about interview questions, jobs, compensation, and other topics related to engineering.

Great for

LeetCode is great for intermediate-to-advanced programmers. It might not be the best suited for brand new coders who don’t know how to write basic loops yet, but once you learn the fundamentals this is a great site to practice coding.

Pricing / Premium content

There are free challenges available on LeetCode, and they also have a premium subscription which gets you access to more challenges and other features of the platform.

4. Edabit

Helpful links: Website | Blog | Challenges

This is the first time Edabit is appearing on our top sites list (2018 list, 2017 list)! It has grown in popularity over the last year, and developers seem to really enjoy the challenges. They offer a large collection of over 4,000 challenges that can be solved online in one of several languages.

The site currently only offers online interactive coding challenges — there aren’t any discussion boards, articles, user solutions, or mock interviews like other sites offer, but over time they might be adding some of these.

Great for

Edabit is great for beginners looking to practice their coding skills daily by solving bite-sized challenges. Once you reach the intermediate stage, other sites provide harder challenges and more content geared towards competitive programming and job interviews.

Pricing / Premium content

All the challenges on Edabit are free, and there is no premium pricing option.

5. Codewars

Helpful links: Website | Blog | Free Challenges | Premium

Codewars provides a large collection of coding challenges submitted and edited by their own community. You can solve the challenges directly online in their editor using 20+ programming languages. You can view a discussion for each challenge as well as user solutions. You can earn points and climb the rankings by solving their challenges.

Great for

Codewars is great for people in the beginner-to-intermediate phase. The challenges are created by the community so you get exposed to a lot of different types of coding challenges.

Pricing / Premium content

They offer all of their challenges created by the community for free, and their premium subscription gets you access to some cool features on their platform.

6. HackerRank

Helpful links: Website | Blog | Challenges

HackerRank has a large collection of coding challenges tailored towards algorithms and data structures, along with interview prep material, a discussion board for each challenge, and a list of top user solutions. They have challenges for other topics as well like functional programming, AI, Shell, SQL, and more.

Great for

HackerRank is great for intermediate-to-advanced programmers who have already picked up the basics of a language and are ready to solve more complicated problems. The challenges are written with mathematical notation and can sometimes be a little confusing, which is why it might not be so great for beginner developers.

Pricing / Premium content

All the challenges on HackerRank are free, and there is no premium pricing option.

7. TopCoder

Helpful links: Website | Blog | Challenges

TopCoder is one of the original platforms for competitive programming online. It provides a list of algorithmic challenges from past competitions that you can complete on your own directly online using their code editor.

Their popular Single Round Matches are offered a few times per month at a specific time where you compete against others to solve challenges. Here are some topics that their challenges may cover.

Aside from solving challenges for fun online, they offer sponsored competitions where you can win prizes for writing the best solution.

Great for

TopCoder is better suited for advanced programmers who are comfortable solving algorithm challenges dealing with advanced topics like graph search and number theory.

Pricing / Premium content

All the challenges on TopCoder are free, and there is no premium pricing option.

8. Codeforces

Helpful links: Website | Discussion | Challenges

Codeforces is now probably the top competitive programming website (a few years ago TopCoder was where most competitive programmers spent their time).

There are problems that you can solve online to practice, but there’s no online editor. Rather, you write your solution in your own editor and then upload it to their system which then tests your code against a suite of test cases.

They also frequently hold contests where the best competitive programmers take part in.

Great for

Advanced and competitive programmers who truly enjoy solving difficult algorithm challenges.

Pricing / Premium content

All the challenges on Codeforces are free, there is no premium pricing option.

I believe that one of the best ways to improve your coding skills is to CODE MORE!

For that I have the perfect challenge for you! ?

It's called: #7Days7Websites

The main rule is simple: build one website, every day, for a week.

Here is a short video I made to explain everything in more detail:

You can find the official website here.

Rules

• Create a website every day for a week.
• You can use any programming language and/or any framework you want.
• The website can be on any topic.
• Submit your entries on the submit page.
• Share your progress on Social Media using the #7Days7Websites hashtag.

Live Streams

I'm also going to attempt this challenge in a series of Live Streams on my YouTube Channel. Subscribe if you want to get notified when I go live.

Suggestions

Anyone is free to build anything they want, but if you don't have an idea or you want some inspiration, here are some of the websites that could help:

• Frontend Mentor
• freeCodeCamp
• App Ideas Repository

Showcase

At the end of these 7 days I'm going to make a Special Live Stream where I'm going to showcase the best submissions.

Conclusion

I hope this challenge will get the best out of you and it will help you improve your coding skills! ?

Happy Coding! ?

One month ago I embarked on a challenge that many people told me was insane. I set out to conquer the entire freeCodeCamp curriculum. All while live streaming everything on my YouTube channel.

29 days, 56 Live Streams and 72 hours of live streams later...

First a Disclaimer

I'm a professional software engineer. I've been coding since 2013. And I had previous experience working with all of the technologies covered in freeCodeCamp's curriculum.

So this was easier for me than it would be for people who are just starting out. Most people spend months or even years earning these certifications.

Remember: It's not about how much time it takes you to complete freeCodeCamp's curriculum – it's about what you are learning along the way.

I created this series as a guide for anyone who gets stuck during the curriculum, and wants to watch how a relatively experienced software engineer would solve challenges and build projects.

This series of 72 hours of video covers the following topics:

• HTML
• CSS
• Flexbox
• CSS Grid
• JavaScript
• Bootstrap
• React
• Redux
• NodeJS
• Express
• MongoDB
• Mongoose
• and more...

And I also build 30 projects along the way.

Below you'll find a list with all the videos nicely structured by certifications. ?

How did this crazy month of my life get started?

I've been planning to do this challenge for a while now. But it always seemed to be a HUGE one, which would take a lot of time to complete.

Apparently it didn't take months, as I initially thought. (And I'll tell you why in a moment.)

Before I started this challenge I ran the idea by freeCodeCamp's founder Quincy Larson to see whether he thought that this was something that could benefit the developer community. He was very encouraging.

freeCodeCamp has a "learn in public" culture, and a lot of people post their projects on the forum and on GitHub for feedback. And an increasing number of people live-stream themselves building these projects, too.

Quincy said not to worry about "spoiling" any of the challenges or projects. These are all the equivalent of "open notes tests." Students must write their own code, but they can look at other people's solutions for inspiration if they want.

Why Did I Choose freeCodeCamp's Certifications for This Challenge?

I have always recommended freeCodeCamp's curriculum to people who want to start learning web development.

Why? Well, the answer is very simple: it's the best free resource to get up and running with web development, in my opinion.

Now, even though it's a very good resource, people tend to quit along the way because they start to hit different roadblocks... and that's sad. ?

We want more people to finish the curriculum!

And here is where the Conquering freeCodeCamp's Curriculum challenge starts to shine. It gives everyone a follow-along playlist of videos in which I personally go through the entire curriculum, explaining what I'm thinking with each step I take. I also added my own comments and "bonus" explanations.

Every section on freeCodeCamp is covered in a single video. There are a total of 56 videos. (See below for a list of all the videos.)

My background and experience

I started learning how to code back in 2013. Since then I've worked as a freelance developer and held multiple software engineering jobs.

Last year I started to write articles on my blog. I also started creating YouTube coding tutorials. Feel free to subscribe if you like these type of videos ?.

It is safe to say that I already knew most of what you would learn on the platform, which gave me an advantage on conquering the curriculum in a month.

But, don't let this intimidate you. No matter your experience – no matter if it takes you years to finish the curriculum, just do it. I promise that you won't regret doing it.

I also worked A LOT to put out these Live Streams. Some days I recorded more than 5 hours. One day I even did 8 live streams and ended up completing an entire certification just in that day. ?

Why did I do that?

Well... most people would say that I'm either crazy or a robot.

I'm not a robot. But maybe a bit crazy? Yes. ?

The reason I pushed so hard was because I had plans to go on a vacation. And I wanted to have this all out before going. (Well... the vacation got canceled due to the Coronavirus outbreak. But I'm still happy to have gotten all this done.)

Also probably because I was excited about setting a new world record by finishing the whole curriculum in a single month.

Conquering freeCodeCamp - All the Recordings

Below you can find a list with all of the recordings – 56 in total.

Keep in mind that all of these were recorded in a series of live streams, so you might hear me answer questions received during the live stream from the chat. I also take breaks to do some deep thinking and even struggle to figure out some of the solutions (I'm not a robot after all ?).

All of this is perfectly normal for software developers. When devs get stuck, they often get up and take a break for a few hours – even a day. This can help you re-approach the problem with a fresh perspective.

I built all the projects on live streams (instead of just pre-recording) because I wanted it to be as close to real life as possible. I think this will be of greater value to you than me just walking you through my solutions.

I also created a Discord chat room server if you want to socialize with other people who are attempting this same freeCodeCamp curriculum challenge.

All right, enough talk. Here are all of the recordings. Enjoy! ?

Responsive Web Design Certification

Basic HTML and HTML5 - Live Stream #1 Basic CSS - Live Stream #2 Applied Visual Design - Live Stream #3 Accessibility and RWD Principles - Live Stream #4 Flexbox and CSS Grid - Live Stream #5

Projects

Build a Tribute Page (for Brad Traversy) - Live Stream #6 Build a Survey Form - Live Stream #7 Build a Product Landing Page - Live Stream #8 Build a Technical Documentation Page - Live Stream #9 Build a Personal Portfolio Webpage - Live Stream #10

JavaScript Algorithms and Data Structures Certification

Basic JavaScript (Part 1) - Live Stream #11 Basic JavaScript (Part 2) - Live Stream #12 JavaScript ES6 - Live Stream #13 Regular Expressions - Live Stream #14 JavaScript Debugging - Live Stream #15 JavaScript Basic Data Structures - Live Stream #16 JavaScript Basic Algorithm Scripting - Live Stream #17 JavaScript OOP - Live Stream #18 JavaScript Functional Programming - Live Stream #19 JavaScript Intermediate Algorithm Scripting (Part 1) - Live Stream #20 JavaScript Intermediate Algorithm Scripting (Part 2) - Live Stream #21 JavaScript Algorithms and Data Structures Projects - Live Stream #22

Front End Libraries Certification

CSS Bootstrap - Live Stream #23 jQuery - Live Stream #24 SASS - Live Stream #25 ReactJS - Live Stream #26 Redux - Live Stream #27 React and Redux - Live Stream #28

Projects

Build a Random Quote Machine - Live Stream #29 Build a Markdown Previewer - Live Stream #30 Build a Drum Machine - Live Stream #31 Build a Calculator - Live Stream #32 Build a Pomodoro Clock - Live Stream #33

Data Visualization Certification

Data Visualization with D3 - Live Stream #34 JSON APIs and Ajax - Live Stream #35 Visualize Data with a Bar Chart - Live Stream #36

Projects

Visualize Data with a Scatterplot Graph - Live Stream #37 Visualize Data with a Heat Map - Live Stream #38 Visualize Data with a Choropleth Map - Live Stream #39 Visualize Data with a Treemap Diagram - Live Stream #40

APIs and Microservices Certification

Managing Packages with NPM - Live Stream #41 Basic Node and Express - Live Stream #42 Mongo and Mongoose - Live Stream #43

Projects

Timestamp Microservice - Live Stream #44 Request Header Parser Microservice - Live Stream #45 URL Shortener Microservice - Live Stream #46 Exercise Tracker - Live Stream #47 File Metadata Microservice - Live Stream #48

Information Security and Quality Assurance Certification

Information Security with HelmetJS - Live Stream #49 Quality Assurance and Testing with Chai - Live Stream #50 Advanced Node and Express - Live Stream #51

Projects

Metric-Imperial Converter - Live Stream #52 Issue Tracker - Live Stream #53 Personal Library - Live Stream #54 Stock Price Checker - Live Stream #55 Anonymous Message Board - Live Stream #56

What's next for me?

I will continue to create coding tutorials on my YouTube Channel. One of my main goals for 2020 is to reach 100,000 subscribers. (A crazy goal, I know, but... I think it's possible. What do you think? ?)

I'm also waiting for freeCodeCamp to release the 4 new Python certifications. Then I will work through those as a series of live streams, too.

Along with these, you'll also find me doing other live coding series.
My latest series is called CodeWars.js. If you want to learn more about how to solve different coding challenges using JavaScript, this is for you!

Feel free to subscribe to my YouTube channel if you want to follow along with my journey. You can also follow me on Twitter. I'm pretty active there.

I hope you found this article interesting.

Happy Coding! ?

I Love Challenges! They keep me going. They motivate me. They help me become a better version of myself!

Over the past 2 years I've been doing multiple "crazy" challenges.

I started in September 2018 with the run everyday for 365 days challenge. I completed this challenge and even did a little extra, ending up with 422 consecutive days of running! I also uploaded a photo to my personal Facebook page every day. Social proof - this helped me to keep going.

Last year, considering that I'm also a programmer, I thought to do some sort of programming challenge. #100DaysOfCode is cool but it wasn't at the level I was looking for... I wanted something bigger! So...

I started and completed the #100Days100Projects challenge, creating one project every single day for 100 days. People really enjoyed it! ?

Then, I started my YouTube channel and I planned to "go big or go home" with it. So I thought... ?

"I have to find something big. Something interesting...
I have to create content. A LOT of content!"
(at this point you are probably used to my way of thinking already ?)

So... This year on Jan 1st I started the #31Days31Videos challenge and alongside the 31 videos that I created, I also did 11 Live Streams bringing the total up to 42 videos in a month.

Pretty crazy. But fun, a lot of fun! ?

The next challenge

So as you can see... I love challenges! ?

And now I've been thinking...

"What should I do next? Something bigger... Something crazier...
I want to help the developer community more. I want to create more content!" ?

And then it hit me. ?

What if...

...wait for it...

...wait for it...

What if I'll go over freeCodeCamp's entire curriculum in a series of Live Streams on my YouTube channel? ?

That'll be amazing, right? (And crazy at the same time! ?)

Let me explain this idea to you.

There are currently 6 certifications in the freeCodeCamp curriculum:

1. Responsive Web Design
2. JavaScript Algorithms and Data Structures
3. Front End Libraries
4. Data Visualization
5. APIs and Microservices
6. Information Security and Quality Assurance

My plan is to start from scratch (with a clean freeCodeCamp profile) and go through the entire curriculum, conquering one certification at a time.

It will all be done in a series of Live Streams. At the end the videos will be uploaded to the channel for those who missed the Live Streams or for those you want to rewatch them later.

I already created a playlist where I'm going to add all the recorded Live Streams. Also there you'll be able to find the planned ones for the future in case you want to follow along.

I'm also going to announce everything on Twitter so make sure you follow me there if you want stay up-to-date with my progress.

I also have a Discord server where you can join if you want to follow along and chat with others which are doing the challenge too.

My answer has always been simple: practice as many algorithm and data structures problems as you can.

But today, I have something more concrete for you. A challenge that will expand your computer science and math knowledge – all while giving you a ton of programming practice.

It's called #ProjectEuler100. And a lot of people have already publicly accepted the challenge.

The challenge is named after Leonhard Euler, one of the most prolific mathematicians in history.

Leonhard Euler - the 16th century Swiss mathematician this challenge is named after.

It represents learning on hard mode. Finishing this challenge will demand creativity and problem solving skills you didn't even know you had. It will turn you into an incredibly resourceful developer. It will give you the confidence to tackle the most ambitious projects.

In short, the #ProjectEuler100 challenge will be a crucible where your Super Saiyan self is forged, ready to unleash your latent engineering genius on the world.

Goku going super saiyan.

What is Project Euler?

Project Euler is a website created back in 2001. It hosts a collection of around 600 different algorithm problems that get progressively harder, to the point where even people with math PhD's still struggle with them.

This said, the first 100 problems are totally do-able by a new developer. Thousands of people have completed the first 100 Project Euler problems over the years.

It's just brutally hard. Like... Dark Souls hard.

Dark Souls is a video game famous for being ridiculously hard. But it becomes much easier with consistent practice - just like these algorithm problems.

I love the Project Euler problems. I used them extensively when I was first learning to code. I love these so much that we've added these Project Euler problems to freeCodeCamp's Interview Preparation section.

These will really wrack your brain. But they will be rewarding. They are hard, but fair. And if you're willing to swallow your pride and go down a few Wikipedia rabbit holes, you can solve them, too.

Embedded content

So what do you think. Are you up for solving the first 100 Project Euler problems? Here are the rules.

The Rules of the #ProjectEuler100 Challenge

I've boiled everything down to these 6 simple rules all participants must follow.

1. Tweet out a photo of yourself giving a thumbs-up and announcing that you are committing to the #ProjectEuler100 challenge.
2. Create a GitHub repository.
3. Each time you complete a challenge, add your solution to your GitHub repository and tweet a link to it using the #ProjectEuler100 hashtag.
4. Then scroll through the #ProjectEuler100 hashtag and give supportive feedback on at least 2 tweets from other developers.
5. Move on to the next Project Euler challenge. You can't skip ahead. You have to complete all 100 problems in order. But you can use any programming language you want to solve these.
6. Once you've finished all 100 of them, tweet out a celebration photo of yourself with your laptop open to your GitHub repo.

Where do I do my coding?

You can use the 20-year-old Project Euler website itself.

Or you can use the freeCodeCamp.org version - which lets you code right in your browser, and has built-in tests.

Or if you're feeling spicy, you can build your own website for solving these challenges. (All of the Project Euler problems are Creative Commons-licensed and are free for non-commercial use.)

Why do I need to put my solutions on GitHub?

Putting your solutions into GitHub (Or GitLab or BitBucket) accomplishes several things:

1. It gives you a nice public record of your progress that you can share with other people.
2. It will make your GitHub profile look super active for any employers / clients looking to hire you.
3. It gives you something you can show to your grandkids.

Can I look at other people's solutions?

You can look at other people's solutions for problems that you yourself have already solved.

Each challenge can be solved in many different ways - some more elegant than others. And you can compliment other people on their approaches.

This said, it's 2020. The reality is that solutions to these problems are already peppered across the web. You may accidentally stumble upon a solution if you're searching for hints.

If you are exposed to the solution of a challenge that you have not yet completed yourself, you absolutely should not use the code you see there. You need to come up with code solutions for each of these problems yourself.

Can I live stream my attempts?

Yes. By all means. As I said, the solutions to these problems are already all over the web. And many of the people who would tune in on Twitch or YouTube won't be doing the challenge - they'll just enjoy watching programming streams in general.

So don't worry about "spoiling" anything during your live streams.

We will be live streaming #ProjectEuler100 attempts on freeCodeCamp's YouTube channel.

This said, if you are creating video guides or articles that people would use as a reference to these problems, I encourage you to include spoiler warnings. People want hints so they can get unstuck - not full solutions.

How fast do I need to solve these?

To quote a great man:

"It does not matter how slowly you go as long as you do not stop." - Leonhard Euler

(OK, that quote is commonly attributed to Confucius. But all kinds of quotes get mis-attributed to Confucius, so I'm misattributing this quote to my boy Euler. ?)

The first few problems are relatively easy. But they rapidly increase with difficulty. By the time you get to the final 20 or 30, you may be spending days to solve a single problem.

So don't make the mistake of saying "I'm going to finish these in 100 days" or something like that. Just keep working on these a little bit every day. You've got an entire community around you to help you make it past the finish line.

The community is here to support you

We are all in this together. We're huddled around the #ProjectEuler100 hashtag on Twitter. This is baked right into the challenge rules. ("Rule #4: Scroll through the #ProjectEuler100 hashtag and give supportive feedback on at least 2 tweets from other developers.")

You will support other developers embarking on this challenge. And they will be there to support you.

I also encourage you to join our #ProjectEuler100 Discord chat room where you can chat about the challenge and get help.

And you can follow our #ProjectEuler100 Twitter bot.

So if you're ready, take the first step. Tweet out a photo of yourself giving a thumbs-up and announcing that you are committing to the #ProjectEuler100 challenge.

You've got this.

I finished the #100Days100Projects challenge ? In this article I’m going to cover my experience doing this challenge and I’m also going to answer some of the questions that I received on Twitter about this.

It will be an “ask and answer” type of article, so I hope you enjoy it! ?

What is this challenge about?

The main purpose of this challenge is to build a project every single day for 100 days in a row. You can read more about the rules here. (Note: there is also an easier variant: #30Days30Projects, in case you are interested for something lighter ?)

I started this challenge on 17 September 2019 and finished on 25 December 2019.

What projects have you built during the challenge?

In the last project (#100) I added all the projects that I’ve built during the challenge, so if you want to check them out click here.

All of the projects were web based - frontend mostly (HTML, CSS, JavaScript), and some of them had a little bit of NodeJS for the backend.

I used all sorts of APIs, some JS libraries (ReactJS, p5js - for working with the canvas), but most of the projects were done with Vanilla JS and CSS.

How do you come up with so many ideas?

Apparently a lot of people have asked me this question over these 100 days.

It’s simple: I am a genius. ?

Just kidding ?... I’m far from being that.

The truth is that I gathered a lot of resources over the past year because I needed inspiration for my articles, videos, etc, and I’ve used them to get inspiration for these projects also.

Also, doing this creative process over and over and over, you end up eventually getting ideas from all the things around you. There are some projects that I did because I saw a need in my day-to-day life (Drink Water app, Random Picker Visualizer, Countdown, Password Generator, etc…).

Let’s not forget also that some of the projects were suggested by my followers. (Thank you guys ?)

The resources that I’ve used mostly for inspiration:

• Dribbble
• CodePen
• CollectUI

Did you have a plan for a longer period of time or did you do it spontaneously?

Out of the 100 projects, I think that only 2 or 3 were “planned” beforehand - like a day before. ?

The rest of them were just done spontaneously.

But I wouldn’t recommend doing that. It’s much better to have things planned out - it gets rid of the headache you might get when you have to come up with an idea right away.

Why did you do it?

I LOVE CHALLENGES! ?

As simple as that.

I love pushing my limits and this challenge looked like one that could do that (and it did!). Also, I’ve noticed that if I publicly announce that I’m doing something, I end up actually doing it - maybe because of the shame that I would feel if I fail. I don’t know. Haven’t failed a challenge yet. ?

The first challenge I did was a 365 days of running challenge. I publicly declared on Facebook that I was going to do it and I posted a picture daily with me after my runs. This gave me the strength to finish it (actually ended up doing 422 days). I couldn’t fail my followers, right? ?

And on the other hand, I knew that if I was going to post daily I would inspire others. I wanted to show people that even ordinary people like us can do stuff if we set our minds to it. We have a powerful mind, we just don’t use it at its full capacity!

Yes. I am an ordinary guy. Nothing special here. So if I did it, you can do it too!

How much work did it take to create a project?

Some of the projects I did in under 30 minutes, a couple took me 6-8 hours and 1 or 2 I had to “postpone” to the 2nd day because I couldn’t finish them. Although I postponed these projects to the next day, I recreated them from scratch - only using the gained knowledge. This turned out to be a good way to get "unstuck". Just redo it from scratch.

I would say that I needed around 1-1.5 hours on average per day. This includes: idea + execution + social media.

Keep in mind that I’ve been coding since 2013, so maybe someone with less experience would need a little more time, but it really depends on the project difficulty.

What motivated you to keep going?

As I mentioned above, I think that the shame of failing kept me moving, considering that I publicly committed to the challenge. I can’t fail my audience!

I had a \$25 “punishment fee” which I would have to pay for the failing days, but I don’t think that I ever thought about it after I started.

I added the money aspect because I knew that it would be engaging for people to have it and some of them would want me to fail (sneaky you! ?) so they would check in daily - which ended up giving me a small boost of views on my posts ?.

What have you learned during the challenge?

I’ve learned a couple of things:

• Learned how to “sketch” and plan a project structure
• Learned and played around with some technology and APIs that I haven’t used before
• Learned more about CSS properties (positioning, animation, etc)
• Learned more on how to work with the JS DOM API

It ended up helping me solidify my vanilla JS and CSS skills!

What would you do differently?

One thing that I’ve noticed is that there were more simpler projects that I initially planned. I expected to have more apps with multiple functionalities, but considering the fact that this challenge wasn’t the only thing that I had going, I ended up doing more simple projects (like just a design implementation with HTML/CSS, no JavaScript).

If I would ever do this challenge again, I would either:

• Do fewer days (30 or 50) or
• Focus 100% on the challenge (no more client work or other projects, etc)

This way I could do more “sophisticated” apps.

Nevertheless, I’m happy with the projects that I’ve done considering the given situation.

Also, I ended up spending a lot of time posting on social media (Twitter, LinkedIn, Facebook, Instagram - for which I created a new image every time).

Maybe a good system to “share everywhere” would help to speed up the process.

Don’t get me wrong, posting on SM is important and I wouldn’t drop it, but I would speed it up if possible.

Should people do this challenge?

If you want a good challenge. Yes.
If you want to learn new things. Yes.
If you want to create engagement with your audience. Yes.

Should you do 100 days? Depends.
Do you have the time? Then do it. Otherwise I would only do the 30 days variant.

What’s next for you?

Another challenge. ?

For 2020 I’m planning to go all-in on YouTube so I’m going to start the year with a 31 days 31 videos challenge (more about it coming soon). I want to have a solid backlog of videos for my YouTube channel, so this challenge goes very well for that.

Who knows… maybe I’ll keep doing it if everything goes well.

Subscribe if you want to follow my progress! ?

Conclusion

If you have any other questions, let me know and I’ll be happy to answer and update the article!

I hope this was helpful for you!

Thank you for reading! ?

Read more of my articles on my blog.

As many of you know, I landed my first developer job at the end of June and I thought it would be great to use the challenge I was given as the subject of today's article.

It is important to note that I used React to build my project, but this could have been completed with any front end framework or 'vanilla JavaScript'.

Below is a list of topics we'll go over:

• Accessing the Quip Automation API
• Creating spreadsheets/documents with the Quip API
• Installing and using the Axios library (this is optional and you can make API requests without it but I like the syntax)
• Using qs package to stringify requests (this is not a requirement but I wanted to try something new and if it didn't work I always had the fallback of knowing Axios will stringify my requests by default)
• Making POST and GET requests

For context, here is a snippet of the requirements as I received them:

"Create a front-end web app that interacts with the Quip API in the following ways:

• Create a spreadsheet (bonus points to import data into the newly created spreadsheet).
• By import data, I mean upload an Excel spreadsheet, or copy and paste data into Quip spreadsheet.
• Export a Quip spreadsheet to .xlsx
• Download (backup) a folder/multiple documents.

Create the UI for the page in whatever way you see fit (buttons, dialog boxes, etc)."

I was a little worried when I read the requirements as I wasn't exactly sure where to begin. So, I dug into the API docs and started soaking up information. Thankfully, no time limit was given to me but I wanted to be done with this as soon as possible to see where I stood in the interview process.

To start, I designed a prototype of the finished product in Figma so I'd have a road map to go off of. This is not a required step, but it does make your project building experience run much smoother.

Alright, let's dig in!

Getting Started

I built my Nav, Footer, and Content components so I'd have a solid foundation for my app.

Each of these components return some basic JSX and there isn't much to them (If you'd like to see the code for each you can check out the project's GitHub repo).

I decided the majority of the requests would be split between the App.js and CenterContent.js files.

For reference, here is my project structure:

My project structure

You'll see me reference POST and GET requests throughout this post. If you aren't familiar with those now is a good time to do some research on those. I'll be honest in that I wasn't 100% on them when starting this project and had to go through some resources myself.

In a nutshell, a POST request is when we ask the server to accept some incoming data (that we are sending) - in our case that data comes in the form of creating a new spreadsheet file.

A GET request is when we ask the server to send us data from a specified resource on the server.

I used the Insomnia REST Client to help debug issues with my requests. I'm working on a beginner's guide for it so stay tuned for that!

Using the Quip API

If you're like me, you've never heard of the Quip API and had no idea what it does. At its core, Quip is an automation tool that allows you to integrate with tools like SalesForce to make your sales team more collaborative.

For our purposes, we will be using it to create Excel spreadsheets on my Quip account (if you want to replicate this project you'll need to create a Quip account - it is free to do so).

You'll also need to create a personal developer token in order to make requests. You can do that here (requires an account). Once you have your token, keep it in a safe spot because we'll be making use of it soon.

To start, I installed Axios into my project by running npm install axios and then I import it into the files where I need to make my requests with import axios from "axios";

My import statements for required packages

Authentication

Before making any kind of requests to the server, I needed to authenticate with my credentials. I decided to put this in the App.js file inside a componentDidMount lifecycle method so it would load every time the page loads:

My authentication function

So I built my function, I called my function and for a moment thought all is well, until I ran into this dreaded error:

"Cross-Origin Request Blocked: The Same Origin Policy disallows reading the remote resource at $websiteName"

Noooooooo!!! The dreaded CORS monster rears it's mighty head! (CORS is actually a useful intermediary between me and the server but can be annoying to deal with if you've never seen this error before).

Side note - if you've never seen this error before don't worry! I still don't fully understand it but I know enough to debug it. If you get stuck, check out the link above for some helpful info or look below for a quick work around.

An easy way to get around this is to use a proxy like the CORS Anywhere free resource. Essentially, place this link https://cors-anywhere.herokuapp.com/ in front of your end point URL and it'll resolve the problem, for now.

This handy tool will allow you to make your requests while developing on localhost. If I were you, I would do some research before using this approach in production. Full disclaimer, I don't know enough about this little trick to tell you if it's safe to use in production or not.

So, after some tweaking of the authentication function I got the desired result to log to the console. Time to move on to making requests!

Making Requests

Now that my authentication is working, we're ready to make some requests. I knew I was going to make a POST request whenever I wanted to create a new document and that I also wanted to tie that action to the click of a button. So, below is my POST function:

My POST function

You'll notice this is where our qs package I mentioned at the beginning of this article comes into play. I'm not an expert but from what I gleaned after reading the docs on it, this package turns my request into a string to be sent to the server. If you prefer not to use this package that's no problem as Axios will do this by default. I know that qs offers more than just stringifying data but I'm unfamiliar with the full range of its capabilities.

Now, I want this function to fire when clicking a button. Thus, a basic button came to life!

A simple React button with an on click method

My POST function has been built, my button has been built, and the method tied to it. It's time to cross my fingers and see what my function spat out into the console:

The result of my server request - it works!

At this point I'm over the moon! I'm beyond excited that I've gotten this API call to not only work but to return something as well. Now the real test...does this show up as a new spreadsheet on my Quip account?

I have the console statement and the confirmation from my Quip account showing that I have successfully created a new spreadsheet - this is awesome! I'm ecstatic and I literally jumped out of my chair and yelled "YEEEEEEESSSSSS!!!" once I got both of these.

That feeling of getting something to work after struggling with it is like nothing else I've experienced in my professional life. I tell myself that I have to keep riding this wave of enthusiasm and elation so I push on to the next item on the list.

Import Data Into the Newly Created Spreadsheet

I had some great ideas for this section of the "assignment" but at this point it has been almost two weeks since I started this project and I'm anxious that the interviewer will have forgotten about it (i.e. me) or is getting impatient with me.

So, I scrap those grand plans and opt for something of a more simple nature so I can get this project turned in ASAP.

I built a small function to at least attach to the upload button so that I would have some type of functionality for it. At it's core, this function waits until a file has been uploaded, sets the state to the first element in the event target array, then creates headers based off of that information, with the eventual goal being it posts to my Quip account with that information.

However, you can tell by the comment at the top of this function block that I was unable to get it to work properly. However, I did not have time (at least I thought I didn't) to dig deep into this problem and get it fixed.

My import function that never quite worked properly :)

At this point, I've been working on this project after work and at night for over two weeks. I decide that it's time to turn it in without the other parts working (import, export, and downloading data).

The Final Touches

I know my project is unfinished and I'm beating myself up pretty hard about it. But, as an added bonus I decide that I'm going to design something in Figma as an added touch to help my chances of getting a call back.

Here is the finished product modeled off of their current colors/font/theme:

And That's A Wrap

With my project not finished but at a stopping point, I'm feeling not so good about my progress and my timing but I package everything up and throw it on GitHub. I throw in the above image and schedule an e-mail to go out the next morning at 9AM to the interviewer.

I waited nearly 2 days with bated breath hoping to get some type of call back - something. It finally came as I was driving into work. The interviewer had gotten my project and wanted me to come in for another meeting with his lead developer.

I was terrified and excited all at the same time because I was thinking they wanted to bring me in to make fun of my code or to ask me what the hell I was thinking when I built this monstrosity. But that wasn't the case at all. I ended up getting a job offer from this project!

If you'd like the whole story about that, it can be found in my previous blog post about landing my first developer job.

I hope you've found some value out of this post. If you have let me know on Twitter or any of the other platforms I post on :D

Also, I cross post most of my articles on great platforms like Dev.to and Medium so you can find my work there as well!

While you’re here why not sign up for my Newsletter – you can do that at the top right of the page on my blog. I promise I’ll never spam your inbox and your information will not be shared with anyone/site. I like to occasionally send out interesting resources I find, articles about web development, and a list of my newest posts.

Have an awesome day filled with love, joy, and coding!

You read the title right! I was offered a development position with a company and after some negotiating I accepted their very generous offer!

I am beyond blown away, excited, happy, and (if I'm being 100% honest) terrified - in a good way though. I'm still in disbelief that this is really happening but ecstatic to start working on production code.

I've had a lot of people ask me to distill my journey into an article to share and help others. So, buckle up because here we go.

Getting Started

I've always been interested in computers, tech, etc. Like many people my age, I got to 'cut my teeth' with development by creating a GeoCities site and later by personalizing my MySpace page with some basic CSS.

I didn't know it at the time but this was development, a crude version of it but still development nonetheless. At that time, I didn't know that people would pay for this kind of work or I might have stuck with it. So, I went to college and got a degree in nothing tech related - psychology. Not a useless degree, but one I ultimately never put into professional use.

Finding My Calling

Fast forward to the summer time in 2016 where I found myself with an abundance of free time on my hands outside of work. I had always wanted to teach myself to code/program and decided now was the time - no more delay. With the amount of free and accessible resources online to teach myself how to code it was the perfect time to jump in.

I started by searching for resources and came across Codecademy. I took handwritten notes by copying the entire question, answer, and result into a notebook. I wrote down everything thinking that I would need it. I came back to these notes from time to time to review them. It's also interesting to look back on them and compare what I considered difficult then to what I consider difficult now. ?

A friend introduced me to freeCodeCamp because he knew I was self teaching and told me this platform was built for people like me. I had planned to check it out, maybe do one or two lessons and then go to bed. I finished the entire section on HTML that night! I was hooked.

The more I learned the more questions I had. I felt this urge, this pull to find answers to those questions. So I continued on working through the lessons and projects. I finished 2 projects before the curriculum was overhauled and revamped on freeCodeCamp.

I was finding any excuse to learn and work on projects. While I was standing in any line waiting for something I would pull out my phone and instead of looking at social media, I began to read web development articles or watch a development related video.

I feel like this was a major shift in the way I viewed downtime as compared to previously where "mindless consumption" ruled my time. _(_If you enjoy social media or funny animal videos I'm not calling you mindless, I'm simply saying that type of consumption typically doesn't require you to be engaged. It's the type of consumption that you can do on auto pilot and frankly I still do it from time to time.)

During that time I had bounced around the various different sources and was like a kid in a candy store. At one point I had a folder that had roughly 300 links to material I had planned to work through. I now know that finding a resource and sticking with it is far better than hoping from one resource to another.

I was doing all of this at night when my wife and daughter were asleep. I was staying up until 12:30 AM sometimes as late as 2:00 AM and then having to get up at 6:00AM to do my normal day job. At first, when the topics weren't as mentally taxing this was not an issue. But as I started moving into JavaScript, learning the basics of networking, servers, accessibility, etc I noticed that the later it got, the more difficult it became to keep my brain engaged.

Needless to say, this routine only lasted a few months before having to change it.

I didn't want to stop working on projects/learning but I needed to alter my schedule in order to benefit my well being. That's when I decided to go to the other end of the work day spectrum.

I started getting up at 4:00 AM, instead of staying up late, to learn and work on projects before going to the gym then starting my day. I must say, this was a pivotal moment in my journey because I started to retain more of the information I was learning and that ultimately helped me move forward with more projects/material.

Also, this is the time when I started to buy up every resource I could find (Udemy courses and books mostly) dealing with any aspect of web development. I can tell you that this isn't a wise (or financially sound) choice to make. If you find a resource you like and that you're learning from then stick with that resource until it's exhausted. The last thing you want to be doing is jumping to the new resource each time you find one like I did.

Grow With Google & Udacity Scholarship

The image that came with my acceptance e-mail

In January 2018 I applied for and was awarded a scholarship to Udacity's Front-End Nanodegree program. This was not only an awesome opportunity to help propel me towards my goal but a humbling experience as well.

I came into this program with a basic knowledge of HTML, CSS, and a small portion of JavaScript in the vanilla flavor. In this course I was introduced to jQuery, functional programming, object-oriented programming (OOP), test driven development (TDD), accessibility, servers, API's, basic networking, React, AJAX, and so many more facets of web development that I hadn't previously been exposed to.

I'll be honest, it wasn't always easy or fun and there were times I seriously considered dropping out. I felt like I would never learn these concepts and that I was in over my head.

I'm happy that I didn't quit because no one ever accomplished their goals by quitting - first and only cliche statement I promise :D

I had the chance to build many awesome projects like the Card Matching Game, Arcade Game Replica, Restaurant Review App, and the Neighborhood Map App. More than the projects though, I got to meet many great people and valuable experience collaborating with other developers in the course.

Without this course, I can truly and honestly say that I would not be where I am today. I gained many valuable experiences and lessons in this 9 month course.

Job Hunting...dun dun duuuuunnn!

_Photo by [Unsplash](https://unsplash.com/@sxoxm?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Sven Mieke on <a href="https://unsplash.com/search/photos/job-search?utm_source=unsplash&utm_medium=referral&utmcontent=creditCopyText)

At this point I had been working diligently (sometimes slacking off as well) for about two years. I did not feel as though I was job ready but a friend who became my mentor told me that I'll never feel ready. He said that I should apply and if I get interviews then let them tell me I'm not ready if that's the case but to not exclude myself from an opportunity.

So, with a metric ton of fear, anxiety, and doubt I decided to start applying for jobs.

At first, I was only applying for jobs where I met the majority of the qualifications. I can tell you now that this is not the way to do it, however, at the time I was terrified that someone would actually call me about an interview. (Later down the road I was applying for anything that interested me. Senior developer - sure, I applied for that. Front-end ninja with React skills - yep, threw in an application for that as well. API developer with SQL experience - oh yeah! I applied for that one as well. I did this because you never know what will come of your application. Maybe you don't get hired for that senior role but maybe they like you and your personality so much that they ask you to interview for their junior role.)

That's exactly what happened after I'd been applying for about 3 months. I got a call for my first interview! I was so happy and scared at the same time. Now the pressure was really on.

I read articles, brushed up on my interviewing skills, read books, asked my wife to quiz me on topics, and tried to run through different scenarios that I thought would come up in the interview. I also prepared questions for interviewer because I wanted to know what it was like to work at this company.

Ultimately, I did what I wasn't supposed to do; I convinced myself that this was the perfect job and I wanted it. I wanted it more than anything I could ever remember wanting. I built it up as something that I had to have.

The day of the interview came and to say I was nervous is an understatement. I was sweating bullets. I answered all of the questions and when it was my turn I asked the questions I had prepared. After it was over I left feeling like the interview went well.

Ultimately, I didn't get the position and I was crushed. I felt like everything went like it should have but for some reason the stars just didn't align. Little did I know that this would be a common pattern among my interviews.

I decided not to let these disappointments define or destroy my confidence. I started working harder, learning more, using that disappointment I felt to fuel my passion. I would do whatever it took to ensure that one of these interviews would end with a full time offer.

Here are some metrics about my job search:

• Applications submitted across all platforms: 271
• Any form of contact from company after application: 28
• Phone Interviews: 7
• In person interviews: 8
• Job offers: 3 (one was contract with the (small) possibility for full time, one a part time freelance gig, and the eventual offer that I took for a full time position
• Companies that ignored me after expressing interest: Too many to count

If you are applying for jobs, in any field, don't let the numbers discourage you! Yes it is disheartening, yes it can be daunting, yes it stinks to fill out an application and never hear anything back, but don't quit! You can do this! I'm proof!

My Advice on Your Job Search

This is by no means an exhaustive list of tips/tricks but below are some pieces of advice I've picked up along my journey to getting a job in development:

• Develop thick skin - it's a must! Companies will disappoint you
• Apply for anything you're interested in
• Apply even if you don't meet all of the requirements (this is what I did and also how I landed my first developer job)
• Spend time perfecting your resume
• Just because companies turn you down doesn't mean you're a failure
• Show companies you can do the work by building projects outside of tutorials
• Ask for help if you need it (this was a hard one for me to learn)
• Apply for jobs on all of the major platforms but don't forget that platforms like GitHub jobs also exist
• Ensure you take care of yourself - get enough sleep, exercise, eat healthy (it's important for overall health!)
• Don't be afraid to take breaks
• Don't compare yourself, your job search, your situation, or your skills to others
• If it takes you 3 months or 3 years (like me) remember, this is not a race
• Work hard, learn well, and never give up!

As always, I wish you nothing but the best in all you do. If you need advice or help I'd be glad to do what I can. Connect with me on Twitter or LinkedIn. I'm always willing to help and I love meeting new people!

I also run a personal blog where I write articles related to web development. While you're there consider signing up for my newsletter that I send out once a month with articles and great finds from around the web.

Have an amazing day and happy coding!