1. Learning based on practice
There are people who love CodeGym with all their hearts, and there are people who hate it with all their hearts. But even CodeGym's most vicious critic will readily agree that it has an impressively huge number of tasks. And the reason why there are so many of them is because all CodeGym training has practice as its foundation.
Programming is a skill. Nobody says, "I know how to program". Every programmer says, "I can program". It is a hands-on skill, like swimming or playing chess. And you can only cultivate the skill through constant practice.
That's why the entire CodeGym course is a sequence of increasingly difficult tasks. You start with very easy, primitive tasks, and end with the most difficult and interesting ones. The difficulty grows a little with each level. This is precisely the path that will lead you to your goal of becoming a programmer.
2. Types of tasks
A whole bunch of different types of tasks await you on CodeGym. Let's list the main ones:
Tasks where you write code following an example
This is the simplest exercise. The purpose of these tasks is to practice your ability to write code. To solve the task, you will need to write code just as it exists in the sample code. This is very useful, but it gets boring very quickly. There are almost no such tasks left: we've replaced them with tasks that are more interesting for CodeGym students.
The cards for such tasks are marked with the letter T:
Tasks where you write a program
These are the most important tasks in the course. Their difficulty level varies widely: from the simplest tasks to those that you will have to think about a lot.
The goal of these tasks is to write a program that meets specified conditions and requirements. Most tasks fall into this category. For the convenience of CodeGym students, we mark these tasks according to their difficulty level: EASY, MEDIUM, HARD and EPIC.
EPIC tasks are often based on future learning material in lessons you have not yet unlocked. They are popular with CodeGym students who feel the course is too easy for them. Others can simply skip these tasks and return to them later, when they have already become familiar with the relevant theory.
The downside to ordinary tasks is that they are small. Done and forgotten, as they say. Therefore, it is rarely possible to make them highly interesting. But a large program is difficult to test: there are simply too many ways to implement it.
That's CodeGym introduced project tasks — large tasks divided into 10-30 ordinary subtasks. You perform all the subtasks sequentially, and you end up with a large program.
At the end of each level in Multithreading and Collections quests, there is one large project task, which is divided into twenty subtasks. There are also another 6 game tasks, which are also projects. In total, there are 27 project tasks in the entire course.
For a long time, CodeGym had no tests or quizzes. CodeGym's creator holds the opinion that passed tests create the "illusion of knowledge" in people. People don't really know how to program, but they are thoroughly convinced otherwise, since they passed the tests. Such people stop learning, since "they already know everything".
Subsequently, quizzes were added to allow CodeGym students to easily identify gaps in their learning. It is useful for programmers to know the nuances of the things they work with on a daily basis in their profession.
Finally, the very last type of task is watching a video. A lot of useful and interesting videos related to the IT industry have been included in CodeGym lessons.
3. Task statuses
Each task on CodeGym has a special status. The status can change as you solve tasks.
Each CodeGym task is associated with a lesson. Initially, you won't have access to any tasks, which means you won't be able to solve them.
When you open the next lesson, all the tasks in the lesson become available for solving, i.e. their status changes to "Available".
If you have submitted a task for verification at least once, then its status changes from "Available" to "In progress".
Finally, when you have successfully met all the requirements and the validator accepts your submission, then the task's status changes to "Completed".
Users with a Premium Pro subscription have 3 more days to try to write other solutions for the task. After this additional window of time expires, the task moves into "Closed" status, and this status will no longer change.
To make it easier for you to solve tasks, we've written a special widget: WebIDE. It looks approximately like this:
On the left, you see the task conditions and requirements that your solution must satisfy. In the center, we have the editor, which is where you need to write your code. Your program displayed some text, which you can see in the pane at the bottom.
And at the top you will see these buttons:
- Verify: Submit your solution for testing.
- Help: Ask a question about your solution in the CodeGym community.
- Discuss: Discuss the task with other users.
- Reset: Reset your solution, i.e. start over.
- Run: Start the program without submitting it for verification (your verification counter won't increase).
- Code analysis: Get suggestions on your solution's code style
In the early years of CodeGym, when you verified each task you got a simple result: yes or no. The program either passed all the tests or it did not. Super simple, but not super helpful.
As people learn, it is very important that they understand what they are doing wrong and how to start doing it right. Accordingly, it makes perfect sense that if the server doesn't accept your solution, then you would ask, well, what's wrong with it?
To get an answer to this question, you need someone to dive into your solution, analyze it, and tell you what's wrong with it. This would take a long time and be expensive. The beauty of instant task verification is that you can sit down to study at 2 AM and it will all work just like any other time.
That's why we rewrote all the tasks on CodeGym. Now each task has not only task conditions, but also a list of 5-10 requirements that flesh out the conditions. Most importantly, each requirement is verified separately.
That means that when you submit a task for verification today, you will get an extended response: next to each task requirement you will see a special icon indicating whether your program satisfies this requirement or not. Example:
This approach greatly simplifies life as you work on tasks that require you to write several classes or methods. You will always be able to see which methods or classes you wrote correctly and which you did not.
Is it possible to make the tasks even better somehow? Wouldn't it be great if, after each check, you were told what exactly is wrong in your program and got hints about how to fix it? Yes, that would be cool! Well, guess what? We do just that on CodeGym 🙂
We catch dozens of common mistakes by checking each task requirement. If your program makes a mistake that the validator knows about, then it makes a recommendation — a hint on how you can fix your solution so that it satisfies all the requirements.
Think about it. There are now roughly 1200 tasks on CodeGym, with a total of approximately 10,000 requirements. And there are several recommendations associated with each requirement. Some requirements have dozens of them. CodeGym's validator is ready to make over 50,000 recommendations for user solutions.
Plus, all this happens as your solution is validated, which in most cases takes less than a second. No person could do that. This is a real virtual mentor.