pil0u / lewagon-aoc Goto Github PK

This information might be useful in the future.

After the migration, here is my suggested implementation:

# app/models/user.rb

def self.from_kitt(auth)
  batch_from_oauth = auth.info.last_batch_slug&.gsub(/[^\d]/, "")
  batch = Batch.find_or_create_by(number: batch_from_oauth) if batch_from_oauth.present?

  user = where(provider: auth.provider, uid: auth.uid).first_or_create do |u|
    u.username = auth.info.github_nickname
    u.github_username = auth.info.github_nickname
    u.batch = batch
  end

  user.update(github_username: auth.info.github_nickname)
  user
end

.update triggers an SQL query only if the value is different, thus making the transition smoothly and the information up-to-date with time.
The username can be edited by the user in the app any time, the github_username is retrieved from Kitt.

• Add a clear statement of who validates what

Also, add the channel linked somewhere fixed.

• Ajouter un lien Twitch dans le profil utilisateur
• Ajouter une page dédiée pour mettre en avant les streamers en live

Communication

• Touch base with Ursula, the new E&C Paris
• Touch base with French E&Cs
• Every city in the world is aware of the event (Google Slides)
• We have a video trailer

Prizes

• Send a message to Guillaume directly
• More small prizes for more people (100 t-shirts, 20 virtual escape rooms for squads, 1000€ for a party) => 5700€

Adventofcode.com

• Get an answer from Eric about larger private leaderboards (it's a no)

On step 2 of the sync process, the click here link is an external form submission that is supposed to make the user join the leaderboard on adventofcode.com.

It was supposed to improve UX, but for some (probably good) reasons, some browsers seem to block that behaviour.

• Find the root cause
• Fix

To reproduce:

1. Sign out from Kitt
2. Sign out from https://aoc.lewagon.community/
3. Click "Sign In with Kitt" and follow the Kitt sign in flow
4. You are redirected to Kitt and not the platform

Current candidate is https://fly.io/

This issue should be tackled when the front for the rankings are ready.

Simplest approach is by leveraging timestamps from the top 100 of the past years and determine absolute threshold as an output:

• 🟢 very easy (< 2 minutes)
• 🟡 easy (between 2 and 10 minutes)
• 🟠 hard (between 10 and 20 minutes)
• 🔴 very hard (> 20 minutes)

Enable people to post 1 message a day on a public wall

When the scores are retrieved from the API, the JSON is parsed and stored in scores table.

To retrieve information from that table, the ideal scenario is to avoid N+1 queries (:smile:) by properly querying the table in the pages_controller to get nice Hash(es) that can be easily browsed for the stats we want to offer.

• Scoreboard page
• Dashboard stats
• Dashboard calendar

To do:

1. List all the metrics we want to have
2. Write down the right Hash structure(s) considering all the stats we want
3. Build the appropriate queries

Database schema to date:

• Update Q&A
• In pages_controller.rb > scoreboard, change all 3 .order() with count(distinct users.id)

Why

Purpose n°1: allow validators to check the code written by participants and validate rankings
Purpose n°2: make it sharable amongst participants

What

People could share 2 codes for the same challenge:

• one that corresponds to the immediate resolution and is used for cheating-proof. This one is immutable, not publicly shared
• one that the user wants to share. This one is publicly available / displayed, editable at any time.

The Validation snippet

"You won't be able to edit or access this code afterwards"
Add a checkbox "Use this code as my Shared snippet as well"

Add an optional "time to solve" declarative field for people to share it. IMHO, as it would always be declarative, we don't need to add a custom timer on our platform and rather let people who want to compute it themselves and let them the opportunity to share it. We could then compute a "Declarative leaderboard".

The Shared snippet

Keep an history of editions?
This snippet is displayed publicly on the platform.

People are allowed to add emoji reactions to the shared snippets:

• 🎓, for a solution that is exemplary to learn things
• 🤯, for a solution that blows your mind
• 👏, for a generic celebration of a solution
• ♥️, for "Organizers' favorite"

Maybe add a constraint, like only one reaction available per snippet.

For a given challenge, snippets are ordered in 3 virtual blocks:

1. First appearing block, snippets that were posted in the past 15 minutes
2. Second appearing block, snippets that were posted between 15 and 60 minutes ago
3. Third appearing block, all the remaining snippets

Within each block, snippets are ordered by:

1. number of 🎓 desc
2. number of total reactions desc
3. submit time asc

Technicalities

• We just store the code (= text) as is
• Don't share Jupyter notebooks (painful to read)

• Design the table
• Implement the model and database migration
• Add validation on name (unique)
• Auto archive empty squads
• Add the Create/Join/Leave process in the settings
• Block join if squad is full
• Lock squads after December 8 (no join, no leave, no create)

New schema
More info

Especially, get rid of Node dependency with importmap

Need to check in the backend the batch input as there is a max value of a 4-bytes integer column in a database.

Not the most important issues but as I found it though I could fix it.

Advent of Code rooms are limited to 200 slots. Some effort was made to anticipate the case where more than 200 people want to join the contest:

• the use of an environment variable AOC_ROOMS to avoid re-deployment when a new room is required
• this one variable can handle ∞ rooms

Some work is still required for this feature to be functional:

• When a new room is added to that variable, the join link on the Dashboard should automatically switch to the new room
  ➡️ Use .last instead of .first for the join link (dashboard.html.erb)
• Update the refresh sub-task in scores.rake to merge JSONs coming from all the rooms

require "open-uri"

kitt_cookie = "your-kitt-session-cookie"

raw = URI.open("https://kitt.lewagon.com/api/v1/users", "Cookie" => "_kitt2017_=#{kitt_cookie}").read
cities = JSON.parse(raw)["all_places"].map { |h| [h["label"], h["count"]] }.to_h

cities

This is interesting to get a % of participation depending on the "size" of a city.
It's also helpful to adjust the seed:

# db/seeds.rb

# Initialize cities
cities = [
  "Amsterdam",
  "Bali",
  "Barcelona",
  "Beirut",
  "Belo Horizonte",
  "Berlin",
  "Bordeaux",
  "Brasilia",
  "Brussels",
  "Buenos Aires",
  "Cape Town", # not in the API
  "Casablanca",
  "Chengdu",
  "Cologne",
  "Copenhagen",
  "Dubai",
  "Istanbul",
  "Kyoto",
  "Lausanne",
  "Lille",
  "Lima",
  "Lisbon",
  "London",
  "Lyon",
  "Madrid",
  "Malmö",
  "Marseille",
  "Martinique",
  "Mauritius",
  "Medellín",
  "Melbourne",
  "Mexico",
  "Milan",
  "Montréal",
  "Munich",
  "Nantes",
  "Nice",
  "Oslo",
  "Paris",
  "Playa del Carmen", # not in the API
  "Porto",
  "Remote",
  "Rennes",
  "Rio de Janeiro",
  "Santiago",
  "Seine et Marne",
  "Seoul",
  "Shanghai",
  "Shenzhen",
  "Singapore",
  "Stockholm",
  "São Paulo",
  "Tel Aviv",
  "Tokyo",
  "Zurich"
].map do |city|
  { name: city }
end

We want to encourage people to collaborate, think about problems alone or around a table, but avoid them to copy-paste solutions found elsewhere.

Solution 1 - Reduce cash prize
Solo cheating is driven by high cash prizes. Drastically reducing the incentives would drive cheating down.
My opinion: no more solo cash prize + "group" (tbd) cashprize + symbolic city prize

Solution 2 - Open source participants' solutions
This expensive solution would contribute to two things:

• cross-validate solutions for top performers and validate rankings
• share and log code for all the participants

• Add an official end date to freeze the scores
• Explain the details

How it works currently is explained here: https://aoc.lewagon.community/about

What works great:

• Any participant earns points (individually) whenever they solve a puzzle

We identified different issues:

• By nature, groups (batches and cities) have different sizes
• Batches are mostly very small
• All scores are based on the time-to-solve, thus time-zone specific
• In spite of the effort to keep it simple, it requires a 1-page explanation in the Q&A section

Solution 1 - Change batches to groups of fixed size

This requires great changes and raises a number of questions.

• What size for each group?
• Can people come and go from a group to another? Should we lock them at a certain point? When?
• How would it work? A group leader/creator that invites people? Pre-generated groups that people fill?

Solution 2 - Distinguish hardcore competitors vs casual participants

Hardcore competitor: don't care about getting up early during 25 days, they solve puzzles as soon as they're out
Casual participant: want to try to solve the puzzles through their spare time with no intention to hustle

To enter the hardcore competition and appear on this specific leaderboard, individuals would have to check a box on their profile setting for example (disabled by default).

For casual participants, instead of a relative solve time ranking, we grant fixed points based on time frames:

• If you solve a puzzle (= a part) within 24h, you get 50 points
• If you solve a puzzle within 48h, you get 30 points
• If you solve a puzzle anytime before the end of the contest, you get 20 points

The tie breaker would be the median exact solve time for solved puzzles.

By pressing Ctrl + K, you can search and access any resource from the platform:

• users
• squads
• cities
• days
• FAQ questions

Currently, all participants have 0 point, thus all with the same rank.

Rank computation is not exactly the same between the dashboard and scoreboard controller methods.
In case of equality, this creates inconsistencies.

Solution? Order by score, then by id.

Edit: Even better, order by

• username for solo ranking
• batch number for batch ranking
• city name for city ranking

A green/red arrow with the change in the ranking in the last 24h.
How? Compare 2 data points at 5.55am Paris Time for example and display the "+2" or "-1" or "=" signs next to each line.

Bonus: we can make a graph out of it.

We tried some incentives to make people contribute to the project, did not really catch.

• Change the CONTRIBUTORS constant in app/models/user.rb to ORGANIZERS and remove ids
• Change the parrot gif to the aoc gif

Statistics

All statistics are displayed, thus visible on the Whimsical link (private).

Additional statistics, low prio

• Declarative time to solve
• Number of top 25% / 10% / 5% / 1%
• A map of the cities with their scores
• Graph of city scores over time

The page is kind of broken on mobile. The project is using Tailwind CSS.

I won't fix this, unless 25%+ of the participants upvote this issue.
However, anyone can take the issue to solve it 👍

Jusqu'ici, exporter un dump d'un bout des données est tout à fait faisable. Je remets cette fonctionnalité en P4, parce que c'est la classe

and update alert message.

Just for the sake of it.

docs

Setup Sentry for basic error logging.

Routes

Current state:

                      Prefix Verb     URI Pattern                         Controller#Action
user_kitt_omniauth_authorize GET|POST /users/auth/kitt(.:format)          users/omniauth_callbacks#passthru
 user_kitt_omniauth_callback GET|POST /users/auth/kitt/callback(.:format) users/omniauth_callbacks#kitt
        destroy_user_session DELETE   /sign_out(.:format)                 devise/sessions#destroy
                 unauth_root GET      /                                   pages#home
                        root GET      /                                   pages#dashboard
                       about GET      /about(.:format)                    pages#about
                  scoreboard GET      /scoreboard(.:format)               pages#scoreboard
                    settings GET      /settings(.:format)                 users#edit
                             PATCH    /settings(.:format)                 users#update
                       stats GET      /stats(.:format)                    pages#stats
                  stats_user GET      /stats/users/:id(.:format)          stats/users#show
                 stats_batch GET      /stats/batches/:number(.:format)    stats/batches#show
                  stats_city GET      /stats/cities/:slug(.:format)       stats/cities#show
                      status GET      /status(.:format)                   pages#status

New routes are defined on the Whimsical.

Models

Current architecture can be found on Kitt.

Also switch from synced? to confirmed?