Elaine

Posted on Jan 19 • Edited on Jun 9

So I completed Replit's free 100 Days of Python course

#100daysofcode #beginners #python #replit

This week I finished Replit's 100 Days of Python.

Around two months ago, I found out about Replit from a friend who started taking their 100 Days of Python course, with no prior programming experience. I've never been too interested in Python, but I've always had the thought to learn it, just only when I really need to. Python does have a reputation of being a beginner-friendly language, and so I was thinking, transferring skills from Javascript won't take that much time. In any case, the thought of doing a bit of Python every day for 100 days sounded doable, and given all the fervor around AI and machine learning, I thought it might be a good idea now to finally dip my toes in a bit. I also should note that, of the people I know who either have some programming knowledge, gone through bootcamps, or use programming in their jobs, nearly all of them learned Python.

With that intro aside, I do believe this Python course deserves a comprehensive review because in my opinion it is one of the best delivered courses on programming that I've taken, especially for complete newbies. If you know how to code already, you may breeze through it fairly quickly (I finished it in 64 days). One of the most interesting features on the course page is this visual course path called the Journey Map that shows you how many people have started the lesson for that day. As you can see, over 225,000 people started Day 1, and around 114,000 progressed to Day 2, which is basically 50% from Day 1.

Out of all the ones who started, fewer than 1000 people managed to finish Day 100 at the time of writing (yes, that includes me).

To put these numbers into perspective, for every 1000 people who start this course, only 4 of them will complete it. I don't know whether a 0.4% completion rate is low or not as I don't have data from other courses for comparison, but judging from my own experience, I wouldn't be surprised if a huge number of people found themselves struggling with the material, even to the point of dropping out. If that happens to be you, don't worry, there are probably many others like you, and the reason could be the course itself, not a lack of understanding on your part. Having said this, there are so many good things about the course, some of which you may not find elsewhere, not even in in-person classes. That's why I think it'd be a shame if those learning code end up stranded halfway just because the challenges got way too difficult to complete.

In this review, I'll go over a number of things, namely:

What you can expect to learn in this course
Which areas I find to be outstanding
What possible hurdles there are for learners
Thoughts on how this course can be even better

For those who want a TL;DR, skip right to the end here.

Course Overview

Course and lesson structure

There are 100 lessons, and each lesson is meant to be covered in a day. The lessons follow more or less the same format, and once you click on the repl (which is basically the "file" or link with the lesson), you'll see the following main parts:

A video lesson where you can follow along with David the instructor as he goes through the lesson content (the lesson can be accessed on Replit's own YouTube channel, where they have a playlist for the course as well)
An area with the lesson content in a multi-page written tutorial
An area with the main.py file where you write all your code
An area with the console tab opened (there's a shell tab as well)
The green "Run" button, where you either run or stop processing the code.
A blue button also near the top that you can click on when you complete the challenge at the end of the lesson.

One thing to keep in mind, the next lesson will be unlocked only if you complete the current lesson, so be sure to click on the blue button when done!

As for the course content, you'll be able to see kind of an overview or syllabus. In the learning hub, aside from the Journey Map, there's a Journey List view that shows you briefly the description of each day or lesson. Even if you haven't progressed to the other days, you'll still be able to look through the Journey List and see what you will be learning later. I find this to be helpful as you know what to expect in the upcoming lessons, and for some people, it can give them something to look forward to as motivation.

Course content

For a course that is 100 lessons long, I think what they intended to cover is pretty ambitious. In Day 1, you're taught the most basic instruction of print() where you just print something to the console, and then in Day 100 you use a library to scrape a webpage for information and then send the info to yourself in an email with a scheduler set up. Here's a list of some things you can expect to learn (and I know these terms may all sound strange if you haven't heard them before):

Setting up and using variables
Using strings, numbers, lists, dictionaries
Using for and while loops
Writing subroutines (or functions)
Using databases, authentication, and environment variables (i.e., secrets)
Complementing our tasks using libraries such as datetime and random (this will be used a lot)
Using a GUI (i.e., tkinter) instead of the console
Building websites and servers using Flask (yes, the course covers basic HTML and CSS)
Retrieving data using APIs
Using AI for various tasks

Challenges and Projects

Most days contain a challenge if there was a lesson presented, but there are also days where it's a project day with no lesson. Whether it's a challenge or project, the course makes sure you have the opportunity to use what they've taught you and build lots of programs. Completing the challenge or project is also what allows you to progress to the next lesson, so if you're stuck on one, you could be there for a while.

Here are some of the things I built during these 100 lessons:

A rock paper scissors game where I can battle with another person
A "Mokébeast" simulation game where I can create my own Mokébeasts and then have them go into battle
A "Choose your own adventure" story game using tkinter
A to-do list manager where I can add tasks, view them or remove them
A secret diary where I need to input the correct credentials in order to access the app and add entries
A website that shows my portfolio and info card
A community chat website that only allows Replit users to use and access the chat
A app that scrapes a website for events I may be interested in and then emails me the info when new events appear

I think any of these can be standalone projects in a portfolio. Often times I did take the liberty to add all the bells and whistles I want, especially when it comes to enhancing the user experience. Having enough programming knowledge prior to this course certainly helped in this area, and I had a lot of fun tailoring the projects.

Course delivery

As a former educator in the school system, I tend to be fairly critical of how course material is taught. I think many people equate teaching with learning, and while the two do work in tandem, just because you "teach" something, it doesn't mean a student has learned it.

After these 100 days, I can confidently say that yes, this course taught me how to write in Python, and it's done this quite well on the whole compared to many other courses I've taken. Credit goes to David the instructor, who is such a trooper for the work he's put into the video presentations and even the solution videos towards the latter part of the course. It's rare to find an instructor who has the ability to walk a learner through difficult concepts in baby steps. The key part is his vibrant personality, which I think is essential for engagement with learners and also for keeping them interested and motivated while going through some tough mental work. For some, there could already be a lot of mental blocks when it comes to programming; having a teacher like David really helps to make that journey much more enjoyable. He could be teaching knitting and I'd still be down.

Watching David code while having the ability to pause the video and try out the code in the repl has been a key to learning, as well as the repetition. Each lesson builds upon what you've learned, and so you are constantly given the chance to practice writing and revising code. Of course, you can also choose to copy and paste what you've written in another lesson; for me, I try as much as possible to write everything from scratch, seeing that the repetition is how learning takes place.

2. The Praiseworthy Bits

Here are five things of what I really like about the course:

Most lessons are bite-sized

There are days when I'd get home late from work late, and I'd still make sure I can work on a lesson or two. They are designed in a way where you need around 30 minutes to work through the material including the challenge, and there may be some challenges and projects that require a lot more time.

Projects have real-world applications

Maybe I can't say this about all projects (see Mokébeasts), but there could be times where you just might need a rock paper scissors game to entertain a young child, or you may want to scrape the web for changes in product prices, or you may need to build your own portfolio (definitely necessary). At the very least, there is no foo bar stuff here.

Content covers a lot of ground in Python programming

As seen in what I listed above regarding their content, they really put a lot of topics into the 100 days. I think for many people who need to use Python for their job or for getting a job, the skills you learned here is probably enough as a foundation. At least you'd be able to write an option menu, build a server, and use AI!

You can code in the Replit IDE alongside video instruction

Unlike a lot of other courses and tutorials where you passively watch the instructor, here you can code along in real time and watch it work (or not work) in the exact same environment. When you follow the video instruction, David would ask you to pause the video and try the code yourself. If you're a newbie, it's helpful when your coding environment is the same as what you see on screen, as you'd only need to focus on writing code and not spend unnecessary time trying to figure out where the folder pane is and how to run your code. In fact, in the first lesson, David would walk you through the Replit IDE to help you get familiarize with its features.

The Replit IDE makes is unbelievably easy for beginners where they don't need to deal with installing software and packages; they can just click on the lesson link that forks the repl, and then they're good to go. They won't need to deal with different programs or even outdated versions of the same program with different looking interfaces. Another learning platform that does this is Scrimba (also an excellent provider), even though Scrimba's instructions are given through their scrims in audio form instead of video. It may be a minor point, but for some visual learners and especially those with hearing impairment, being able to see the instructor's face and read the captions can be greatly effective in their learning, which brings me to my last point...

Instruction method is lively and engaging

This is probably the most important. Even if you got the above four points, there would still be something lacking if the instructor doesn't have enough energy and passion. Once again, thank you David!

3. The Hiccups

As hinted at the beginning, the course is not without flaws, and I suspect that some of these may be impeding learners from further progress. Here are four issues I found.

Some content may not be engaging for learners

I don't play video games, so I don't care much for an app that is a game inventory or an app that lets you create characters and then battle them. Thankfully, these were relatively short challenges and I got through them quickly, but I do understand at least from reading the comments on the YouTube lessons that some learners really don't care for game building. It would be nice to create challenges with those same skills needed but the end product could be something that most people find useful, like writing a simple shopping list, or keeping a list of restaurants you want to visit and then randomly choosing one for you to go to.

Some instructions may not be clear enough

I've had times where after reading the requirements of the challenge, I wasn't sure what exactly I needed to do. One example is in Day 25 where we needed to write a program to create a character in a video game with their stat numbers randomly generated through subroutines.

I remember that I completed Step 1 by writing said subroutine for rolling a die, and then I was confused about what this subroutine was for, since there was no additional explanation. I followed the instructions for Steps 2 and 3 in writing another subroutine, but it didn't occur to me at all that the roll subroutine in Step 1 was to be used in Step 2. Scaffolding learners is necessary when they are building upon prior knowledge; even something as simple as "Use the subroutine you wrote in Step 1" would have been enough. Also, I don't know whether it's relevant here, but in any case I'm a native English speaker, so reading comprehension shouldn't be an issue in most cases (unless operating under sleep deprivation).

Some lessons contain either inconsistencies, mistakes, or missing resources

It's one thing when the console brings up red error text due to something you wrote in your code, but when that error came from the instructor's code, it can be super frustrating if you're a total programming newbie. Not only are you just learning to fix your own code, now you're supposed to fix the instructor's also. One example to bring up for this point is in Day 64, a lesson on Object Oriented Programming (and by the way, you will hear David say "orientated" instead of "oriented", which is just due to language variant differences because he is British). Here's a code snippet from the section on inheritance:

As can be seen in the screenshot, the talk() method is missing in the animal class and in the bird subclass, but actually it was there in the previous page of the tutorial, and somehow it got left out on this page. In any case, you'd definitely get an error when you run this code as is. Following this, the next code snippet contains another error:

In the bird subclass, the initiation excluded color as the second parameter, but clearly it appears within the initiation method and also in the polly variable assignment with "Green" being passed in the subroutine call. There's also the point where the lesson talked about setting all the characteristics to None prior to the initiation, but color is not set to None in the subclass. This actually is not an error and won't be flagged, but this is indeed an inconsistency and can be confusing for learners, as they may wonder why it's not needed in this instance.

Missing resources was also an issue for some lessons. For the lessons on Flask in building webpages, some images just weren't in the repl even though the tutorial had those images as part of the instruction. In the end, I needed to download images myself.

Certain challenges are either too difficult or required skills not yet taught

Some challenges took me more than a day to finish because I only had an hour or so after I got home from work, and an hour wasn't enough. Sometimes it might be because the challenge involved several parts, and building multiple things from the ground up without looking at previous code can take some time. There were also challenges where I need more time because additional non-code resources had to be created, such as the challenge for writing a graphic novel, which had me hunting the web for story illustrations. (By the way, it'd be good if they had actually provided the content needed for the challenge instead of needing to hunt for an illustrated story, which actually wasn't easy.)

There were a few times though when the challenge really was too difficult, like the calculator challenge on Day 66, which is the first lesson on tkinter. In the lesson for the challenge, we are taught how to place text and inputs on the screen, and one task that was shown was to input some numbers in a text box and then see it added up, as displayed in text in the window.



import tkinter as tk

window = tk.Tk()
label = 0

def updateLabel():
  global label
  number = text.get("1.0","end") 
  number = int(number) 
  label += number
  hello["text"] = label 

hello = tk.Label(text = label).grid(row=0, column=1)
text = tk.Text(window ,height=1, width = 50).grid(row=1, column=1)

Then comes the challenge for the lesson, which is as follows:

)

It sounds simple enough, but if you've ever built a calculator before, you know how much logic is involved. The skills taught in this lesson and even those in the previous ones are likely not enough for learners to complete the challenge on their own. It's a bit like teaching someone 1 + 1 = 2 as the first lesson, then ask them to add up the accumulation of bank interest over 10 years (which, by the way, was also one of the challenges), and then go over how to use multiplication to solve the problem. In any case, the only thing I'm thankful for is that this Day 66 challenge didn't require adding the decimal point. At least for me, I got to use this opportunity to practice building a calculator without referencing other code I've written, but most definitely I found myself wondering whether some poor soul out there has given up entirely.

Suggestions for Improvement

My feedback here is mostly from a teaching point of view, but it will also have things that those with a non-teaching background can relate to. I also realize some of these likely can't be implemented since the course has video content, and redoing those may not be possible. In any case, here's a list of three suggestions:

List the lesson objectives and topics at the start of the lesson, and make sure the challenges only cover the exact objectives and topics. Challenges should be manageable enough and should focus on skills taught in the lesson instead of too many additional skills (even non-programming skills), whether those skills have been taught already or, even worse, not covered yet. For instance, in the calculator challenge, a good chunk of the lesson was on using the input box, including the example on adding numbers in the tutorial. However, the challenge omitted the input part and instead required the use of lambda functions, which wasn't covered at all in the lesson and was only listed in the "hint" section (but these hints are all hidden by default unless you click into the section). Also, for my calculator to be functional, I had to include a lot of if/else statements, which really wasn't the focus of the lesson. In other words, I felt that a large part of the challenge really wasn't about using the skills learned in the lesson. If I were to rewrite this one challenge, I'd make something smaller and more doable, like a tip calculator, where you only need two numbers that you type into the input boxes.
Review the lesson content after creating it, and make corrections and updates if necessary. Mistakes in lesson content is frustrating for learners, and at times can be detrimental to their learning. I saw a post on the Replit community forum where a user was trying to figure out why the code wasn't running in one of the lessons, and it turns out there was a mistake in the code given. I noticed that the later lessons especially had more frequent occurrences of mistakes and inconsistencies. Also, the Open AI library has seen a few updates since the course was created, and some of the code doesn't seem to be usable any more. I also needed to be creative at times and find appropriate content for the challenge when the original just wasn't available, like the Replit Community Events page, which was needed for the web scraping challenge but no new events have been posted for a long time.
Try to choose topics and content that are appropriate and accessible for the majority of users. It's hard to write with the world wide web in mind, but it does help to visualize what kind of users there could be using this material, especially when this is for learning purposes. I found that some content may either be not appropriate or accessible to some users, like the Open AI API, which isn't available for the area where I'm currently in, and so I needed to find an alternative. When it comes to topics, certain lessons were somewhat insensitive (and perhaps even juvenile), like writing an insult program, something that could be triggering for those who have encountered bullying or constant verbal abuse. Maybe some users could find it funny that David is constantly making fun of his own baldness, but for me the bald jokes got tired after a while. There were also times where the content may not be understood outside some cultural contexts, such as games like BINGO and Hangman, which may only be played in certain parts of the world. I'm sure there are alternatives, and if there aren't, it would be helpful to at least introduce and explain the content as if the audience is seeing it for the first time instead of assuming they should know how rock paper scissors is played.

Conclusion

Overall, 100 Days of Python with its engaging teaching style is a great course that I highly recommend to all learners, whether you're a complete newbie or someone with programming experience already, but do keep in mind that you may run into some difficulties along the way due to the content, whether the level of difficulty, the lack of clarity in some instructions, or even just plain mistakes in the code (which is really unfortunate). I suggest bringing in additional material to supplement your learning instead of only relying on the course material. Even a short Python YouTube Tutorial would do, just something that gives you another look at how Python is used. I do hope that beginners who take this course will remain motivated and encouraged, despite getting stuck along the way. For those that get stuck, there's a forum on Replit for 100 Days of Code, and that's a place where learners could ask questions and hopefully get some help. And did I mention already this course is completely free? As far as free content go, you'd be hard pressed to find something like this. If you're looking to learn Python, try giving this a go.

Did you take the course as well? What kind of stuff did you find helpful, or are you currently stuck on a lesson? Feel free to share your thoughts in the comments below.

Top comments (8)

Subhayu Kumar Bala • Jan 20

All of that was nice and helpful. But they missed the PEP-8 guidelines and how you can improve the readability of the code.

For eg, class names should be CapWords (Animal, Bird) and function names should be snake_cased (update_label).

Here's a much more readable version of the OOP example

from typing import Optional


class Animal:
    def __init__(
        self,
        name: Optional[str] = None, # you can use `str | None` instead of `Optional[str]` since Python 3.10
        species: Optional[str] = None, # also, the above and this lines are don't follow the PEP-8 guideline of 79 characters per line
        # whereas this line follows it
        sound: Optional[str] = None
    ) -> None:
        self.name = name
        self.species = species
        self.sound = sound

    def make_sound(self) -> None:
        print(self.sound)


class Bird(Animal):
    def __init__(
        self,
        name: str = "Bird",
        species: str = "Avian",
        sound: str = "Tweet"
    ) -> None:
        super().__init__(name, species, sound)


# Example usage
polly = Bird()
print(f"{polly.name} is a {polly.species} that says:")
polly.make_sound()

Elaine • Jan 21

Thank you for the info on PEP-8! I did wonder a few times what are the naming conventions that should be followed, since the instructor does change it up sometimes in the examples.