rsschool-app Documentation

An application for the RS School education process

10,380 stars TypeScript TypeScript 1 file ยท ~10,478 tokens #hacktoberfest
RAW Doc

Docker & Self-Hosted Deployment Verified OCI

Deploy rsschool-app on any server, homelab, or cloud container platform.

1-Click Terminal Command
bash (docker run) 
docker run -d --name rsschool-app -p 5432:5432 --restart always postgres:15.5
Configured Services & Ports
โš™๏ธ postgres
image: postgres:15.5
๐Ÿ”Œ Ports: 5432:5432
docker-compose.yml
yaml (docker-compose.yml) 
services:
  postgres:
    image: postgres:15.5
    container_name: db
    restart: always
    #volumes:
    # - /tmp/postgresql:/var/lib/postgresql
    environment:
      POSTGRES_PASSWORD: 12345678
      POSTGRES_USER: rs_master
      POSTGRES_DB: rs_school
      PGDATA: /tmp
    ports:
      - 5432:5432

File: README.md

RS School App

app.rs.school is an application for the RS School educational process. It helps thousands of students become front-end, back-end, mobile, and data science engineers.

Monitoring

https://status.rs.school/

Technology Overview

Stack

Infrastructure

Getting Started

Repository is organized into 3 workspaces: server, nestjs, client. Each workspace has its own package.json and npm scripts. We use Turbo to run scripts across workspaces.

Prerequisites

Please install the following software before starting development:

Steps

  • Clone repository
  • Run npm install (installs dependencies in the root folder and client / server folders.)
  • Run npm run db:up (starts local database)
  • Run npm run db:restore (restores a test DB snapshot)
  • Make copies of server/.env.example and nestjs/.env.example, then rename them to server/.env and nestjs/.env respectively
  • Run npm start (starts application by running Next.js and REST API server)
  • Open http://localhost:3000 in a browser
  • See more in CONTRIBUTING guide

Running docs locally

  • Install docsify globally: npm i docsify-cli
  • Run docsify serve -p 4000 docs

Contributing

See CONTRIBUTING guide

Contributors

Code Contributors

This project exists thanks to all the people who contribute. [Contribute].

Made with contrib.rocks

Financial Contributors

Become a financial contributor and help us sustain our community. [Contribute]

Individuals

Organizations

Support this project with your organization. Your logo will show up here with a link to your website. [Contribute]


License

Mozilla Public License 2.0

File: docs/platform/about.md

RS School App

The RS School App is an open-source platform used in the learning process at RS School and developed by community activists.

Links:

Main panels of the RS School App:

  • Dashboard - a panel for tracking the key performance indicators of student's learning
  • Score - a full list of students enrolled in the course, with the total sum of points scored. The list updates daily at 04:00 am Moscow time/Minsk
  • Schedule - course schedule, as well as task start dates, deadlines and links to task descriptions
  • Cross-Check: Submit - a section for submitting links to solutions that are checked using cross-check
  • Cross-Check: Review - a section with solutions that the student must check during cross-check
  • Interviews - list of scheduled mentor interviews and their results
  • Auto-Test - a section for the automatic checking of tasks (tests, algorithmic tasks and codewars tasks)
  • Gratitude (https://app.rs.school/gratitude) โ€” a section for expressing gratitude. Have you been helped with solving a problem, finding a bug, or just checking your work qualitatively? Feel free to write thanks!
  • Heroes page (https://app.rs.school/heroes) โ€” a list of students who are trying not only to gain knowledge, but also ready to share it! Thanks from the Gratitude page are here.

Q&A

How to enroll in the course in the RS School App?

You can sign up for the upcoming courses by following the link.

How to understand that I have enrolled in the course successfully??

Go to RS School App and check that the course is displayed in the course list. Then, open the score tab.
In the header of the table after the inscription GitHub, click on the magnifying glass icon, enter your nickname on GitHub and press 'Enter'
If the nickname is found in the list of students, then you have successfully registered for the course. Congrats!

How do I know if it is possible to register for a course that has already started?

If the desired course is available in the list of courses on the registration page, you can still enroll in it.

How to leave the course in the RS School App?

To leave the course, click the "Leave course" button in your profile, in the "Student Statistics" section.
The course remains in the list, but you will not be able to complete tasks and track statistics.
Attention! Clicking the "Leave course" button excludes the student from the course. You can re-enroll by clicking on the "Back to Course" button.

My progress in the `Total` field on the Score page after passing the test has not been updated, what should I do?

'Total' is updated once a day at 04:00 GMT+3

Overview

Webinar's record "How to study in RS School App" - 1 hour

A unique opportunity to improve your karma right now

  1. Go to RS School App repository
  2. Click :star: Star
  3. Congrats! Your RS School karma has improved :innocent:

File: docs/platform/adding-tests.md

Adding tests into the RS School App (for trainers and admins only)

  1. To add tests, enter the "Manage Tasks" page:

  2. Then click the "Add Task" button:

  3. Fill in the form and save it:

    • "Name" - task title;
    • "Task Type" - select "RS School App Test";
    • "Discipline" - select course-related discipline;
    • "Tags" - set tags (optional) to highlight which aspect of the course it is related to. For example, "javascript", "html/css", etc.;
    • "Description URL" - link to the task description;
    • "JSON Attributes" - copy the JSON file's content with test settings, questions and possible answers (see below).

  4. In the course menu, select "Course Tasks":

  5. Click the "Add Task" button too:

  6. Fill in the form again and save it:

    • "Task" - select the task you have just created;
    • "Task Type" - select "RS School App Test";
    • "Checker" - select "Auto-Test";
    • "Task Owner" - select the person who is responsible for this task;
    • "Start Date - End Date" - set a date of issuing the task and the deadline;
    • "Score" - set a maximum score a student can get for this task;
    • "Score Weight" - task weight (1 by default). It is necessary for the manager of the course to correct it later, so do not change it.

  7. The task is added! Go back to the course menu and select "Auto-Test" in order to check if the task has been added or not.

  8. Select the test you have created in the drop-down list and check if anything is wrong:

JSON Attributes

Parameters:

  • "strictAttemptsMode" - strict mode by default, set "false" to switch off strict mode.
  • "maxAttemptsNumber" - in strict mode, after a certain amount of submissions, a student gets 0; otherwise, a student can submit it as many times as possible, but their final score will be divided by 2 after the max attempts have been exceeded.
  • "numberOfQuestions" - number of questions (it must be equal to the length of arrays of "answers" and "public"."questions").
  • "tresholdPercentage" - the percentage a student needs to reach for the task to be accepted (otherwise they get 0 and loses 1 trial).
  • "oneAttemptPerNumberOfHours" - if the number is positive integer, then submission will be restricted by 1 attempt per amount of the given number of hours, 0 is used by default and means that this option is disabled.
  • "public"."questions" - questions and answers. To add a multiple choice question, set "true" for "multiple".
  • "answers" - an array of numbers of correct answers (the order of numbers must be equal to the order in "public"."questions"!).

NB! student's resubmission implies they get the last score obtained; it is possible to get 0, finally.

An Example:

text
{
    "public": {
        "tresholdPercentage": 70,
        "numberOfQuestions": 10,
        "maxAttemptsNumber": 2,
        "strictAttemptsMode": false,
        "questions": [
            {
                "question": "Do you like html?",
                "answers": ["Yes", "No", "Maybe"],
                "multiple": false
            },
            {
                "question": "What is css?",
                "answers": ["Cascade style sheets", "cosmic super solutions", "cool super stuff"],
                "multiple": true
            },
            {
                "question": "What is not a css selector?",
                "answers": ["", "div", "a.a", "p"],
                "multiple": true
            }
        ]
    },
    "answers": [
        [0],
        [0, 2],
        [0, 3]
    ]
}

PRs for test functionality with added descriptions and examples

File: docs/platform/choose-kata-languages.md

Choose kata language

A small feature that provides an additional option to the codewars tasks.
To count only katas that were solved in a specific language, the kataLanguages โ€‹โ€‹property containing an array of allowed languages โ€‹โ€‹must be passed to the JSON attributes of the task.
You can configure JSON attributes to the settings of a specific task.

For the task with JSON attributes โ€‹โ€‹from the example below, only solutions in Python and Java will be counted.

If kataLanguages โ€‹โ€‹is not passed, then kata solved in Javascript or Typescript are counted.

File: docs/platform/cross-check-flow.md

Cross-check

Cross-check is a peer-review of tasks by students according to given criteria.

Process

Step #1 Sending task to cross-check

To send the task to cross-check, enter app.rs.school and follow the link Cross-Check: Submit. Depending on the task requirements, show either a link to the working and deployed website or a link to the original code/GitHub repository. It is possible to submit the link several times - only the last one is saved. All who fail to meet the deadline and do not provide their link on time get 0 points for that task. Deadlines are shown in the schedule.

Step #2 Generating peers

After the assignment's deadline, peers for cross-checking are generated. Every student has to check 4 other students' work.

Step #3 Checking others' work

All who send their assignment for cross-checking check each others' work. To do so, enter app.rs.school and follow the link Cross-Check: Review.
NB! You won't be able to submit a review after the cross-check is completed, keep an eye on the deadlines!
How to check:

  1. Select the task (For example, Portfolio).
  2. Select the student.
  3. After selecting the student, the link to their assignment will appear. If the link is not working, please contact the student and ask for a working link.
  4. Check the assignment according to the assessment criteria of the task.
  5. Enter the mark in the form.
  6. Leave a comment, explaining the mark given.
  7. Send the form.
  8. Every student checks 4 other students' assignments.

Step #4 Receiving the score and the comment

The cross-check score is an average of all marks given by reviewers. If the number of students who checked the assignment is 4, the lowest mark is tossed away, and the average of the remaining three marks is calculated as the overall score. If fewer than 4 students checked the assignmnet, all scores contribute to its final score. If you do not check all 4 assignments before the deadline, your own assignment gets a score of 0.

Quality of cross-checking

The goal of the cross-check is not only about checking others' work and giving them marks, but also learning for yourself and giving useful feedback to your peers. While checking, try to stick to the following rules:

  • if the work you are checking is of high-quality, let the author know about it;
  • if you think the work you are checking deserves others' attention, add the work's link to the form of the best works. If your own work seems to have been performed at a very high level, you can add it to the form too.
  • if you see any drawbacks in the work you are checking, do not simply list them. Try to help the author avoid such mistakes in the future by telling them how to correct them.
  • if the reviewer has left you detailed and useful feedback with tips on how to improve your work, you can say thanks via rs app. NB: show your gratitude, not for high marks, but for valuable comments and tips.
  • The most useful comments can be shared in discord in the #crosscheck channel (the reviewer's contacts must be hidden)

Marking approach

  • if you think the assessment criteria are fully satisfied, mark it as 100%
  • If you think there are considerable deviations from what has been asked and it definitely cannot be treated as a feature, mark it as 50%
  • If the criteria are not fulfilled, mark it as 0
  • If the criteria imply an interconnected score, mark it either 100% or 0
  • If the deviations are not critical, mark them for the student's benefit
  • If the score you are giving is not the highest possible, be polite and
    • leave a detailed comment on why the score is reduced
    • leave any contacts (Discord, Telegram, etc.) so that the reviewer could change the mark
    • you may always set a new score before the deadline with a comment on why you have changed it
  • If you think the work is copied, you need to:
    • inform the moderator of the course (with a private message)
    • mark it as 0

Please be kind in conversations. If any inappropriate correspondence is noticed (aggression, obscenities, insults, sexism, discrimination, etc.), regardless of whether the score is biased or unfair, the administration will take strict measures, up to expulsion from the course, provided that screenshots of the correspondence are available.

Responsibility for commenting on reduced scores

This is about comments such as:

  1. "good job, here is 50 out of 100"
  2. "....................................."
  3. "just many spaces" etc.

Administrators can check the reasons for the score reduction during the appeal (administrators can see names of anonymous reviewers). Cross-checkers who leave comments like the ones shown above will receive:

  1. A warning in the #moderation channel - for the first time.
  2. Expulsion from the course - for the second time.

Communication rules in the Discord cross-check channel:

If you think the score given to you by the reviewer is wrong, and you want to make sure if it is fair or not, you can do so in the #cross-check channel.

Your message must contain:

  1. A link to your work.
  2. Your self-assessment regarding controversial points.
  3. Reviewer's mark and feedback.

These might help other students in the chat to help you notice your mistakes in case they exist, or agree with your point of view.

Messages in the channel #cross-check must be directed towards the discussion of the work (especially the task's bullet points), but not towards the reviewer or reviewee.

Appeal

  • takes place if there are any activists, who want to drive the process.
  • takes place if you DIDN'T make changes to your work after the deadline.
  • takes place after all checks of your work and step #4 completion (see above).
  • takes place if your expected score and obtained average score (step #4) differ by 10 or more percent.
  • the score can be increased as well as reduced without any further discussion.
  • in case the difference between the score after the appeal and the score obtained in step #4 is less than 10%, the final score will not be increased.

To appeal:

  1. Wait for all the checks of your work and completion of step #4 (see above). Check if all criteria are met in order to appeal (see above).
  2. Create a new issue github.com/rolling-scopes-school/support/issues. Call it by the following template: Cross-Check 'task title' - 'Your GitHub name'.
  3. Fill in the issue with the following template (if the issue has a title, but is not filled in correctly, it will not be reviewed):
  • A link to your deployed project.
  • A link to the project repository on GitHub.
  • A link to the task.
  • A link to the assessment form (if there is any).
  • A screenshot of cross-checking marks (reviewers' contacts must be hidden).
  • A final score after self-assessment, with comments.
  • A cross-check score of your Score.

Appeal process

  • The process starts after the cross-check deadline.
  • There is a guide-mark "help wanted" for a valid issue (Labels -> "help wanted").
  • Free activist chooses the issue - https://github.com/rolling-scopes-school/support/issues.
  • The activist sets a guide-mark "review started" (Labels -> "review started").
  • The activist checks the work following the assessment criteria of the task. Leaves his/her comments and mark. All see it; everything is transparent.
  • The activist sets a guide-mark "review completed" (Labels -> "review completed").
  • The activist notes the trainer (who assigned the task) in the comments of the issue.
  • The trainer submits the score to the RS APP.
  • The new score replaces the current score.

Common decencies

After the appeal process, thank the activist for their work and time. It is desirable if you use RS App Gratitude (https://app.rs.school/gratitude)

Why Cross-check?

Advantages

  • checking all students' works before the deadline
  • 100% understanding of how many people completed the task
  • 95% of students accurately check assignments.
    Responsible students leave valuable comments.
  • an excellent way of checking layouts
  • cross-check allows students to compare their work with others', and understand at what level they are in comparison with other students
  • there is a possibility to see how different students approach the same problem
  • task assessment teaches students to read technical requirements of the tasks accurately
  • students learn to assess tasks, as many of them come back to become mentors in RS School
  • there is a possibility to look at the task from the user's point of view, learn something new about the app (e.g., some behavior that you haven't noticed while making the app)
  • students are more responsible for reading the task requirements as they know that other students will check their work too
  • practical skills of testing the app, which students can use in their projects in the future.

Disadvantages

  • assessments are not always fair
  • an absence of the opportunity to contact the reviewer and discuss disputable moments
  • not all are responsible while checking. Some write several lines, while others several pages of feedback
  • a lot of time spent on checking
  • need exact assessment criteria

Thanks to the contributors of this page:

File: docs/platform/cross-check-scheduling.md

Cross Check Scheduling

This functionality allows you to automatically distribute a Cross-Check and complete it. The distribution buttons for manual Cross-Check distribution and completion are also still available.

The functionality for starting and ending a Cross-Check complements the existing one.
Now Cross-Check starts automatically after the deadline date. The crosscheck completion date is set when a CourseTask is created or when it is edited from the menu on the course/admin/tasks?course={courseAlias} page.

The end date of the Cross-Check is set up to a day.

For example, setting the date to 03/20/2022 means that the Cross-Check deadline is 23:59 03/20/2022 +00 UTC.

Everyday Cross-Check functionality at the beginning of the day starts 2 jobs:

  • Finds tasks that have passed the submission deadline and that have not yet been distributed and distributes them.
  • Finds tasks that have already been distributed and whose Cross-Check deadline has ended and completes the Cross-Check.

To track the status of a task, the CourseTask entity has been extended with 2 new properties:

  • crossCheckStatus - displays the current status of the task. Includes the following options:
    • initial - task submission deadline has not yet ended and it has not been distributed
    • distributed - task has been distributed for Cross-Check, the Cross-Check deadline has not yet arrived
    • completed - Cross-Check deadline has ended, the cross-check of the task has been completed
  • crossCheckEndDate - datestring with planned Cross-Check deadline date

File: docs/platform/cv.md

CV

CV is a 2-part functionality:

  • For users who want to find a job it helps create their own resume and present it to a potential employer
  • For employers who want to find an employee it grants access to user's resumes.

Part 1: CV

User can get access to the CV from the dropdown menu in the header

After this user needs to click on button "Create CV"

There user will be asked to give his consent to the use of user data, after which the CV will become available to user (but not yet available to employers).

CV has 2 views: View and Form.
View is the โ€œfrontโ€ side of the CV and displays the available information, Form allows user to add, modify and delete user information in the CV.

This is how CV View looks like:

There are 3 types of data presented in the CV:

  • Information that the user can freely change directly

    • General info

      • Name - name
      • Desired position - prefered position
      • Self introduction video - link to a video with a short self-presentation
      • Link to avatar - link to the image that will be used as an avatar
      • English level - user's English level
      • Military service - current military service status
      • Ready to start work from - the date from which the user is ready to start work
      • Ready to work full time - is the user ready to work full time
      • About me - a few sentences to tell about yourself
      • Locations - locations where the user is able to work (3 locations can be added, each comma-separated, the extra ones will be truncated)

    • Contacts

      • Phone - phone number (international format)
      • Email - email address
      • Skype id - skype id
      • Telegram public name - Telegram public name (contained in the link to Telegram after t.me/)
      • LinkedIn - link to the user's profile in LinkedIn
      • GitHub username - the github id of the account that user wants to show to the employer (it may differ from the one used for authentication in RS School App)
      • Website - a link to a website (with a portfolio, some profile etc.)

    • Visible courses - the courses user wants to show in his CV and on the Employer page (he can only select courses for which he has registered). User can explicitly choose which courses to show, all courses are shown if no visible courses were selected.

  • Information that is pulled from RS School App and cannot be changed directly

    • Courses - information about the user's RSS courses, includes (for each course that the student is currently taking or has taken and decided to show):
      • Course name - course name
      • Course status - user's status on the course (in progress, completed, completed with certificate, etc.)
      • Mentor - mentor's name and a link to his profile, if the student had a mentor, "No mentor" otherwise
      • Score - total score
      • Position - usert's position in score
    • Feedback - mentor's feedback
    • Gratitudes - public feedback on the user (gratitudes). Displays only the date and text of the feedback, as well as the total. By default, the last 5 records are shown, and it can be expanded by clicking Show all button (after that user will be able to click Show partially button and the last 5 records will be shown again)

If the user is the owner of the CV that they opens (if the githubid under which the user is logged in matches the githubid of the requested CV) user sees control buttons (Edit CV, Share, Delete)

  • Edit CV - when user clicks on this button, CV switches to the Form mode
  • Share - when user clicks on this button, public link is copied to clipboard
  • Delete - when user clicks on this button, delete confirmation popup appears

When user clicks on Edit CV button, the Form will appear where user can fill in the data for the CV


All this data doesn't overlap with user profile/student data/etc, it's associated with CV only.

Also there are few buttons at the bottom.

  • Save button saves the entered CV data on the server
  • Cancel button switches CV to the View mode without saving the data

Other features:

  • CV View can be printed, special styles are applied via @media print when attempting to print

  • Only CV owner and users with roles admin or hirer have access to student's CV

Part 2: Applicants Page

The grouping table at /applicants page contains information for applicantss to find users interested in employment, as well as links to their CVs.

Only users with roles admin or hirer have access to this table. In the UI, the link to that page is in the Admin Sider.

The grouping table includes only those users who have filled in the minimum amount of information to display at the /applicants page and whose CV has not yet expired.

For each record, the following columns are displayed:

  • Name - user name and link to CV
  • CV Expires - the date until CV is valid
  • Desired position - preferred position
  • Locations - locations where user is able to work
  • English level - user's English level
  • Full time - is the user ready to work full time
  • Start from - the date from which the user is ready to start work

Other features:

  • The administrator can delete or hide the record about the user in the table.
  • There are search and sorting by columns.

File: docs/platform/notifications.md

RS School App Notifications

Notification types

  • As a mentor, you are approved to take part in the course (contains links of approval, does not require subscription)
  • Your task has been checked by mentor/cross-check (contains the score, task's maximum score, and weight of the task)

Channels

  • Telegram: Notifications come from @rsschool_bot
  • Email: Notifications come to the email

How to subscribe to/unsubscribe from notifications

In the Contacts card fill in email and Telegram fields without @ in your profile. Contacts are interconnected when registered.

  1. Enter edit mode in the profile
  2. In the Consents card, set a checkmark in front of the channel you want to subscribe to.

To change the state of Telegram subscription in the profile, it is necessary to subscribe/unsubscribe with @rsschool_bot

File: docs/platform/pull-request-review-process.md

Task Checking Process by Mentor

  1. A student completes an assignment in a private repository.
  2. The student creates and submits a Pull Request before the deadline.
    • The PR rules are specified below
    • Penalties for deadline violations are listed below
  3. Until the final grade is given by the mentor, the student can continue to implement remaining features
  4. The mentor checks the PR, leaves his comments and recommendations on the quality of the code (copy-paste, magic numbers, project structure, etc.) and the implemented functionality. Leaves a comment with a preliminary score.
    • The score is set by the mentor based on the assessment criteria specified for each task
    • When giving a score, all implemented functionality must be taken into account. E.g. a student did not 100% fulfill the minimum (basic) requirements, but fulfilled some of the additional ones - all requirements must be taken into account
    • The mentor can set a preliminary score in advance, taking into account that the student will correct all the comments afterwards
  5. The student addresses the comments within 5 days.
    • If the mentor's comment to the PR is pending the student's answer - the student writes the answer as a comment's reply
    • If the student has committed some changes, the student must leave a comment about what exactly has changed
  6. Based on the results of the code review and corresponding changes, the mentor sets the final grade in Score (RS APP > Submit-review).
    • It is up to the mentor to decide whether to deduct points or not for the functionality implemented by the student after the deadline.
    • If the student has not addressed the mentor's comments, the mentor may further reduce the mark. The size of the penalty is at the discretion of the mentor, maximum -50 points.

Pull Request Requirements (PR)

Pull Request is a place to discuss contributor's code. It should not be a monologue but rather a fruitful collaboration between a contributor and a reviewer. Stay professional, respect each other's time and efforts.

Pull Request description must contain the following:

  1. Task URL.
  2. Screenshot showing the result of Task's completion. The screenshot is added to a Pull Request as an image attachment. To achieve that you can just dra-and-drop the screenshot to the Description text area.
  3. Deployment URL of your application. For frontend - Website URL, for backend - API Endpoint URL. To create deployment you can use the following:
    • gh-pages (if you have access to a private RS School repo)
    • web hosting, like netlify.com (if you don't have access to a private RS School repo or can't deploy to gh-pages because of permissions)
    • other static assets storage with web serving capabilities, like S3
    • serverless or self-hosted solutions for your API (make sure URL is public and accessible by other people)
    • naming scheme: GitHub account name - Task name.
  4. Submittion Date / Deadline Date.
  5. Your self-check of Task's completion result and opinion on the achieved Score.

Description Example

text
1. Task: https://github.com/rolling-scopes-school/tasks/blob/master/tasks/fancy-weather.md
2. Screenshot:
   
3. Deployment: https://chakapega-fancy-weather.netlify.com/
4. Done 28.05.2020 / deadline 31.05.2020
5. Score: 220 / 300
- Markup, design, UI (15/30)
  - [x] minimum page width at which it is displayed correctly โ€“ 320 ั€ั… (10)
  - [ยฑ] application's appearancecorresponds to the layout and/or its improved version (5/10)
  - [ ] aaplication works and looks correctly with any language (0)
- Section "Today's weather" displays the following data (15/20)
  - [x] use weather data and location (10)
  - [ยฑ] clock, refreshed each second (5/10)
 ...

Pull Request must not contain the following:

  • Commented code
  • Leftover and/or irrelevant files, auto-generated code, node_modules, etc.

Code Review Process Recommendations

For a more efficient process of code review of student PRs, it is recommended to conduct it in 2 stages:

  • Review of the "Draft" version of the task. The student creates a PR when the "Draft" version is ready, which shows the main concept of the task and implements the main parts of the application. This version may not cover additional requirements.
  • Review of the "Release" version of the task. This is a completed and refactored version of the task, which contains all the changes addressing the comments and suggestions mentioned during the review of the "Draft" version.

This approach solves several problems that are usually encountered when reviewing and implementing large tasks:

  • Reducing the one-time review load on the mentor.
    • It is often quite difficult to carefully look into the entire code of the task in one go and clarify all the concepts that the student missed within the large code base.
    • It is often much easier to find time for 2 smaller reviews, although in general, the total time may be increased.
  • Catching architectural mishaps at the very beginning, which lead to "expensive", in terms of refactoring, problems
  • Learn how to work with Git and GitHub
  • Motivation to meet the deadline

Code Review Process Example

  1. Code Review process can be started with a check of the PR format, the naming of the commits, and a sufficient number of them.

  1. Next, clone the repository, install dependencies, and check if the project is buildable / runnable.

  2. If the requirements included the use of a linter or tests, check for the presence of a prepared scripts to start, lint and/or test the app and whether errors occur after running them.

  3. It is worth checking the overall functionality of the application, whether there are no errors in the console, whether requests are processed correctly, etc.

At this stage, you can pay attention to possible UI / UX problems:

  • whether clickable elements are highlighted
  • whether there is an overlap of elements / text
  • possible recommendations for improving visual appearance of the app if there was no clearly defined design in the task
  1. Now's the time to review the code itself. Here are some potential code quality improvement points:

General

  • DRY - if there are repeating pieces of code, it's better to put them in a separate class/function
  • KISS - try to keep the structure simple and clear
  • comments should explain the purpose of the code instead of describe it
text
Bad

# method to find min value
function findMinValue() {...}
  • no code formatter used, which helps maintain the same code style across the team (e.g. prettier)
  • it is better not to use abbreviations for naming variables / classes / functions, this will improve overall understanding and readability of the code

HTML

  • no alt attribute for the img tag, it is also recommended to set the height and width, which is useful when the image does not load for some reason
  • lack or insufficient semantics
  • redundant blocks
html
...
  • use class names in kebab-case for HTML
html
html
  • if you need to make some kind of heading in the upper case in your HTML, it's better to do it with CSS
  • using inline styles or JS code in HTML, i.e. in the form of an onclick function, is also a mistake

CSS

  • try to apply dynamic styles with CSS classes, not with the use of JS
  • try to write styles with a small degree of nesting (no more than 2x) - this simplifies maintenance and eases refactoring of the style if necessary
  • it is preferable to use the same units of measurement (px,rem or em) which makes it easier to introduce changes (when using preprocessors, you can write a function that will convert px to rem)

JS

  • use event delegation if applicable
  • use parentheses for if else / for blocks
  • magic numbers and magic strings - try to put them into separate constants
  • use enums objects
js
const KEY_CODES = {
	Space: 32,
	Enter: 13,
	...
}

if (key === KEY_CODES.Enter) {
  ...
}
  • file size (large files are difficult to read and maintain, if the file is more than 200 - 400 lines, then you should think about splitting)
  • monitor the degree of nesting of conditional blocks, blocks with a nesting level of 3 or more are difficult to read and perceive, perhaps they can be moved into a separate function
  • try to use pure functions (they are better tested)
  • use named arguments if the number of arguments is 3 or more, this allows you not to follow the order and when reading the code it is more clear what is passed to the function
js
function insertElement({ parent, tag, class, value }){...}

insertElement({ parent: parentElement, tag: 'p', class: 'class', value: 'Some value' })

Deadlines for Students

  • Deadlines for all tasks are indicated in the course schedule.
  • If student did not have time to turn in the assignment on time, mentor, at his own discretion, can apply the following penalties:
    • -10 score points if you are late up to 3 days, inclusive
    • -30% score percentage if you are late up to 7 days, inclusive
    • -70% score percentage if more than a week late
    • penalties can be omitted if there is a good reason (hospital, army training, etc.)
    • rounding occurs in favor of the student, when applying penalty coefficients

Deadlines for Mentors

Mentor is expected to review student's work within one or two weeks of the student's submission. But the sooner the better. Deadline dates for students are indicated in the schedule.

File: docs/platform/shedule.md

RS School App Schedule

To help you successfully complete the selected course, the RS School App has a schedule which can be accessed from the main menu

  1. Select the desired course
  2. Follow the link

General view of the schedule

Schedule Control Panel

  1. Select the type of schedule. The selection is saved for the device/browser

    • Table - the most detailed view of the schedule (opens by default)
    • List - the most compact view for mobile devices (opens by default on mobile)
    • Calendar - common calendar for schedule review

  2. Time zone selection

  3. Switch to hide past events

  4. Customizing event tag colors. For each event/task, you can choose a color from a predefined set of colors. The selection is saved for the device/browser

Table has some more advanced settings, where you can hide some columns and events/tasks by type

Event/Task Details

The event/task details page displays the most detailed data.

Using the schedule by students

It is possible to search by the name of the event/task or the organizer. It is possible to sort by date (type Table). To open the details of the event/task, click on the name of the event/task.

Additional schedule features for the administration

For the convenient usage of the schedule, the following editing options are provided:

  1. Extended Control Panel

    1 - a button to export the course schedule to a csv file for editing the whole course
    2 - a button to import the course schedule from a csv file (new events/tasks are added or existing ones are updated)
    3 - a button to add a single event/task

  2. Quick edit of the Table view

  3. Add a new event/task

  4. Event/task edit is also available on the event/task details page.

Some features of filling out the schedule

  • The main fields in events/tasks change immediately in all courses. E.g. Name, Type, Url.

  • The field Special allows you to specify the type of event/task. For example, make it optional using the optional tag. It is possible to add tags not only from the provided list.

Explore Related Technologies & Topics

View All 9,111+ Repositories โ†’

Discover similar high-velocity repositories, agent skills, and OpenAPI specifications across the ecosystem.

#hacktoberfest Browse hacktoberfest catalog โ†’ โšก MCP Servers Model Context Protocol โ†’ ๐Ÿง  Agent Skills Prompt & rule files โ†’ ๐Ÿ”Œ OpenAPI Specs REST & Swagger schemas โ†’