DEV Community: Friday candour

The Honest Roadmap to Learning Machine Learning

Friday candour — Sat, 02 Aug 2025 14:39:54 +0000

Tech moves fast. Memorizing every algorithm is a losing game.

Instead, get good at:

Problem decomposition – turn “predict customer churn” into tidy sub-problems.
Resource hunting – know where to look when the docs fail.
80/20 filtering – ignore the blog-post-of-the-week until you actually need it.

If you can do those three things, the rest is just execution.

Step 1: Python & the Notebook Habit (Week 1–2)

Start here because you’ll see results today.

Install Python and JupyterLab.

Then cover the absolute basics:

Topic	Why it matters	One-liner test
Variables & types	You’ll use these every day.	`age = 32; type(age)`
Lists/dicts	Every dataset becomes one of these.	`df['income'].mean()`
Functions	Keeps code reusable.	`def clean(df): return df.dropna()`
`pandas`	Excel on steroids.	`df.groupby('state').sales.sum()`

Do: One beginner course—pick any you like.

Don’t: finish three courses “just to be safe.” One is enough; the rest you’ll pick up by building.

Step 2: Your First Real Data Project (Week 3–4)

Pick a CSV you care about—your Spotify history, city bike-share logs, anything.

Goal: load → clean → plot → tell a story.

Checklist:

Import with pandas.read_csv()
Clean nulls, units, outliers.
Explore correlations (df.corr()).
Visualize with matplotlib/seaborn.
Present as a 5-slide Jupyter slideshow (jupyter nbconvert slides.ipynb --to slides --post serve).

Push the repo to GitHub. Congratulations—you now have a portfolio piece.

Step 3: The Math You Actually Need (Week 5–8)

Skip the proofs; learn the intuition.

Area	Core Concepts	Time Budget	Free Resource
Stats & Probability	mean, variance, distributions, Bayes	2–3 weeks	Khan Academy Stats
Linear Algebra	vectors, dot products, matrix multiply	1 week	Khan Academy Linear Algebra
Calculus	derivatives, gradient intuition	1 week	Khan Academy Calculus

Pro tip: after each new concept, reopen your earlier project and ask a question that needs it (e.g., “How does standard deviation change if I drop outliers?”). Learning sticks when it solves a problem you already have.

Step 4: Core ML Algorithms (Week 9–12)

Resist the urge to binge-watch every neural-network hype video.

Instead, lock in these five:

Linear regression – the mother of all models.
Logistic regression – classification gateway drug.
Decision trees – white-box, human-readable.
Random forest & gradient boosting – practical powerhouses.
k-means clustering – when you don’t have labels.

Resources:

Book (free PDF): An Introduction to Statistical Learning
Companion videos: StatLearning YouTube series
Code-along: scikit-learn’s official tutorial

Work each algorithm three ways:

From scratch (plain Python)
With scikit-learn (one-liner .fit())
On your own dataset

That’s where real understanding happens.

Step 5: Second Project—End-to-End ML (Week 13–16)

Choose a Kaggle dataset that’s not Titanic (every recruiter has seen it).

Follow this loop:

EDA with pandas
Feature engineering
Baseline model (linear regression)
Iterate (random forest, XGBoost)
Validate properly (train/validation/test split)
Write a README with results & business takeaway.

Push to GitHub and link it on your résumé.

A small, clean project beats a half-finished “Uber-for-ML” behemoth every time.

Step 6: Collaborate & Ship (Week 17+)

Learning alone is slow. Speed it up:

Pair program—find a buddy on Discord/Reddit.
Code review—ask for PR feedback in Kaggle kernels or GitHub.
Talk about it—present your findings to a local meetup or on Zoom.

These interactions teach you the unspoken rules: how to structure repos, write readable code, and explain models to non-technical stakeholders.

Step 7: Advanced Topics—Only When You Need Them

Topic	Learn When	Starter Resource
Deep learning (CNNs, RNNs, Transformers)	Your tabular data hits a ceiling	Andrej Karpathy “Neural Networks: Zero to Hero”
Model deployment	Someone asks for an API	FastAPI + Docker tutorial
MLOps	Your models break in production	Made With ML course

Follow the need-not-FOMO rule: if a technique doesn’t solve a problem you have, bookmark it and move on.

Quick Dos & Don’ts

Do	Don’t
Build one small project to completion	Chase every new framework release
Read the scikit-learn docs	Copy-paste code you don’t understand
Ask “why am I learning this?” every hour	Memorize hyper-parameters by heart
Share your work publicly	Learn in isolation

Timeline at a Glance

Weeks	Focus	Deliverable
1–2	Python + Jupyter	“Hello, data” notebook
3–4	Data project	GitHub repo + slideshow
5–8	Math foundations	Updated project with stats
9–12	Core ML algorithms	Algorithm comparison notebook
13–16	End-to-end ML project	Kaggle/GitHub repo + README
17+	Collaborate & specialize	Peer-reviewed contributions

Lastly

You won’t feel “ready.” No one does.

But after ~4–6 months of consistent work you’ll have:

At-least three solid GitHub projects
A grasp of the math that matters
A network of peers who push you forward.

That combination is what hiring managers actually care about—not the certificate that claims you finished a 3-month bootcamp in record time.

Now close this tab, open Jupyter, and start with Step 1.

Javascript await was rogue all along

Friday candour — Fri, 06 Jun 2025 12:42:21 +0000

Don't tell me you don't know await is rogue too, jess christ.

Tell me what is going here.

(async () => {

  const x = await { then: f => f(4 + 2) };

  console.log(x);
  // 6
})();

Example by Thomas

Right there is a thenable, a big time Javascript interface implemented in .then callback chaining.

Or as MKRhere like to put it

"An object that exposes a then method is a Thenable"

Now let's explore some more interesting things.

Let's quickly reiterate on a fundamental definition.

A Thenable is simply an object with a .then() method. That's it. No fancy constructors, no new Promise(), no specific internal slots. Just a method named then.

Think about it, the Promise specification itself relies heavily on the then method. It's the core of how asynchronous operations are chained and resolved. And await, bless its rogue little heart, just says, "Hey, if you've got a then method that behaves like a then method, I'm good. I'll wait for whatever value you pass to that function." that's incredibly pragmatic in my opinion.

Now, if we internalize this, what else becomes possible? What if we don't even need a Promise at all to await something? Thomas's example with f => f(4 + 2) is simple enough. But what if the "value" isn't immediately available? What if it's... delayed?

Imagine we've got a function that simulates fetching a user's profile, but instead of returning a Promise, it returns a plain object that just looks like a promise.

Scenario 1: The 'Fake Promise' that's totally legit to await


const fetchUserProfileThenable = (userId) => {
    console.log(`Fetching user ${userId}...`);
    return {
        then: (resolve) => {
            // Simulate network delay
            setTimeout(() => {
                const user = { id: userId, name: `User ${userId}'s Profile`, status: 'active' };
                console.log(`User ${userId} fetched!`);
                resolve(user); // Resolve with the user object
            }, 1000); // 1 second delay
        }
    };
};

(async () => {
    console.log("Application starting.");
    const user1 = await fetchUserProfileThenable(1);
    console.log("Awaited user 1:", user1);

    const user2 = await fetchUserProfileThenable(2);
    console.log("Awaited user 2:", user2);
    console.log("Application finished.");
})();

Expected output:

Application starting.
Fetching user 1...
User 1 fetched!
Awaited user 1: { id: 1, name: "User 1's Profile", status: "active" }
Fetching user 102...
User 102 fetched!
Awaited user 2: { id: 2, name: "User 2's Profile", status: "active" }
Application finished.

Surely that looks fantastic right?, lesser overhead than using new Promise();

Here's a real life use-case in from Prisma docs.

If you have, probably written code that looks suspiciously like this:

// Prepares the query but does not run any thing;
const allUsers = prisma.user.findMany()

// Actually run the query.
await allUsers;
// so you know how Prisma is designed to handle this right?

Well mostly we will just run...

const allUsers = await prisma.user.findMany()

But in their implementation, It's a form of lazy execution provided by implementing the thenable interface.

When NOT to go rogue

Tho powerful, custom thenables can be harder to debug if their then method is too complex or deviates from expected promise-like behavior. Native Promises often provide more consistent guarantees.
"The Promise.resolve() Connection": Explicitly showing how Promise.resolve(thenable) works, as await uses a similar internal mechanism.

How new language features might standardize some of the patterns custom thenables can achieve, is something i'm i will be watching for.

If you have some interesting additions, let's chat in the comments :)

I still prefer SQLite for little things you know.

Friday candour — Sat, 19 Oct 2024 15:38:09 +0000

I still can't express enough how useful SQLite is, when i need a db for small
and experiments stuff, but for a while, i have taken it beyond that subconsciously.

It’s now a core part of my toolkit for tasks where simplicity and minimal overhead are crucial. What began as a preference for smaller, experimental projects has matured into a deliberate choice in production scenarios. This shift comes in the the rise of managed services that address its traditional limitations.

I have come across a couple of
SQLite managed services
in a while now and i believe it's eventually going to get better.

This has opened up new possibilities for developers who appreciate the simplicity and lightweight nature of SQLite but need more robust performance for production environments. With the growing ecosystem around SQLite, from serverless platforms like Cloudflare D1 to promising newcomers like Turso’s libSQL, there’s a clear trend towards making SQLite more scalable and resilient, often these services deploy SQLite in edge environments, providing low-latency access and reducing the distance between users and data.

In production, i am usually soaked with PostgreSQL and MongoDB depending on
requirements and deadline, but these days using SQLite often in production code
has become my norm and as far i'm using a reputable managed service.

For me, Cloudflare D1 just works fine and super cheap,turso libSQL looks solid
but i haven't dig into it yet.

SQLite vs. PostgreSQL: Just to differentiate

Just to differentiate between these data tools, while both have distinct design philosophies and use cases. we should evaluates their differences in features, performance, and suitability for various applications.

Data Modeling Considerations

When choosing between SQLite and PostgreSQL, consider your data modeling requirements. SQLite is suitable for simple data models, while PostgreSQL supports complex data relationships and schema changes, ~i need to stress this part~.

SQLite vs. PostgreSQL: A Comparative Analysis

Features

Feature	SQLite	PostgreSQL
Data Types	Limited	Extensive
Indexing	B-tree, Hash	B-tree, Hash, GiST, SP-GiST
Transactions	ACID-compliant	ACID-compliant
Concurrency	File-level locking	Row-level locking
Scalability	Limited	Horizontal partitioning
SQL Support	Partial SQL-92	Full SQL-92, SQL:2011

It's reasonable to consider community support and extensibility when comparing SQLite and PostgreSQL. PostgreSQL benefits from a large ecosystem of plugins and extensions that enhance its capabilities in analytics, geospatial data, and beyond. On the other hand, SQLite's simplicity allows for faster iterations, making it perfect for agile development where rapid prototyping is key. The choice ultimately depends on the project's complexity, scalability needs, and how much control over database management is desired.

Use Cases

Use Case	SQLite	PostgreSQL
Embedded Systems	Ideal	Not suitable
Mobile Applications	Suitable	Not ideal
Web Applications	Limited	Suitable
Enterprise Systems	Not recommended	Recommended

Yeah Postgres is a lioness, regardless using a managed SQLite DB offers reliability and security needed for production, plus simplicity.

Some of the traditional constraints of using SQLite in small to medium scale web and enterprise applications are fading away. For example, managed services provide automated backups, high availability, and even multi-region deployments, allowing SQLite to be a viable option for certain production workloads.

Benefits i enjoy using Managed services

Benefit	Description
Scalability and cost-effectiveness	Automatic scaling and cost optimization
Simplified application development	Reduced administrative burden
Enhanced performance and reliability	Optimized database performance
Integrated security features	Built-in security controls
edge deployments	managed edge deployments

Managed services often come with monitoring tools and performance metrics that offer valuable insights into database usage, helping optimize performance over time. For projects that require real-time data processing at the edge, using SQLite in this way is proving to be a cost-effective solution, blending well with serverless architectures.

Challenges i face using managed services.

Challenge	Description
Cold start latency	Initial function invocation delay
latency	network delay
Vendor lock-in	Norms
can't fit large data use case	SQLite itself is not scalable

Network latency in edge deployments can be minimized, Additionally, while vendor lock-in is a challenge, understanding each service’s offerings and limitations can help mitigate the risks and create a more adaptable database strategy.

Mitigating

To overcome the challenges of managed services one could:

Implement caching mechanisms to reduce latency.
Design applications with scalability in mind.
Monitor vendor lock-in risks and plan for migration.
Optimize data storage and retrieval strategies.

last week i needed to make my code reusable, So i worked a query builder that fits my needs for:

using cloudflare D1 via api, (yeah i gotta escape using workers bindings 👀)
using bun SQLite locally (yeah it's kinda faster)
just generate the query and let me do the rest (💆)
in typescript and super lightweight? yeah!!! (💃)

If you want to check it out see here.

follow me for more contents as well.

Empowering Language Learners: Introducing Linguaverse, Your AI Companion.

Friday candour — Mon, 15 Apr 2024 02:23:50 +0000

This is a submission for the Cloudflare AI Challenge.

What I Built

My project, crafted for the Cloudflare AI Challenge, is designed to redefine how we learn languages with the help of AI.

Linguaverse is designed to make language learning interactive and accessible:

Interactive Learning Chat: Engage in real conversations tailored to you, providing practical language practice with AI asistance.
Seamless Translations: ~~~Effortlessly translate text across multiple languages with accuracy and context, making communication across language barriers easy and intuitive~~~.

Architecture

This is entirely based off cloudflare workers and pages.
pure html, css and javascript but with professional touch.

Demo

My Code

Live preview: https://linguaverse.pages.dev/src/index.html

site: https://github.com/FridayCandour/Linguaverse
worker script: https://github.com/FridayCandour/-linguaverse-api

Journey

Next Steps
Moving forward, we aim to:

Enhance the interactive learning chat with additional features to provide more personalized feedback and guidance.
Expand language support to include a wider range of languages and dialects, ensuring inclusivity and accessibility for all learners.
Integrate gamification elements to increase engagement and motivation, making language learning a fun and rewarding experience for users of all levels.

Multiple Models and/or Triple Task Types

The AI chat feature only uses: @cf/meta/llama-2-7b-chat-int8
the translation feautures uses: @cf/meta/m2m100-1.2b

glacias :)

At this point, Linguaverse will mostly teach you french.

Started too late.

Introducing JetPath: A Lightning-Fast, Code-Saving Node Framework, for Supercharged Server-Side apps! ✨🚀

Friday candour — Thu, 28 Dec 2023 09:50:11 +0000

Image by Tom from Pixabay

Navigating the Challenges of Server-Side Frameworks for Node.js, Deno.js, and Bun.js

I'm writing this article to talk about two things.

The heavy and cumbersome nature of server-sider frameworks for NodeJs, Denojs and Bunjs
The solution y'all been waiting for!

let's walk in.

Cumbersome? what's cumbersome?

What's the Challenge?

Things become cumbersome when they tends to create a dependency tree, complicated interfaces, limited innovation, excessive abstraction layers, and most of all using solutions that implies heavy runtime overhead. If you've ever felt trapped in this situation, you're not alone.

As a software engineer i always have this phylosophy of simplicity is easier to manage and extend. The tool I'm about to introduce aligns with this philosophy, providing a refreshing perspective in this early 2024 and beyound.

The Culprits in most node Frameworks.

High learning curve, Abstraction layers, Convention over Configuration, Middleware management, boiler-platey codes, Configuration Overheads, Dependency Injection overhead, debugging challeges, updates and compartibility dramas.

Not to make this article too long and creating a debate over the value of whatever advantages or disadvantages. i won't go much into detail on which tools is lacking or what's not.

Instead, Let's find out something better.

Rationale

JetPath

JetPath is one of Bun's fastest web frameworks.
benchmark repo
JetPath is Javascripts's easiest backend library.
JetPath repo

Many are obviously fed up of dealing with heavy and cumbersome server-side frameworks for our Node.js, Deno.js, and Bun.js applications. Looking into JetPath which revolutionize our development experience With its lightweight design and intuitive routing patterns, JetPath takes server-side JavaScript frameworks to a new level of innovation and simplicity.

Whether you're using Node.js, Deno.js, or Bun.js, JetPath adapts seamlessly to your preferred runtime. Let's look into JetPath maybe it will solve all your problems.

It's a runtime 'Drop in' it only use the native http api of the runtime you run your app with, so zero http compartibility overhead.

With a simple design and high performance, JetPath offers a refreshing experience, i have ever seen. this is new innovation.

Fast, Small, and Easy-Peasy

JetPath is a small and efficient framework, weighing in at just 5kb. Its lightweight nature bare level of abstraction ensures your applications performs optimally without unnecessary overhead. Additionally, JetPath offers an easy-to-use context (ctx) API.

The Need for more Speed and Simplicity

When it comes to server-side frameworks, speed and simplicity are of utmost importance. JetPath's aim is to avoid performance bottle necks, with a lightweight and minimalist design that emphasizes on speed and simplicity.

It's has an inbuilt intuitive routing system, which uses function names as routing patterns, sets it apart from traditional frameworks like Express or Fastify. This innovative approach simplifies your code and enhances the readability of your routing logic, making it easier to design and manage your API(s) with unparalleled granularity.

The Power of JetPath

JetPath seamlessly adapts to your preferred runtime. With JetPath, you have the flexibility to choose the runtime that best suits your project's requirements without sacrificing the simplicity and speed that JetPath offers. Why limit yourself to a single runtime when JetPath empowers you to explore all three? with no extra steps, configurations or overheads!!!

Exploring How JetPath's Work

JetPath operates by searching through your source folder and automatically assembling any exported defined paths and hooks functions following its intuitive route patterns.

This seamless integration saves you precious development time and effort. Instead of spending time configuring and setting up routes you just write them as the function name and you can focus on crafting your application's core logic while JetPath handles the rest for you.

JetPath's minimalist and efficient approach streamlines the development process, allowing you to build powerful server applications with ease and speed.

Easy Setup and Configuration

Getting started with JetPath is a breeze. Simply install JetPath using npm or your preferred JavaScript package manager:

npm install jetpath --save

Once installed, configure your JetPath instance with necessary options, such as setting the source folder for your routes and specifying the port you want to listen on. Here's an example:

import { JetPath } from "jetpath";

const app = new JetPath({
  source: "./src", // Optional: Set the source folder for your routes
  port: 3000, // Optional: Specify the port you want to listen on
  cors: true, // Optional: Enable CORS support
});

// Start listening for requests
app.listen();

With just a few lines of code, you're up and running with JetPath, ready to take advantage of its speed and simplicity.

Core features of `JetPath`

These features are the core of JetPath.

Function Names as Routing Patterns

JetPath introduces an innovation where your function names declares the routing pattern for the function. This unique approach eliminates the need for complex configuration files and enables you to define routes with ease.

My first testimony - ( more below )

not going to spend time thinnking about what to name this function anymore, cus now i know!

Pre, Post, and Error Request Hooks

JetPath provides hooks that allows you to execute code before and after each request, as well as handle any runtime errors that may occur. These hooks offer unparalleled flexibility to customize the behavior of your application. Whether you need to manipulate data, validate requests, or handle errors gracefully, JetPath's hooks has got you covered.

Decoration Hook

This allows you to extend the power of the CTX object that is avaible on every request by adding your custom functionality, like auth or specific Utils needed by your app on every request.

Built-in CORS Handlers

JetPath has an built-in CORS hook. Enable CORS support with a simple iniatilisation option, and JetPath takes care of the rest.

Requirements and Installation

JetPath is built for the major server-side JavaScript runtimes, Node.js, Deno.js, and Bun.js. Additionally, it offers experimental support for environments like Deno Deploy and edge runtimes such as Cloudflare Workers (coming soon). To get started, simply install JetPath using your preferred package manager:

npm i `jetpath` --save

Getting Started with JetPath

Using JetPath is incredibly straightforward. Let's walk through a basic app setup to demonstrate the simplicity of JetPath:

import { JetPath } from "jetpath";

const app = new JetPath({
  source: "./src", // Optional: Set the source folder for your routes
  port: 3000, // Optional: Specify the port you want to listen on
  cors: true, // Optional: Enable CORS support
});

// Start listening for requests
app.listen();

Example Routes

To provide a better understanding of JetPath's capabilities, let's take a look at

some example routes:

// File: src/routes/cats.js

// GET localhost:8080/
export function GET_cats(ctx) {
  ctx.set("token", "0x00000");
  ctx.reply("Welcome home, `JetPath` fellas!");
}

// GET localhost:8080/cats
export function GET_cats(ctx) {
  ctx.reply({ foo: "bar" });
  // ctx.throw(400, "meow");
}

// POST localhost:8080/cats
export async function POST_cats(ctx) {
  console.log(await ctx.text());
  ctx.reply("Enter skelter");
}

// GET localhost:8080/cats/friday/12/male
export async function GET_cats$name$age$sex(ctx) {
  const { name, age, sex } = ctx.params;
  ctx.reply(
    `Hello ${name}, you are ${age} years old and you are ${sex}. Thanks for visiting the JetPath App!`
  );
}

// GET localhost:8080/cats?*
export async function GET_cats$$(ctx) {
  const { name, age, sex } = ctx.search;
  ctx.reply(
    `Hello ${name}, you are ${age} years old and you are ${sex}. Thanks for visiting the JetPath App!`
  );
}

// GET localhost:8080/default/dog/types
export async function GET_default_dog_types(ctx) {
  // custom ctx methods
  ctx.sendDefaultDoglist();
}

// Hooks
export function hook__POST(ctx, data) {
  // console.log("POST boohoo");
  return data;
}

export function hook__PRE(ctx) {
  // console.log("PRE function boohoo");
  return data;
}

export function hook__ERROR(ctx, err) {
  ctx.throw(400, "Bad request!");
}

// hook to decorate the CTX
export function hook__DECORATOR() {
  return {
    sendDefaultDoglist() {
      this.reply({
        types: [
          "rottweiler",
          "german sheepherd",
          "boerbull",
          "husky",
          "neopolitan mastiff",
          "pitbull",
          "pug",
          "eskimo",
          "labrador",
          "golden retrieval",
        ],
      });
    },
  };
}

We define routes using function names, allowing for clear and concise code. JetPath also supports pre and post-request hooks, providing extra flexibility for customizations. Additionally, JetPath includes inbuilt CORS hooks, things everyone web dev needs :).

It's time to JetPath, JetPath, Jet.

JetPath is the game-changing innovation you've been waiting for — a fast, minimalist framework that empowers you to build powerful server applications with ease. With its lightning speed, simplicity-driven design, and passionate community, JetPath is the ideal choice for your Node.js, Deno.js, or Bun.js projects.

My testimony

Jetpath greatly reduced the code on all my node code-bases and let me focus on what's important.

Wait i forgot to mention my apis are several orders of magnitude faster than previous frameworks my projects were based on.

Add your testimonies below

...

Some read-world codes (copied with permission)

export async function POST_admin_create_product(ctx: AppCTXType) {
  await productSchema.validateData(await ctx.json()).catch((e) => {
    ctx.throw(400, e); // code stopped executing here if erred
  }); // ignore it don't share my data validator library it's too fast.

  ctx.body.category = ctx.body.category.toLowerCase().trim();
  ctx.body.uploadedOn = new Date().toDateString();
  const product = new Product(ctx.body);
  const data = await product.save();
  ctx.reply({ data, status: 201, message: "ok" });
}

export async function Get_products_search$query(ctx: AppCTXType) {
  if (!ctx.params.query) return undefined; // post hook handovers
  const search = await Product.find({
    title: { $regex: ctx.params.query, $options: "i" },
  })
    .limit(38)
    .exec();
  ctx.reply(search);
}

share the love, tell someone about JetPath. i told my friends and my mum.

Joining the Community

Our Telegram group with other web tools i have made like Exabase and Cradova, stuffs you would love.

Where's JetPath future gonna be like?

currently we are working on integration with industry tools like

Logger (easy)
Swagger (in progress)
Web Socket (in the next release)
http stream (in the next release)
file upload (in the next release)

Those in (in the next release) can be done easily by getting the req object from ctx, but it's going to be available by default soon.

What about Logger?

I major just use this jet-logger solution. the developer added a way to persit to a log file which is nice.


// npm i jet-logger
import logger from 'jet-logger';

// hook to decorate the CTX
export function hook__DECORATOR() {
  return {
    error(msg) {
      logger.err(msg);
    },
    info(msg){
      logger.info(msg);
    }
    imp(msg){
      logger.imp(msg);
    }
    warn(msg){
      logger.warn(msg);
    }
  };
}

This road map is short and narrow to what everyone would benenfit from the most, if you have any suggestions kindly reach out to me on the community.

If you want to make npm packages for JetPath and need support, send a dm.

dog names suggestions was provided by @da-favice.

The Pizza Area

Jump and Slide

Friday candour — Sat, 15 May 2021 09:35:20 +0000

Original animation by Vitaly Silkin: https://dribbble.com/shots/4268258-Evitare-loader

Also inspired by the @keyframers! https://www.twitch.tv/keyframers

Modern Google Loader in Pure CSS

Friday candour — Sat, 15 May 2021 09:18:49 +0000

Modern Google spinning loader animating through four colors.