Background

While at work last week, my coworker gave me an interesting riddle. After working through it myself and giving it to some friends, I decided to make a little write up on the riddle and its solutions.

The Riddle

There are 900 elephants in a race. Bob and Charlie know which elephants are in 1st and 2nd place.

You are allowed to ask Bob a question about the race that he will respond to with a number from 1 to $n$. After that Charlie will give you the number of either the 1st or 2nd place elephant.

You have to use Bob's answer to determine whether Charlie's number is the 1st or 2nd place elephant.

What is the lowest upper bound of $n$ Bob can give you so that you can determine if the elephant Charlie gave you finished in 1st or 2nd?

Clarifications

Can you ask Bob which elephant got first place?

Yes, if you ask Bob who got first place, you can use his answer to determine whether the elephant Charlie gives placed 1st or 2nd. However the upper bound for $n$ in this case is 900 (there are better answers).

Can Bob answer with fractions or decimals?

No, he must either answer with whole numbers or have the ability to map his possible answers to whole numbers.

Can you ask Bob multiple questions?

You can make the question you ask Bob as long as you want. However, Bob is only allowed to answer with a single number. You are allowed to make each digit depend on a sub-question, but then the lowest upper bound would be the range of possibilities that Bob would answer with.

For example, you could ask Bob 2 yes or no questions and have him answer with a 2 digit number (1 digit per question) where 1 means yes and 2 means no. Since there would be 4 possible answers Bob could give (11,12,21,22), the upper bound for $n$ would be 4.

This Sounds Like a Math Problem?

What problem isn't a math problem! Here's a version of the riddle formatted as a math question:

• Let $A$ = The set of answers Bob can give
• Let $E$ = The set of unique elephants in the race
• Let $\mathcal{F} = \{f : E \times E \times A \to \{0,1\}\}$ be the set of questions you can ask Bob where:
  • $f(\text{🐘}_a, \text{🐘}_b, \text{ans}) = 1$ if elephants $\text{🐘}_a$ and $\text{🐘}_b$ can be distinguished using Bob's answer $\text{ans}$
  • $f(\text{🐘}_a, \text{🐘}_b, \text{ans}) = 0$ otherwise

Find the minimum possible $|A|$ such that:

Can Bob tell the future?

A peculiar individual asked me this question to which I answered yes out of curiosity. He then answered: "I would ask Bob to say 1 if Charlie is going to say the 1st place elephant, and 2 if Charlie says the 2nd place elephant". I have not seen a solution with a lower bound than this.

The Intuitive Solution

A non-optimal but still efficient way of solving this problem is as follows:

1. Have Bob tell you a position of the first digit in the 1st place elephant that is different in the 2nd place elephant.
   • He will say 1 if it's the ones digit, 2 if it's the tens digit, and 3 if it's the hundreds digit.
2. Have Bob tell you what the value of that digit is for the 1st place elephant.
   • He will answer this as a number from 0-9.
3. Have Bob combine the 2 numbers as his answer

Since there are 30 possible answers Bob can give (3 max digits $\times$ 10 possible values), the lowest upper bound that Bob can give you is $n = 30$.

Example of the Solution

• Let the 1st place elephant be $\text{🐘}_{45}$ and the 2nd place elephant be $\text{🐘}_{149}$
• Bob will answer "15" since the ones digit is "5" in the 1st place elephant and "9" in the 2nd place elephant
• There are 2 numbers that Charlie can give you:
  • If Charlie gives you the 1st place elephant ($\text{🐘}_{45}$), you can see that the ones place digit is "5". Since you know the 1st place elephant has this characteristic and the 2nd place elephant doesn't, this must be the 1st place elephant.
  • If Charlie gives you the 2nd place elephant ($\text{🐘}_{149}$), you can see that the ones place digit is "9". Since you know the 1st place has a "5" in the ones place, this must be the 2nd place elephant.

Optimizations

The intuitive solution assumes a base 10 number system. Surprisingly, different number systems like Base 12 and Base 7 will give different answers. Below is a more general approach that accounts for different bases:

1. Let $B$ be the base of the chosen number system (decimal, binary, etc.)
2. Determine the maximum number of digits needed to represent 900
   • We'll refer to this as $D$
   • $D = \lceil \log_B(900) \rceil$
3. Have Bob return position of digit along with value
   • Bob will answer in format $(d, v)$ where $d \in [1, D]$ and $v \in [0, B-1]$
     • $d$ represents the digit position (1st, 2nd, 3rd, etc.)
     • $v$ represents the digit value in base $B$

In this solution, the minimum upper bound of answers will be $n = D \times B$. However, since we know that $D = \lceil \log_B(900) \rceil$, we can simplify the upper bound to $n = \lceil \log_B(900) \rceil \times B$. Below are some example bases and their respective results:

What's Going on Here?

Why does changing the base of the number system change the minimum upper bound so much? To answer this, let's dive deeper into what's happening in our solution. When we choose a base for our strategy, we're implicitly creating $D \times B$ different groupings of elephants. Each group is defined by fixing a value of a specific digit to a constant value.

Here are the groupings for $B=10$ with padded zeros to more clearly show the pattern:

Since there are 2 digits unconstrained in each group, there are $10^2=100$ elements per group¹. This means the total number of elephants including duplicates is $30 \times 100 = 3000$, meaning each elephant appears in exactly 3 groups ¹.

Using the Groups

Now let's explore why this way of grouping elephants helps Bob answer our question. When we ask Bob to tell us which digit is different and the value it should be, we're essentially asking Bob to tell us which of the above groups contains the 1st place elephant but not the 2nd place elephant. Once Bob gives us a group, we just check if the elephant Charlie gives us is in that group. If it's in the group, Charlie gave us the 1st place elephant. Otherwise we know it's the 2nd place elephant.

We know that there is guaranteed to be a group that contains 1st place but not 2nd place because of two reasons:

1. The 1st and 2nd place elephants are represented by two different numbers
2. Every pair of 2 distinct numbers must have at least 1 different digit for all number systems

The Advanced Answer

With the previous strategy, we discovered that we are actually turning the 900 elephants into 30 groups (for $B=10$) such that for distinct values $\text{🐘}_a$ and $\text{🐘}_b$ (1st and 2nd place elephants), there is guaranteed to be a group that contains $\text{🐘}_a$ but not $\text{🐘}_b$.

Now we wish to determine the minimum number of groups we need to be able to distinguish the 1st from 2nd elephant given 900 distinct elephants.

Grouping by Hand

Let's start by hand choosing groups for smaller numbers of elephants:

These groupings work because all elephants appear in at least 2 groups which have no shared items besides the elephant in question. This means that for all possible 1st and 2nd place pairs that Charlie can give, Bob can give the number of the group containing only the 1st place elephant.

A Better Representation

Now let's try to generalize this to larger groups of elephants. Instead of explicitly showing the groups, let's assume $n$ groups and give each elephant an $n$ length encoding that says what groups they are a part of. For position $i$ of the encoding, let 1 signal that the elephant is part of group $i$ and 0 that the elephant is not in group $i$.

Using the Representation

To determine if any 1st and 2nd place elephant pair Charlie can give is valid, we can now just compare each elephant's encoding to see if there is a position where 1st place has a 1 and 2nd place has a zero.

Below is an example of how you could use the above encoding to determine:

• 1st Place = $\text{🐘}_3$ and 2nd Place = $\text{🐘}_5$
• Encodings:
  • $\text{🐘}_3 = 1001$
  • $\text{🐘}_5 = 0101$
• Since Position 1 for 1st place elephant is 1 while 0 for 2nd place elephant, we know Group 1 contains 1st place elephant and not 2nd place elephant. Therefore Bob will answer Group 1.
• There are 2 numbers that Charlie can give you:
  • If Charlie gives you the 1st place elephant ($\text{🐘}_3$), we see from $\text{🐘}_3$'s encoding (1001) that it is in Group 1 and therefore must be the 1st place elephant.
  • If Charlie gives you the 2nd place elephant ($\text{🐘}_5$), we see from $\text{🐘}_5$'s encoding (0101) that it isn't in Group 1 and therefore must be the 2nd place elephant.

The Underlying Pattern

If you look closely you'll also notice that each elephant encoding has exactly 2 1s in its encoding of length 4. An interesting property of this representation is that as long as every elephant is in exactly $k$ groups (when a 1 appears $k$ times in the elephants encoding), then for any 2 elephants $\text{🐘}_{a}$ and $\text{🐘}_{b}$ there will be a position in the encoding such that elephant $\text{🐘}_{a}$ will have value 1 while elephant $\text{🐘}_{b}$ has value 0. In the original solution, each elephant appeared in exactly 3 different groups out of the 30 total showing it also follows this pattern.

What are the rules for picking the number of groups ($n$) and number of 1s ($k$) allowed for each encoding? With $n$ groups and a fixed $k$, we can derive the number of unique encodings with $\binom{n}{k}$. So for our example above when $n=4$ and $k=2$, we can uniquely represent a max of $\binom{4}{2}=6$ elephants.

We now need to find the optimal $k$ such that we can minimize $n$ for 900 elephants. To do this, we need to find the minimum $n$ such that $\exists k: \binom{n}{k} \geq 900$. Before we try to solve that directly², let's try and simplify the problem a little more.

Optimizing the Pattern

You may notice when you plug in $\binom{n}{k}$ with different $n$ and $k$ values, it tends to be maximal for a given $n$ when we choose a $k$ that is about $n/2$. This can be formalized with the below theorem:

Sperner's Theorem: The largest possible family of non-overlapping subsets for an $n$ sized set can be calculated as:

$|S| \leq \binom{n}{\left\lfloor n/2 \right\rfloor}$

If and only if each subset has size $k = \left\lfloor \frac{n}{2} \right\rfloor$ or $k = \left\lceil \frac{n}{2} \right\rceil$

We can now use this theorem to more simply represent the problem. Let's start by testing values $n$ with the equation $900 \leq \binom{n}{\left\lfloor n/2 \right\rfloor}$ on different values until we find the minimum number of groups that work.

If we try with $n=11$, we get $\binom{11}{\left\lfloor 11/2 \right\rfloor} = \binom{11}{5} = 462$. This shows us we need more than 11 groups as $462 < 900$.

If we try with $n=12$, we get $\binom{12}{\left\lfloor 12/2 \right\rfloor} = \binom{12}{6} = 924$. As $924 > 900$ we know this is a valid number of groupings. Additionally, since we know $n=11$ doesn't work and we need to use whole numbers for numbers of groups, the minimum upper bound Bob can give is $n=12$ ³.

We can generalize this to different sized elephant races by using a binary search from 2 to the size of the race to find the minimum number of groups using the above equation. I created a handy little visualization tool to help create visualizations for generating the optimal groups below:

Conclusion

In this post, we first determined a way to distinguish any 2 elephants of a 900 elephant race from a set of 30 possible answers based on the digits of the elephants' numbers. We then discovered we can lower the set of possible answers to 20 by using a different number system such as binary instead of decimal. After this we dug deeper into why this trick worked and used the intuition to calculate the smallest possible set of answers³ which turned out to be 12.

The next time you're at an elephant race and have an annoying friend named Charlie who loves giving cryptic answers, make sure you use this strategy when you talk to Bob!

Background

One of my favorite party games is Quiplash from Jackbox Games. Jackbox games are unique because they leverage the fact that (almost) everyone has a smartphone to create a unique game experience. However, it still requires a computer/console and a display to play, which makes it hard to use when traveling. In 2024, me and my wrestling club teammates tried to set up a game after our national tournament, but weren't able to get it set up in our hotel room due to the previously mentioned issues. We ended up finding a russian cards against humanity clone to play, but it planted the seed for me to create Gluck Arena, a jackbox style website that doesn't need a computer and display combo to play games. In this blog, I'll go over how Gluck Arena works along with an overview of its signature game: Quizzer.

How Gluck Arena Works

Technical Architecture

Gluck Arena is mobile first website designed for arbitrary multiplayer party games. It was designed for party games and doesn't require players to create accounts. At a high level, it was built with the following technologies:

• Typescript: A typed superset of Javascript with static typing
• Cloudflare Pages: A platform that is able to host serverless NextJS applications
• Convex: A real-time backend as a service (BaaS) platform

The multiplayer features leverage Convex's sync engine, which ensures all players see the most recent game state. This architecture allows for a seamless multiplayer experience without complex state management, as long as the games don't require extremely frequent and complex updates to specific rows of data.

Key Components

Player Management

When a player first enters Gluck Arena, a unique ID is created for them as their "account" and stored in a browser's session storage. This will allow them to refresh their page without losing their account, while also allowing me to test games by making new tabs in a single browser. Once an account is created, the below form then appears asking to enter a username that will be used for their time in Gluck Arena.

Once a username is chosen the player ID and username are added to the "players" table in the Convex database. The username can be changed anytime using the "change name" form in The navigation bar. If a player refreshes the page or leaves and re-enters the browser session, the unique ID from the session will then be used to check the database for a corresponding player. If there is no ID in a user's session storage or if their ID isn't found in the player table, a new ID is created and the player is assigned to the new account.

Game Management

Each game instance in Gluck Arena is stored as a single row in the "games" table. A game consists of three properties: a join code to allow players to enter a game, a type to represent what type of game is being played, a status to show if a game is joinable/in-progress/completed, and a state that contains the information needed to play the game. There is also a "game-player" table used to track which players are in which games.

Convex allows documents, or "rows" in a table to contain a maximum of 1 mebibyte (MiB, which is slightly bigger than a megabyte) of data, 16 layers of nesting for objects, and 8192 objects per array. This makes it easy to store all the game logic in a single row in the "games" table. In addition, the game logic is typed using a Typescript union type to ensure type safety even though rows can represent different games. However, for games like Quizzer, an additional table is needed to store available questions.

To ensure the table doesn't get filled with expired games and old players, a Cron Job is configured to delete each once they've reached predefined "oldness" thresholds based on activity and age. Once a game or player is deleted, a database trigger is activated to delete rows in the "game-player" table that reference it.

Quizzer Implementation

To implement a game in Gluck Arena, there are 5 requirements: a type to represent the game logic, backend functions to allow game actions, and a React page for each of the game statuses (lobby, active, and finished). The lobby page is shown when a game is created, but waiting for all players to join. There are also typically settings in this page shown to the game creator for configuring the game for things such as number of rounds to play. The active page is used to play the game and the finished page shows the leaderboard of who won. Because implementing a game is so standardized, AI tools like Cursor can be used to implement a lot of these requirements.

The rules of Quizzer are simple. Each round, players answer questions assigned to them such that each question is answered by exactly 2 players. Then, players vote on which answer was better for each question (except for the answer writers) and players get points depending on how many votes their answer got. At the end of the game, whichever player gets the most points wins the game.

There are 2 types of questions in Quizzer: the default questions (which I put in the database) and AI generated questions (which are dynamically generated per game). Before each game, the game creator has the option to allow AI questions and enter in a prompt to give a theme to the question if entered. The creator can also specify how many questions they need, allowing a mix of AI and non-AI questions. The creator can also add custom questions by hand through a UI in the lobby page.

For each Quizzer game, there are $n$ questions per round where n is the number of players. When a game is created, it randomly selects $(n*\text{num rounds} - (\text{num AI Generated} + \text{num custom questions}))$ from the question database and starts the game. It then divides the questions up into $n$ rounds and assigns each question to 2 players. At the start of each round, players then go into "question answering mode" where they answer their assigned questions. If players are taking too long to answer questions, the game creator has the ability to end this mode early and AI generate answers to unanswered questions. After this mode is over, players vote on prompts with the game creator controlling the speed at which the game is played. This is repeated for each of the rounds in the game.

Conclusion

One thing that makes Gluck Arena stand out from my other projects is in how it's based on the features/limits of Convex. Without Convex, the multiplayer features would be significantly more complex to implement and likely more expensive as well. This project reminded me of Warpstream, a Apache Kafka compatible product that simplifies and cheapens stream processing by leveraging the features/limits of object storage. I recently wrote a report on the patentability of Warpstream for a class that goes into more detail if you'd like to learn more.

Overall, I believe that the biggest takeaway from this project is the power of designing projects around specific technologies. I feel there is a lot of unneeded pressure in software engineering to make projects backend agnostic and infinitely scalable. However, designing projects around a technology like Convex or Object Storage often has tangible benefits. This is more obvious in Warpstream's case as it was acquired for $220 million 13 months after it was released for essentially rebuilding Kafka from the ground up around modern technologies. I suspect this trend will continue as technology gets better and platforms give stronger guarantees.

Background

Ohio State University has a lot of students (60k+). Students often get hungry, so OSU has a lot of dining halls, each with a lot of different food options. Finding a dining hall to eat at can be tricky, especially if a student has dietary restrictions or nutritional goals (bulking or losing weight). This blog post goes over how I made OhioState.food to make it easier to browse OSU food options and how I used an inverse index to make it fast.

Project Structure

OhioState.food is a Nextjs deployed using Cloudflare Pages. It uses Cloudflares's Nextjs adapter to work with Cloudflare and has the drawback of only supporting the edge runtime for Nextjs (Cloudflare Workers acts as the server). Cloudflare D1 is used for persistence (essentially a hosted sqlite database).

The data is sourced from Nutrislice's API, which has menu information for every dining hall on OSU campus. Every morning, a cron job on Github Actions is used to run a script that updates the database with the latest menu items using the "populate" endpoint on the site. Once the data is uploaded, I use Nextjs Server Actions to query the database with the Drizzle ORM for type safety.

Food Searching

The easiest way to choose a dining hall to eat at is to start with the food you want to eat and work backwards. Lets start with a simple query that queries the "food" table in my database based on food name, dietary restrictions, and nutritional information.

-- Simplified Query

-- Get all columns from foods table, aliased as f
SELECT * FROM foods AS f
-- Filter foods where name contains the search query
WHERE f.name LIKE '%{query}%'
-- Filter by dietary restrictions
AND f.dietary_info == {dietary_filter} 
-- Filter by nutritional requirements
AND f.nutrition == {nutrition_filter} 

This query takes around 10-15 seconds to run on the foods table with 1k+ foods. I found this to be slow, especially since I wanted to display food results on the site live as the user was typing.

The traditional way to speed up a SQL query is to add indexes to frequently read columns in a table. This slightly slows down write speed and increases table storage size, but speeds up queries significantly as the database no longer needs to do a linear scan on the entire table. Dietary and nutrition information are easy to index on as they only need equality and range comparison for queries. However, indexing on full text search with conditions f.name LIKE '%{query}%' requires a bit more effort than simply adding a built in sqlite index. This is where inverted indexes come in handy.

Inverted Indexes

Inverted indexes are a special data structure made to speed up full text searching. They work by creating a mapping of tokens (processed words) to documents. I'll demonstrate how they work by showing what happens when a food document is added to an already existing inverted index.

Step 1: Get Tokens From Document

The first step to adding a document to the index is to get a list of all words in the document. This is called tokenization. Lemmatization or stemming is also typically done here to ensure words like "steak" and "steaks" are map to the same documents.

Step 2: Construct or Add to Inverted Index

Once the tokens are retrieved from the document, a check is done to see if there is an entry in the inverted index for that token. If there is, a reference to the document (typically its ID) is added to the structure. If there is not, a new entry in the index is made with the document reference as its initial value.

Step 3: Querying the Index

There are many ways to handle full text queries with an inverted index, but a simple way is to tokenize the query the same way the document was tokenized, get relevant documents using the inverted index, and ranking them on relevancy using an algorithm like BM25. There are many possible optimizations here, such as using data structures like tries to enable searching on prefixes or by tokenizing the index on trigrams to allow substring matching. Overall though any of these techniques should make full text queries drastically faster than a linear scan with string comparisons.

Implementing a Fast Full Text Search

Implementing an inverted index and effectively using it for full text search is a lot of work. Luckily, there are many ready to use database extensions that allow you to leverage these structures without the hassle. FTS5 is a sqlite extension that handles full text search with inverted indexes for you.

FTS5 works by allowing you to create virtual tables (essentially code that pretends to be a table) backed by an efficient full text search engine (which uses inverted indexes). It also includes additional features like proximity and phrase search. I've attached the FTS5 setup from OhioState.food below.

-- Create FTS5 virtual table on name field in food table
CREATE VIRTUAL TABLE IF NOT EXISTS foods_fts 
USING fts5(name, content=foods, content_rowid=id);

-- Create triggers to keep FTS table in sync
CREATE TRIGGER IF NOT EXISTS foods_ai AFTER INSERT ON foods BEGIN
    INSERT INTO foods_fts(rowid, name)
    VALUES (new.id, new.name);
END;

CREATE TRIGGER IF NOT EXISTS foods_ad AFTER DELETE ON foods BEGIN
    INSERT INTO foods_fts(foods_fts, rowid, name)
    VALUES('delete', old.id, old.name);
END;

CREATE TRIGGER IF NOT EXISTS foods_au AFTER UPDATE ON foods BEGIN
    INSERT INTO foods_fts(foods_fts, rowid, name)
    VALUES('delete', old.id, old.name);
    INSERT INTO foods_fts(rowid, name) 
    VALUES (new.id, new.name);
END;

-- Populate FTS table with existing data
INSERT OR IGNORE INTO foods_fts(rowid, name)
SELECT id, name FROM foods; 

The virtual table can now act as a full text search index that can be used to match a search query for a food item much faster than before. For more details on how FTS5 works, check out this blog. Below is an example of a SQL query that uses the table to do a search on food name, with dietary and nutrition restrictions.

-- Simplified FTS Query

-- Get all columns from foods table
SELECT f.* FROM foods AS f
-- Join with the FTS virtual table
JOIN foods_fts AS fts ON f.id = fts.rowid
-- Use FTS MATCH instead of LIKE for faster search
WHERE fts MATCH '{query}'
-- Filter by dietary restrictions
AND f.dietary_info == {dietary_filter}
-- Filter by nutritional requirements
AND f.nutrition == {nutrition_filter}
-- FTS tables automatically provide ranking
ORDER BY rank;

Our new query now has a full text index on food name along with the existing indexes on dietary nutrition information, bringing down our search delay to <1 second¹. Try it live here!

Conclusion

In this post we

• Walked through the design of a food search app for Ohio State Dining halls.
• Explored how inverted indexes can be used to speed up full text search.
• Implemented the FTS5 extension into a sqlite database.

The next time you are trying to design a system with full text search, remember that you will likely need a specialized system like an inverted index if you expect any scale at all.

Live demo

The Wrestling Backstory

Not too long ago, I helped my club wrestling team host a competition across three schools. To score a college wrestling match, you need a scoreboard, a timer to track how much time is left in a period, and a special clock to track the riding time for the match. Riding time is simple to calculate: while a wrestler has control of their opponent, they gain riding time. The riding time of a match is shown as the absolute value of the difference of both wrestlers total time in control with an indicator of who has more. Below is an example of a wrestling scoreboard:

The gym we used to host the competition already scoreboard that could handle the first three criteria, but we needed a way to track riding time. The timer we needed was simple, in fact it was simple enough to create a Claude Artifact last minute to score the event. However, I decided to create a better version of this site which led me down the rabbit hole that is WebRTC.

Building a Better Timer

While the Claude Artifact was good enough for the event, I decided to build a better one. There were 2 pain points I had while using the old version:

1. No way to manually adjust the riding time.
2. No way to simultaneously control the timer and show it to the ref.

Pain point 1 was trivial to implement (reset the timer with an offset for each adjustment). Pain point 2 turned out to be a lot more interesting. During the match, we only had a single computer set aside to control the clock, so only the operator of the clock could see the riding time of the match, making it hard for the ref to verify it was running correctly.

There were two approaches that came to mind to solve the problem:

1. Mirror the computer's screen to a separate display (ex. tv, external monitor)
2. Extend website with a page that displays the riding time from another browser's clock

Approach 1 is inconvenient as it requires platform specific technology (ex. airplay) or extra hardware (ex. tv, hdmi cord, and a power supply). Approach 2 is more flexible as it only requires two devices with modern browsers (ex. smartphones). Approach 2 is also a more interesting problem to work on so I went to work on designing a way to sync 2 instances of my site.

Approaches To Sync

While brainstorming, I came up with three approaches to how to sync the instances:

1. Use a managed synchronization service like Convex or Zero
2. Use Cloudflare Durable Objects to store clock sync and have both sites connect via WebSockets
3. Connect the two websites directly via a peer to peer protocol (WebRTC)

One of my goals was to make this run for as cheap as possible, crossing out approach one. Approach two was/is viable but I needed a Cloudflare paid plan to use durable objects. This led me to start with implementing approach three, which didn't need (as many) costly cloud servers.

The WebRTC protocol

Before we go into my implementation, it's important to understand what WebRTC is and how it works. At its core, WebRTC is a protocol built into most browsers that allows peer to peer connections. I'll be mainly using it to send data across devices but it can also be used to implement phone calls, video streaming and more.

Despite being peer to peer, a server is still needed to setup the connection. Available peers and their connection information are stored on Signaling servers. STUN servers are used to attempt setup the connection. If setting up a direct connection is impossible (likely due to NAT issues), a TURN server is used as a bridge to connect the two peers.

Implementation

My final design for Wrestle-Time consists of 4 elements:

• A "controller" to control the riding time tracker
• A "receiver" to display the current riding time
• A key-value database with WebRTC session metadata
• Cloudflare Calls (WebRTC SFU platform)
  • A Selective Forwarding Unit (SFU) routes WebRTC connections between multiple participants instead of requiring each peer to connect to each other directly (helpful at scale)

Here's how it works:

1. Browser chosen to control riding timer enters site and generates a controller with a unique code and WebRTC Session.
2. Controller writes the WebRTC session metadata to database with generated code as key.
3. Browser chosen to display riding time enters /receive/${code} path on site.
4. Receiver fetches session data from database and creates a connection to Controller via Cloudflare Calls
5. Whenever riding time controller updates, updates are sent to the receiver in real time.

Currently all of this is run on Cloudflare infrastructure under the free plan. This means that I am limited to creating 1,000 sessions per day unless I upgrade to the $5/month¹ paid plan where it is then 1,000,000 sessions.

Additionally using Cloudflare TURN servers and SFU's cost $0.05/gigabyte for outbound traffic. TURN servers are free when using Cloudflare SFU's and the first 1,000 gigabytes/month used towards either are free. Cloudflare STUN servers are free to use and public. This led me to use the SFU service as it cost the same while also scaling better for most cases.

Final Results

With WebRTC, I was able to create a scalable, simple to use riding time tracker for wrestling officials. All an official needs to do is enter the Wrestle-Time.com site and copy the displayed code onto another device. Both devices will then be synced to display the same data with the original device being able to make manual changes.

Caveats

WebRTC has some downsides I wanted to address. The first being that the implementation of the protocol can vary from browser to browser, making it less reliable than other protocols like websockets. There are adapters that help mitigate this problem, but I occasionally have difficulty connecting devices together.

Another downside is lack of mature tooling around the WebRTC protocol. The most popular libraries I saw were either unmaintained (SimpleRTC) paid services (Twilio), or required separate servers(PeerJS). Luckily, learning the WebRTC Browser API didn't turn out to be too bad.

Reflection

Overall, I'm pretty happy with the cost and performance of my little riding time app. I'll likely continue to add functionality until it can replace a wrestling scoreboard. As I continue to work on it, I think it's important to point out that WebRTC may not be the best option if I ever decide to monetize the project. Using a central server or solution like Cloudflare Durable Objects to track state would likely be more reliable at a not much higher cost² (especially at my scale). While I enjoy playing with shiny new tech like peer to peer WebRTC, projects like these remind me that "old-fashioned" approaches are often simpler, better documented, and can offer similar if not better performance when optimized.

Update

I ended up implementing a full wrestling scoreboard located at score.wrestle-time.com. New features include:

• An adjustable timer for tracking wrestling periods
• A buzzer that goes off when a period is over
• Point tracking

Motivations

If you're reading this, there's a high chance that I've recently did a mock interview with you. This guide covers my personal opinions on how to pass a leetcode style interview based on my experience as an interviewee and mock interviewer.

Format of the Interview

A technical interview will typically have the following stages:

1. Introductions
2. Leetcode Problems
3. Opportunity To Ask Questions

Introductions

Both you and the interviewer(s) will go back and forth giving quick intros about yourselves. Its important to practice this as it sets the tone for the interview. I recommend writing down your intro as it will typically not vary much from between interviews.

The rough structure of my intro is below. You should try to match how in-depth you go based on how your interviewer does his intro.

• Name and current position
• Overview of recent experiences
• Overview of relevant project (if you have one)
• Mention of a hobby or two (what you do outside of work/school)
• What you're looking for (Why that company?)

Problems

The interview will then give you 1+ leetcode problem(s) to solve with your language of choice. New questions can expand on previous questions, requiring you to modify your old solution. You will likely solve the question on a platform such as Hackerrank or CodePair. Depending on the company, you may or may not have the ability to run code, use a debugger, or use Google. You'll also get varying amounts of information on the problem so its up to you to clarify.

I recommend structuring your approach to solving the problem using the GLUCK method¹.

• G: Grasp understanding
  • Ask questions about inputs/outputs
  • Run through a simple case with the interviewer
  • Jot down notes as comments
• L: Link to underlying patterns
  • Identify the applicable patterns for the problem
  • Mention your observations to the interviewer
• U: Unveil your plan
  • Verbally go over your solution as a high level
  • Verify that the approach matches input/output criteria
• C: Code and debug
  • Start writing code based on your plan
  • Talk through what you're doing with your interviewer
• K: Know your solution
  • Go over Time Complexity
  • Mention Bottle Necks
  • Go Over Future improvements (if necessary)

Questions

Assuming you solve the above problems in a timely matter, you will have time at the end of the interview to ask questions about the company and your interviewer(s).

I recommend treating this section as an opportunity to gauge if the company is a good fit for you. This is typically the least practiced of all the sections despite its importance as it will be used to help your interviewer(s) gauge your interest in the company, personality, and curiosity. I like to prepare a few questions about the company before the interview, as well as come up with a few questions specific for your interviewer based on their intro.

Here are some topics you can ask about. I try to make this more of a conversation by asking follow-ups.

• Interviewers background (if they didn't mention in intro)
  • Follow up with technical questions if you have relevant experience
  • What made them join the company?
• Day to day in the company
  • I try to figure out if interviewer enjoys their day to day
• Company growth/future
  • You probably don't want to join a struggling company
• Career growth/scope of role
  • How long do promotions take
  • What kind of work will you do as an engineer

Solving A Leetcode Problem

Solving a leetcode problem requires 4 things

• You need to know a programming language
• You need to know how to use key data structures for that language
• You need to have a toolbox of general purpose algorithms (ex. 14 common patterns)
• You need to know how efficient your algorithms are

Choosing a language

If you have an interview with short notice, I recommend using whatever language you're currently most comfortable with. Otherwise Python will make your life easier.

I recommend Python for the following reasons

• Your interviewer likely knows it
  • If they don't its still easy to read
• Most data structures don't require imports
  • Exceptions include heaps and the collections library (alternatives to the built-in data structures)
• Lots of tricks to keep your solutions simple and succinct (examples)
  • My favorite trick is using dict_obj.get(key, default_value) to query a Python dictionary (Python's version of a hashmap)

Mastering Data Structures

A lot of leetcode problems involve changing the state of your input into a data structure. At a minimum, you should known the following (or their equivalents for a specific language). Mastering them is ideal but knowing the purpose and time complexity for each is usually enough.

• Array
• Queue
• Stack
• HashMap
• Heap/PriorityQueue
• Linked List/Tree/Graphs (They're all technically graphs)

Some others that are good to know about are:

• Self Balancing Trees
• Trie
• Skip list
• Bloom Filters
• Segment Tree and related

I also recommend learning approaches to Concurrency for your language of choice.

Building your Algorithm Toolbox

Leetcode questions tend to fall into one of the following categories:

• Simple usage of a data structure
• Using a common pattern with minimal modification
• Using a pattern with modifications to fit the problem
• Using multiple patterns with modifications

To be able to solve problems efficiently, you should learn the following for at least the 14 patterns

• How the pattern works
• When to use the pattern (ex. sorted array -> binary search)
• Bottle necks for the pattern

Use these resources to learn:

• Intro to Algorithms (CLRS)
• Elements of Programming Interviews
• Grokking the Coding Interview

And these to practice

• Leetcode
• Neetcode
• Sean Prashad Patterns

Evaluating Your Algorithms

After you solve a leetcode problem, you will likely to be asked to evaluate your solution in terms of time and memory complexity.

The trick for this section learn the time complexities of the previously mentioned patterns and other common operations (ex. popping from a queue) and combining them together. Also be sure to clearly define what the $n$² in $\mathcal{O}(n)$ is referring to when describing complexity.

Here are some tricks to know

• Sorting will take $\mathcal{O}(n*\log(n))$ time
  • An exception to this is Counting Sort being "linear" time
• $n$ recursive calls will require $\mathcal{O}(n)$ memory at minimum due to the Call Stack
• Adding/Removing an item from a heap takes $\mathcal{O}(\log(n))$ where $n$ is the size of the heap

Debugging In Interviews

Often times the hardest part of solving a leetcode problem is fixing your mistakes in your solution on the spot. While the best way to avoid bugs is to take your time while coding, the time crunch of the interview can make you rush and overlook details. This section goes over some strategies to track down errors for different interview types.

Whiteboard/Text Editor

These types of interviews tend to focus more on your thought process over writing 100% correct code. However you may still have errors in your thought process and will need to identify where in your algorithm you went wrong.

The way I think about debugging is that you're trying to find the line of code doesn't do what you think it does. Sometimes you can track this down with just intuition, but it's important to have a structured approach in case you don't.

What I like to do is to create a simple input and trace its state in the code using comments. I usually use an input I went over with the interviewer at the start of the problem unless you have a specific input that you know fails. Below is an example with the Two-Sum Problem:

input = [1,2,3,4]
expected_output = [1,3]

def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        seen[num] = i
        if complement in seen:
            return [seen[complement], i]
    return []

# Example trace
# nums=[1,2,3,4], target=6
# i=0: num=1, complement=5, seen={1:0}
# i=1: num=2, complement=4, seen={1:0, 2:1} 
# i=2: num=3, complement=3, seen={1:0, 2:1, 3:2}
# complement is in seen, output is [2,2]
# Bug: value is added to seed before complement is checked in seen,
#   allowing for an index to be returned twice

The level of details in the comments will vary based on the problem. For Two-Sum, I only tracked the state of the program at the if statement as the solution was relatively simple. For more complicated problems, you may want to track the state per line by putting comments next to each line of code instead.

Online IDE/Compiler

If your interviewer allows you to execute code during the interview, they likely value having a working solution more than the previous situation. Luckily, being able to run code gives you a few tricks that can help narrow down your bugs.

Tracing with print statements

This is essentially the same as the whiteboard strategy with print statements instead of comments. I recommend labeling the variables you're tracking in the below style.

print(f"Var1:{var1}, Var2:{var1})

Testing out small parts of the code

For more complicated problems, it may be tricky to find problems by tracing. One approach that may help is factoring out the different parts of your program into smaller functions and verifying that each of them work as intended. This is known as Unit Testing³.

IDE with Debugger

If the interviewer gives you a debugger, its useful to know how to use one. All you need to do is set a breakpoint where you think the code is wrong, and step through the code.

Keep in mind the above approaches are still applicable and could be better choices depending on the situation.

Miscellaneous

Even if you master every aspect of acing a leetcode style technical interview, it may not be enough get you the job. The two things I recommend that can help you stand out as a candidate is honing your communication skills and learning about system design.

Communication

Being able to communicate clearly and confidently can make you a much stronger candidate. The best way to practice this is to do mock interviews with a wide variety of people. Also practice tailoring your communication style towards your specific interviewer. There is no one size fits all for communication.

System Design

Companies are hiring you for your ability to generate value for them, not based on your ability to solve leetcode problems. Understanding how the underlying tech works for large scale systems along with the tradeoffs of different technologies can come in handy when talking to your interviewer, even if the interview is not strictly a system design interview.

• Tech Interview Handbook
  • In depth resource to technical and behavioral interviews
• Designing Data Intensive Systems
  • Recommended for learning about system design
• System Design Primer and Hello Interview
  • Useful for practicing system design interview questions

Other Tips

• Ensure you clarify any assumptions you're making
  • "Can we assume the input fits in main memory?"
• Knowing the target time complexity for the solution can be a hint
  • For example, if you know that the time complexity should be $\mathcal{O}(\log(n))$ the answer is likely a form of binary search
• Listen for hints/suggestions from the interviewer
  • They'll often nudge you towards the right data structure or away from bad solutions
• Name variables based on what they're used for
  • Avoid overusing one letter names like "x" or "y"
• Be confident when asking/answering questions
  • Interviewers may try to get you to second guess your answer even if it's optimal (the answer may just be incorrect so be careful)

Concluding Thoughts

While technical interviews can be intimidating, it's important to remember that you wouldn't have gotten an interview if the company didn't believe you can handle it. Interviews in general are expensive due to it requiring both recruiter and engineer time (the latter being especially pricy). Stay confident and you'll crush your interviews!

Why I'm Making This

Around this time last year, I launched the first public version of TheGradeGuide.com. Now that I'm about done with this project, I wanted to share the journey of why and how I made this site! My goal with this writeup is to reflect on my wins and mistakes while making this and to inspire other students to create their own Grade Guides for their colleges.

Part 1: Building the Dataset

Realizing Grade Guide was Possible

I was sitting in my data structures and algorithms class when my friend showed me GradeTier: a site that showed anonymized past grade distributions for OSU class. I found this more interesting than learning about the Ford-Fulkerson algorithm and started down a rabbit hole. I began investigating how they got the data and found two reddit posts: one about GradeTier and one about OSUProfs (student survey result site). I then started wondering if there was a way to combine these sites to figure out which professors give the best grades

Acquiring The Data

I started my investigation by sending a Reddit DM to the account the created the GradeTier post asking about how they sourced the data. They directed me to The Ohio Public Records Act, which prompted me to email Ohio State's Public Records Division asking for grade distribution data by professor. Unfortunately I was denied under the Federal Family Educational Rights and Privacy Act (FERPA). However, I found that requesting for anonymized grade distribution data and student survey results for professors separately was compliant.

Making the Data Useful

The first set of data I received was a excel sheet of anonymized grade distributions by class. The shape of the (messy) data was roughly as follows:

Cleaned_Excel_Row = {
  Term_Code,
  Campus,
  Subject,
  Catalog,
  Class_Number,
  Title,
  Total_Students,
  A_Count,
  A_Minus_Count,
  ...
  E_Count,
}

While I was waiting for the student survey data I spent my time cleaning up the Excel sheet into a clean csv with Pandas. I also noticed that the "Class_Number" seemed to be a unique identifier (at least for the semester) for a class and was shown to students in Canvas.

Eventually I received an (also messy) Excel sheet for the student survey data¹ with the below shape:

Cleaned_Excel_Row = {
  Last_Name,
  First_Name,
  Subject,
  Catalog,
  Class_Number,
  Term,
  SEI_Responses,
  SEI_Rating,
}

Right away I noticed that each dataset has 4 matching keys: Subject (ex. MATH), Catalog (ex. 3341), Class Number (ex. 13169) and Term/Term Code (ex. "Fall 2020"/1242). I then opened up Pandas and looked to see whether this data could join together and if it was accurate. I discovered 3 things:

1. Many classes have grade distributions but no student survey results
2. Some classes have survey results but no grade distributions
3. Classes with multiple parts (ex. lecture, lab, recitation) didn't always have their (Canvas) Class_Code in the grade distribution excel

After some manual verification and email exchanges with the public records office I made the following discoveries:

• Survey results for PhD or Masters students were intentionally excluded by OSU due to FERPA
• Grade Distributions for classes with under 10 students were also intentionally excluded by due to FERPA
• For classes with multiple parts (ex. lecture, lab, recitation), each part will have its own class code with only one used in the grade distribution excel

I then had to make some tradeoffs with how I joined the data: use grade distributions as a source of truth (left join), use student surveys as a source of truth (right join), keep all the data with missing gaps on either side (outer join). I decided that the grade distributions were the most important data to me and that I didn't care about survey results on their own, so I chose to do a left join. This led to a dataset that had grade distributions for every class taught for the past 5 years with student survey results (and professor info) if it existed.

Part 2: From Notebook to Website

Early version of Grade Guide

Grade Guide v0: The Prequel

By the time Autumn scheduling came around, I was determined to leverage (at the time) personal dataset to help me schedule classes. As Javascript scared me at the time, I whipped up a quick jupyter notebook and made some Plotly charts. The notebook had 3 main uses:

1. See past instances of a class being taught and a bar graph showing how many As, Bs, Cs, etc for each
2. See a bar graph of the average GPAs for a class by which professors taught it (shown in pic above)
3. See a bar graph on how what grades a professor gives based on which classes they teach

At this point I was likely the only student who knew that it was possible to compare classes and professors based on historical grade data at Ohio State, so I felt like a wizard whenever I showed it to my friends. Eventually, I started getting enough requests where I began considering making Grade Guide a site and monetizing.

Grade Guide v0.5: An Over-engineered Mess

When I officially decided I wanted to make Grade Guide a website, I had two major roadblocks: I knew nothing about how to make a website and I also disliked UI/UX design. This made my attempts at making a webapp that met my standards tricky.

I ended up putting Grade Guide on hold until I got back from my internship at Amazon where I did full stack web dev (and conquered my fear of Javascript in the process). Once I got back I had both the knowledge of how to make the Grade Guide and the motivation to grind out building it solo (I was pretty bored at the time).

My approach to making Grade Guide was to start by modeling what kind of data views I wanted to see, and then making a fronted to show the data in nice to use way. This let me focus on function instead of spending my time making mockups. I was optimizing for developer speed and ended up choosing Convex as a BaaS platform since I had a poor experience in the past with Firebase and also got good vibes from one of the company representatives from a past Hackathon I attended. I also decided to use the Next.js with the NextUI component library for the frontend.

Working with Convex was easy, in fact I would argue it was a bit too easy. After adding the core functionality to the site, I added a login, then reviews, and then upvotes/downvotes on the reviews. I would likely have kept adding new features (namely the ability to upload study materials to a class) to the site until I started sending early versions of my site to friends. Once I heard their feedback and saw them using it, I realized a lot of these extra features were distracting from Grade Guides core purpose: informing students with data, not opinions. I then began to work on stripping away everything but the core functionality.

Grade Guide v0.75: Turns Out UI Mattered

For the next version of Grade Guide, I spent the majority of my time on website polish and providing new insights on the data I had. I also added Google Analytics as I needed a way to track usage as I removed user accounts. My mistake at this stage was trying to salvage my UI components from the last version instead of creating from scratch with a clear goal in mind from the start. This led to me spending too much time trying to tweak my NextUI components instead of focusing on the actual user experience.

On the backend side of things it was around this stage where I started to optimize my data schema for the site. The first update was making my data more graph-like. By allowing a class to link to the professors that teach it (and vice-versa), exploring the site suddenly became much more natural for a user. I also spent time doing various optimizations to keep my data under Convex's free limits (removing redundant fields and indexes mainly)

At the end of this stage I started to get improved feedback from my friends, though realized I neglected something crucial: the mobile experience. I mainly tested my site on my laptop, which led to the site looking sloppy on mobile devices. At this stage I became frustrated with NextUI and decided to cut my losses and rebuild my UI from the ground up.

Grade Guide v1.0: The Final Remake

This version of the site had one goal: mobile friendliness from the ground up. I ended up choosing a new library called Shadcn, which promised a sleek but easy to customize components. I was also able to beta test v0, an AI platform to make UI components with Shadcn underneath. As this was my third attempt making the site, I was able to learn from my mistakes of adding too much functionality and not having a clear vision of what I building.

Two other key features I worked on was a universal professor/course search bar at the top of my screen and keeping the storage under the free limit after adding 2 new semesters. The search feature was easy as Convex had recently added a text search index feature, so adding a universal search only required creating a custom text field to search for my course and professor tables, searching both whenever the search box is updated, and showing the more relevant search result on top.

Optimizing my memory usage proved to be an interesting tradeoff. I had 3 main tables in my database: courses, professors, and instances. The first 2 tables are self explanatory while the instances table represent a specific section of a class being taught (ex. CSE 2221 by Professor Bucci from 12pm-1pm). This table had 2 compound indexes: subject-catalog for class lookups (CSE 2221) or first-last name of professor (Paolo Bucci) which were used for quickly getting relevant data for each course and professor page (among other things). However, this index used the majority of the free tier of my memory limits so it had to go. I ended up opting to storing the primary key of each instance directly in their corresponding class or professor row. While this saved me storage space, it came at the cost of doing N database lookups for each class page where N is the number of instances for the class. I also used the index for subject level "explore" pages which led me to create a new table "departments" that had a list of all class and professor primary keys for each subject (ex. CSE, Math, Psych).

I also discovered that there was a public OSU site that could be used to get some interesting data for classes like descriptions and number of units. I wanted to add this data to my site but also wanted to launch soon. To achieve this I used an API used internally on the OSU site and updated my database each first time a user view a class page.

Part 3: Mission Accomplished?

Current Grade Guide Home Page

My First Launch

Once I was happy with how the site looked, I launched with a reddit post and discord message in OSU's CSE discord. To track feedback, I created a site email and google form and added it to my site's footer.

Most of my time at this page was listening to feedback and making slight visual tweaks. My original plan to monetize was to get around 5k monthly users. The idea was to reach out to local business on OSU's campus and charged them a bunch of money for non-intrusive ad space on my site. However once I reached 1k monthly users² I decided that I would rather spend on my time on making cool stuff over marketing or managing other people to market for me.

Expansion (and why I didn't)

Once I saw the positive reception I started to think about expanding to other schools. UT Austin was the first to come to mind as they were public, were subject to similar Freedom of Information as OSU was, and had a huge student population. I started with an email to their records department but unlike OSU, they would have charged me around $100 for the data! Luckily, they had recent anonymized grade distribution data and student evaluation reports publicly available, though in unideal formats. With some python scripting I was able to download all of this data automatically and then parse it into a nice csv using some xpath and regex expressions. Then with some Pandas, I was able to get the data almost identical to my OSU dataset for free (though only for the past 2 years).

Armed with this data, I began working on expanding my database to work with multiple schools. I ended up deciding on adding new indexed attributes on my department, course, and professor tables to identify which school they belonged to. Then, I would use decide which index depending on whether the site had the url param /OSU or /AUSTIN as a prefix.

While planning my launch, I came across a linkedin post advertising UT Grades Plus. While I believed my site was better, I didn't want to spend my free time marketing my site at a school I didn't go to (if I wanted to market something I would rather start at OSU). I decided to just keep making my site focussed on OSU which also let me work on some other side projects.

Side Quests

This section will discuss the new features I've gradually over the past year along with some other stories. The boring features I've added were new charts and metrics to show grade data such medians gpa, and how it changes over time (line graph). I chose to precalculate averages and medians for classes/professors tables and update whenever I add new instances. This led to the ability to sort classes and professors by GPA, making it easy to sort them "easiest and hardest". I also spent a lot of time tweaking my Plotly graphs to make them suitable for phones (removed the capture button and dragging).

Adding in RateMyProfessor

My biggest upgrade was integrating RateMyProfessor into Grade Guide. This turned out to be trivial as there was a unauthenticated graphql endpoint I was able to reverse engineer to get data from the site programmatically. To try and not upset the company, data from RateMyProfessor is never stored in my database, their endpoint is only called when a user presses a button, and I link to their webpage from my site. I currently show a professors scores, most common review tags, and a wordcloud of their 50 most recent reviews. The wordcloud uses webworkers to ensure quick loading. Strangely a few people complained about this feature seemingly because it made their favorite professors look bad.

Making The Worst Data Pipeline

Once the site was public, I had to make a data pipeline to update my database incrementally. My first attempt at this added data one instance at time, resulting in an extremely slow and bandwidth expensive operation. Additionally I did the operation multiple times on my dev database with attempts at speeding up the process via concurrent API requests to Convex. This led to race conditions that led certain uploads to fail which led me to go back to the slow, single threaded way. This process all in all cost 40-50 gigabytes of bandwidth for 2 semesters while my current pipeline is about 100-300 megabytes for ~15 semesters (each request now uploads a class instead of an instance).

Fixing an Inefficient Search

When I was still on the Convex free tier, I had issues keeping my database bandwidth under the limits once I got past ~600 monthly users. Upon a bit of investigation, I realized that my search functions were using the majority of my bandwidth so reached out on the Convex Discord to try and find ways to optimize. After some discussion with their team, I realized the issues was actually quite trivial: I was calling the search functions on every key press in the search, which messed up the built in caching features of Convex. After adding a delay to the search calls in the form of a Debounce Filter, my usage drastically went down.

Getting a Sponsor

I eventually stopped actively working on Grade Guide and wanted to avoid paying for a site I was making $0 off of. At that point my only recurring cost was my BaaS provider (Convex) and my usage was only slightly above the free tier limits. After a few email exchanges, Convex (shoutout to Jamie Turner) generously offered to give me a better free plan in exchange for putting their logo in my sites footer. Though there are cheaper options to Convex (like Cloudflare Pages): the developer experience, built in functionality, and customer support have been unmatched (at least in my short career).

Takeaways

Looking back, this had been one of my favorite project for 3 reasons: I still use it, my friends use it, and random people (including professors) also use it. Having people get value out of your work is very motivating and makes the programming more fun. Here are some key takeaways from working on Grade Guide:

• Start with the core features of your app before adding extras
  • Even if they seem easy quality control becomes harder
• Move fast but make sure the developer experience stays good
  • BaaS providers like Convex help a lot with this
• It never hurts to ask for things (both data, help, or more)
• If you go to a public university, you can likely follow my steps in this article to make a Grade Guide for your university