Inspiration

What inspired our team to make ScheduLit was our work schedule as students. We often find ourselves with so many deadlines to meet, but with no clue how to partition our time efficiently. Which assignments have the highest priority? Will I get everything done in time? How will I meet multiple deadlines? These are all questions that ScheduLit answers.

The creation of ScheduLit stems from the common dilemma of having to schedule tasks, and not quite knowing if your schedule will allow you to complete all the tasks you set out to accomplish. By solving this problem, we're taking some of the stress out of figuring out what to work on, and from there, helping people get their work accomplished faster.

What it does

ScheduLit is a Google Chrome extension that allows users to input a list of tasks, which will then be organized into the most optimal schedule through the implementation of a greedy algorithm. The input consists of the task name and deadline, the estimated number of hours required to complete the task, and the user’s preference for the task (on a scale from 1-10).

From there, we seed our greedy AI with our temporary starting schedule, and it then populates a new calendar with the best schedule. The schedule adheres to the most regular intervals of working hours while honoring limitations like sleep schedules, inactive hours, and permanent events that are already on the calendar.

Our greedy heuristics factor in how early the tasks are completed in relation to the deadline, the preference to complete a task, and how variant the task blocks are listed. For instance, a long task spread out over the course of a few days is better than a long task that is completed all in one day.

How we built it

The technologies we used to create ScheduLit include vanilla JavaScript, the Google Calendar API, and a Python to JavaScript transpiler called “Transcrypt.” First, we discussed our vision for the project and the features we wanted. Then, we split up the work by having one front-end developer, two back-end developers, and one full-stack developer. We occasionally checked in with each other and used Git to ensure that we were all on the same page. Finally, we reconvened to combine the frontend and backend.

Challenges we ran into

The challenges we encountered were both individual and team-based.

Our team had very little experience in front-end development, and as a result, our front-end developer had to do a considerable amount of research before she could start stylizing the extension and implementing user input.

Our back-end developers were not familiar with JavaScript at all, and as such resorted to Python. However, Google Chrome extensions are only compatible with JavaScript code, so the back-end developers researched ways to implement, or at least convert, python to javascript code. Luckily, they found a way, by using Transcrypt to transcompile the code. We ran into troubles when dealing with converting our Python’s heapq library, so we ended up having to create our own.

Our back-end developers also had a rough time determining the starting states for our heuristic, as well as what greedy algorithms to run in order to optimize trade-offs between efficiency and accuracy.

Our full-stack developer faced challenges in dealing with Google Calendars. The recommended google cloud API is incompatible with Chrome Extensions due to security constraints, so he had to make the HTTP requests manually.

Accomplishments that we're proud of

We are proud, first of all, that we completed our first hack together. We have two members of our team who are doing their first hack, and their motivation to stick through the weekend is something we are extremely proud of.

We are also proud that we were able to find solutions to most of the problems we hit, such as finding the transcompiling software, or our full-stack developer configuring the GET and POST requests manually for the HTTP header when he realized that Google Calendars hate Chrome Extensions.

What we learned

We learned about the importance of task delegation and communication. While splitting up tasks between team members can accomplish a lot, it can also be confusing. There were some elements on the front end, such as the structure of the user’s input, that were handled differently on the back end. As a result, we learned that we needed to keep each other notified of our progress.

We also learned that preparation is important. When we came into this hackathon, we had an idea picked out, but not necessarily which tools we needed. Oddly, the default Google API for JavaScript is incompatible with Chrome Extensions due to security requirements, knowing this would have saved hours of time Similarly, if we had known that we had to use JavaScript, we might have been able to prepare and spend more time on development.

We also learned that it's okay if we don't know how to do something, because Google's always got our back. Thanks, Google.

What's next for ScheduLit

What's next for us is diving deeper into the User Interface for ScheduLit. We'd like to have a sleeker UI, with more options in the settings for inactive hours, preferred tasks over others, and pre-set tasks to include in our calendar. We would also like to improve the efficiency of the algorithm behind the scenes so that we can process a large number of tasks more quickly. After this extension is implemented, we'd like to explore making this into an actual calendar app. Combining our efforts with other CS students passionate about efficient scheduling, we are going to create a fantastic Calendar AI that will plan your week with no thought on your part.

Built With

Share this project:
×

Updates