Labper: Lab Performance Evaluator
Tags: 2020devgrad, octograd2020, django, githubsdp
Published: 2020-05-20 08:27:43

---
title: Labper: Lab Performance Evaluator
published: true
description: I just graduated from college with a bunch of projects, want to highlight one of them named Labper.
tags: 2020devgrad, octograd2020, django, githubsdp
---

## About Labper

It was around Sept 2018 (Start of 5th semester of my Engineering), we have a course named Software Engineering (CS-302), in which we learn about different [Software Development Life Cycle (SDLCs)](https://www.tutorialspoint.com/sdlc/sdlc_overview.htm) and best practices.

We also have to submit a project at the end of course with tons of documentation on how we created that project.
On top of that, the project you create should be of value.

### A little backstory

When thinking about problem statements to pick with my [team](https://labper.herokuapp.com/about/), I remembered one of my friends from IITK telling me about [Prutor](https://ict.iitk.ac.in/product/prutor-a-coding-platform/), a software to manage labs session and much more.
We thought about our current lab evaluation scenario, we found out a bunch of issues in the process.


Let me create a list of issues for a quick overview:

- My institute had only 2 branches (as of 2020): CS & IT, hence most of the assignment involves some kind of code.
- The current process was to write, compile and test code on Lab Computers and then submit the zip for Code with Documentation (which has test cases you ran) and then upload it to Google Classroom.
- The Lab Computers limit the kind of compilers (languages) we can use, plus the checking of the assignment was with pretty random test cases, hence most of the codes missing corner cases might pass the evaluation.

We decided to move on with this problem statement for our institute and started working on planning the MVP.
We spent around 15-20 days on tons of documentation (~20 includes Database Design and stuff) created (as part of course work) and then we had 15 days to code out the MVP.

## Implementation

We started executing our plans from the very beginning of the project, the landing page shouldn't be misleading and hence we simply added only the Sign In Button.

### Whitelisting Domains and Validating Users

Now we needed to whitelist few domains for OAuth and we started on deciding on how we can set permissions (user categorization) on login itself.

Then we came up with a solution using the email address pattern that we have in our institute, which is:
- For students, it will be all digits (Year [4 digits], Branch [2 digits], RollNumber[3 digits]).
For example: If your batch started in 2016 and your branch is CS (51) and your roll number is 1, then your email will be `201651001@iiitvadodara.ac.in`
- For Professor/Staff, it will be all alphabets with some special characters. Ex: `heet.sankesara@iiitvadodara.ac.in`.

Hence we clearly drew a line on the login itself for all kind of things are to happen on the homepage.

We differentiated it using this code:

```py
@login_required
def home(request):
    user = request.user
    month = datetime.date.today().month
    year = datetime.date.today().year
    
    # Session Type was an ENUM(w: Winter, a: Autumn)
    session_type = 'a' if month > 6 else 'a'

    session, create = Session.objects.get_or_create(year=year, type=session_type)
    target = Profile.objects.get(user=user)
    is_teacher = not target.user.username.isdigit()

    if is_teacher:
        teacher, create = Teacher.objects.get_or_create(profile=target)
        courses = teacher.course.all() # Courses opted for being taught
    else:
        # First 4 digits of username
        batch = int(target.roll_no[:4]) + 4
        
        # Get the 5th and 6th digit of username
        branch = target.roll_no[4:6]
        
        student, create = Student.objects.get_or_create(
            profile=target, batch=batch, branch=branch)
        
        # Courses for the batch of user
        user_courses = Course.objects.filter(target_batch=batch)
        for c in user_courses:
            student.course.add(c)
        courses = student.course.all()

    context = {
        'courses': courses,
        'upgd': is_teacher,
        'session': session,
    }
    if student:
        context['student'] = student
    
    return render(request, 'landing/home.html', context=context)
```

The above home is function is pretty much what our home function looks like, but we also have to cover the case where the user is TA (Teaching Assitant).
So, the problem one is over, now the user is inside the matrix and is identified by Labper.
We also created a small pipeline along with social-auth, to get the user's profile picture from Google.
The pipeline's code is something like this and it is executed as part of the login

```py
def get_profile(backend, user, response, details, *args, **kwargs):
    url = None
    profile = Profile.objects.get_or_create(user=user)[0]
    if backend.name == "google-oauth2":
        if response['picture']:
            url = response['picture']
    profile.avatar = url
    profile.save()
```

Now we have fully functional Auth and stuff.
Next comes the Course, Lab Creation Part

### Course, Lab Creation, and Notifications

Now, since for testing we needed an email address which is all made of alphabets, as a student we didn't have one, but we had the email of `codingclub@iiitvadodara.ac.in` which acted as a professor for our whole testing time.

- We created a bunch of more tables Lab, Assignment, Session, etc.
- The create Course, create Lab, promote to TA, invite to Course features were given to Professor. Also, the ability to view all submissions for course and mark them.
- As soon as a student logs in, they enroll for all the courses made for their batches and can start submitting lab assignments directly.

For notifications, we used Django's core `send_mail` functionality. So if you are enrolled on Labper and some new course is added for your batch, you will receive an email for the same.

### Solving development environment issue

One of the MSP of Labper, as we mentioned in all the docs, was that it will remove dependencies from Lab Computers.

Now we needed to add an IDE to the platform, we started looking for what we can do in a day or two (certainly we can't make an online IDE of our own).

Hence we took a trial for SPOJ's IDE widget and added that to our platform so that students can Code, Compile and Test the code there itself, in most of the languages.

Also, we added a plugin with it named [Test Case Generator](https://tcgen.aashutosh.dev/), which is a small script that lets you generate random test cases for the correct code. So that Professors can test the code on multiple random test cases and the scale is not biased anymore.

## Demo Link

You can tryout Labper here:
https://labper.herokuapp.com/ (Currently sign in only works for `@iiitvadodara.ac.in` Accounts), you can fork it and host your own with different domain whitelisting.

## Link to Code

The repo was last updated around the submission of the project itself and requires maintenance. New maintainers will soon be assigned.

{% github https://github.com/aashutoshrathi/labper %}

## How we built it 🛠

At that point in time, the members of our team were pretty proficient in [Django](https://www.djangoproject.com/) and had some experience with Javascript EcoSystem too.

We used:

- Django (For almost everything)
- [UIKit](https://getuikit.com/) as CSS Library
- Javascript (Of course everything on the web is incomplete without it)
- PostgreSQL as Primary Database
- Google OAuth (for whitelisted domains)

We used Heroku for DB Instance as well as our own deployment and also got some credits using [GitHub Student Pack](https://education.github.com/pack)

## Future Work

There is plenty of improvements that can be made to Labper in its current state.
- We need to renew SPOJ IDE Widget's subscription.
- We can add Plagiarism Detection features on the platform
- The auto-scoring of submission based on given test cases can be done using a new service.


## Additional Thoughts

I normally struggle with writing blogs, but somehow the Labper story was handy for me to write, because of the memories created and lessons learned while implementing the project.

I hope the experience was helpful to you. If your institute faces a similar kind of issue, feel free to fork Labper and customize and host it as your own.

[Final Note]: # (CONGRATULATIONS!!! You are amazing!)