Course Roster Generator

• 

  Image

Inspiration

As a grad student, we're given a form to fill out with what electives we want to take, and those preferences are submitted to advisement for them to create a course schedule. We thought about how difficult it would be for administration to manually input everyone's preferences, while also taking into account what professors are able to teach certain courses, and how many students would fit in those courses, and create rosters manually based off that information.

What it does

Our application takes two .csv files- one is formatted with a Professor Name, a Course Name, and how many students would fit in the class; the other is formatted with a Student Name, a Priority Number (the order in which they registered for courses), a first choice of elective, and a backup choice of elective.

How we built it

First we understood the logic our application would need to perform to make the allocation decisions. Then problem is similar to resource allocations but the number of unknowns are dynamic and too many. We decided to focus on a subset of constraints and built our logic around these assumptions:

• The application would be used by someone who already has knowledge and understanding of the process.
• The App is not trying to replace advisors but is trying to help them by creating a blueprint which can save a lot of time.
• The number of courses, Professors and Students needs to be predetermined.
• The courses are independent of each other that means no student can be allocated to multiple courses and no course or section should be taught by multiple Professors.

We converted the above assumptions into logics and preprocessed our input files accordingly using python. The final output and web application is then built using Streamlit.

Challenges we ran into

• One issue we faced is whether or not to include classroom assignments in our program- this would make our application slightly more complicated as we would have to match a class size with a possible room size, and just the class size to the room size when assigned. We decided to leave this feature out, and build the app in a way that treats these rosters as a guide.
• Another issue we had was overloading professors with too many courses, and to mitigate this issue we decided it would be best to add every professor's course manually in the spreadsheet. In order to run another section of the same class, it would have to be duplicated within the spreadsheet. This gives more control to the advisor, who can choose to add another section if needed.
• A major issue that we have is the amount of students that wont be sorted into any class, as there is currently no way to manually add them to a particular course section. Any changes would have to made to the students' course preferences or the Professor's classroom size, both of which can only be edited in the spreadsheets and rerun with the updated information. The more unsorted students' there are, the more tedious it becomes to sort them.
• Another issue is that it can't adapt to dropped classes- if a professor drops a section, the students have to be redistributed to different classes, and there's no way to properly perform this task within our app. Similarly, there is no wait-list implementation, so when a student drops a class there's no way to add a wait-listed student into that section without editing the source spreadsheets in some way.

Accomplishments that we're proud of

• We're proud that our app can work well with different class size "constraints" and given the data and similar schema we would be able to scale up our project to a level that can handle 150+ students and 8+ professors, and 15 class sections allocations simultaneously and efficiently.
• We're also proud that the blueprint can be used to make incremental changes, for example: Advisors can use the templates to create an initial draft using which the application will generate a blue print now the blue print can be used to make changes in the initial templates and can be re-uploaded to the application. This time the application will generate a better blue print then the last time.
  

What we learned

• I (Gina) learned how to code data structures and a back-end application in python and use Streamlit to create a basic web page for data manipulation, what a constraint-satisfaction problem is, and how it can be applied to a real world problem.
• I (Akash) learned how to take a problem I'm familiar with and apply it to a new use case.

What's next for Course Roster Generator

• First we would want to understand how an advisor would make decision with similar information and make our program intelligent by utilizing past information and changes in the logic to mimic those decisions.
• Currently, the program is limited to subset of all the possible real world constraints, we would like to make it more robust and able to work on other real world constraints (i.e. adding a waitlist, multiple class choices for students, etc.).

Built With

• anaconda
• github
• python
• streamlit