Chronicle: Historical Database of ETH Events

tree · April 29, 2023, 3:49pm

Hello Gardeners!

The number of ETH* events has grown incredibly recently, so it would be a good idea to start categorizing and archiving information about these events for future generations. Every event can be considered a unique piece of art in some way, not only because of the graphic design or content, but also the atmosphere.

At the same time, we would like to make it as open as possible, where anyone can edit or add to the data and distribute the data as decentralized as possible.

I have already started implementing this project - the working title is chronicle. See below for more information.

Collected data

basic event data (name, date and time, venue, links…)
attendance data (expected and real)
contributors (speakers, mentors, judges, team…)
partners and sponsors: how the event was funded
event web - archiving like web.archive.org
graphic content - logos, posters and other materials
data about each talk, workshop, etc.
hackathon: details about the hackathon (number of hackers, projects, prizes, bounties, platform…)
post-event materials: photos, videos (aftermovie…)

MVP Implementation

Frontend

MVP frontend is created using Astro, Svelte & Tailwind (source code).

The application can be found at:

ethevents.xyz

Example: EthereumZurich 2023, ETHBerlin³, ETHBrno²

Screenshot

Backend

I decided to start simple, so I created a GitHub repository where the information is stored in YAML files, and builded into single JSON, which can be easily stored on IPFS or other distributed storage, link below:

Data

The source data is stored in YAML format in the ./data directory.

Schema is defined in JSON Schema format, definitions can be found in the ./schema directory, e.g. ./schema/event.yaml.

Output can be consumed as single JSON at this URL:

https://chronicle.ethevents.club/data/index.json

Collections

Collection	Schema	Description
event	event.yaml	Particular event
family	family.yaml	Family of events (for example ETHGlobal)
series	series.yaml	Series of events in chronological order (for example ETHPrague, ETHBerlin…)

Build

The build into a single JSON bundle is done using scripts written in Javascript, executed via Deno runtime & makefile.

Event example - index.yaml

Here is an example of the definition of a specific event (source):

name: EthereumZurich
series: ethereumzurich
types: [ conference, hackathon ]
date: "2023-04-14"
days: 3
place: Zurich
region: europe
country: ch
host_name: DuckTape/PWN
attendees: 800
attendees_real: 489
links:
  web: https://ethereumzuri.ch/
hackathon:
  hackers: 100
  hackers_real: 71
  hacker_application_platform: typeform
  projects: 16
  project_submission_platform: devfolio
  project_submission_url: https://ethereumzurich.devfolio.co/
  prizes_total: 5000 USD
  prizes:
    - name: Open track - quadratic voting [1st place]
      amount: 1500 USD
    - name: Open track - quadratic voting [2st place]
      amount: 1000 USD
    - name: Open track - quadratic voting [3st place]
      amount: 500 USD
    - name: Judges' favourites [1st place]
      amount: 2000 USD
  bounties_total: 3750 USD
  bounties:
    - name: Gelato Web3 Functions
      amount: 750 USD
    - name: DataverseOS Web3 Functions
      amount: 1000 USD
    - name: API3 DAO - Use of first-party oracles
      amount: 1000 USD
    - name: PWN bounty
      amount: 1000 USD
aftermovie: https://www.youtube.com/watch?v=xWJoMOSDgu0

tree · April 29, 2023, 6:33pm

Here is a list of issues or tasks we need to address.

I will be very happy for discussion and every comment, every single topic mention below is important.

1. Specify what we want in the database (schema)

I have designed a basic schema for models and properties, you can find it in the repository in the schema directory, but there are still a lot of things missing. We need to finish the schema for everything we want to collect as soon as possible, because the subsequent additions to the database will depend on it.

Task for you: think which fields we need, or what data to collect and post it here in the thread, or implement it directly in the schema.

2. Build the basic frontend

As I wrote, I’m working on a prototype (ethevents.xyz), but I’m not really a web designer, so it’s slow going and I could use your help. There’s not much work done yet, so it’s easy to start from scratch and build it on other technologies, if needed.

Besides the real implementation of the frontend, it is also necessary to have a plan of what we want to have there, which you can also help me with. If you are designers or UX wizards, we would be glad to help

3. Complete the event database

This will be the hardest task that never ends We need to add information about events from the past while keeping track of new events and maintaining this whole list. Partly it can work automatically through PR (pull requests), or helper scripts that download for example speakers and other information, but most of the data and basic configuration will have to be supplied manually.

We currently have the base for 100 events in our database and extensive details for only few of them. We will need at least 5 people who will be willing to keep this data repository maintained and running.

4. “2023 ETH Events Coordination” and other groups - replacing the custom list’s

If we already have an extensive & maintained database of all ETH* events, this can replace the various lists in coordination groups such as the “2023 ETH Events Coordination” group.

5. Decide how to store big files like photos or videos (or just how to store everything)

I am in favour of progressive decentralisation. For start, having the core JSON data in a repository on GitHub that we’ll mirror. The question is where to store large files like photos or videos. We’ll probably also use our own hosting for that at first, but would like to get that sorted out as soon as possible.

As an endgoal, it could be to store everything in decentralized manner - basic data (JSON) on a decentralized Arweave (as its permanent) and large files on a distributed IPFS… or Filecoin, Swarm or something similar (as its distributed and immutable). Also frontend can be easily hosted on IPFS as ethevents.eth.limo or similar.