Forem: Arindam Sahoo

OLAP vs OLTP — What Every Beginner Should Know

Arindam Sahoo — Thu, 18 Sep 2025 16:12:24 +0000

“Our education system teaches us how to solve 200-year-old math problems but forgets to tell us how live apps like actually work.”
If you just stepped into college and feel clueless about tech terms being thrown around — welcome to reality. Let’s break down one such buzzword war: OLAP vs OLTP.

First Things First — WTF are OLAP and OLTP?

OLTP (Online Transaction Processing):
Imagine you are ordering momos from Zomato. You tap “Order Now”, payment happens, your order is saved, and the momo guy gets the notification. That small, fast transaction? That’s OLTP in action.
👉 OLTP = handles day-to-day operations.
OLAP (Online Analytical Processing):
Now imagine Zomato wants to see “Which city eats the most momos at midnight?”. They don’t look at your single order. Instead, they analyze millions of orders to find patterns. That big, analytical brain? That’s OLAP.
👉 OLAP = handles analysis and insights.

Side-by-Side Breakdown

Feature	OLTP (Transactional)	OLAP (Analytical)
Purpose	Running day-to-day apps (like payments, bookings, logins)	Analyzing data for decision-making
Data Size	Small transactions	Huge datasets
Speed	Fast reads/writes (milliseconds)	Complex queries (seconds/minutes)
Users	Frontline users (customers, employees)	Data analysts, managers
Example	Booking a cab on Ola	Ola analyzing busiest routes in Kolkata

Why Should You Care?

Because everything around you runs on these systems.

Your college’s “Online Result Portal” → OLTP
The report your principal sees about “pass % of students over 5 years” → OLAP
Instagram likes → OLTP
Instagram showing which reels are trending in your city → OLAP

In short, OLTP = do things fast.
OLAP = think about things later.

How Plotly is Better than Matplotlib and Seaborn (and Where It Falls Short)

Arindam Sahoo — Fri, 28 Jun 2024 05:15:24 +0000

When it comes to data visualization in Python, three names often come up: Matplotlib, Seaborn, and Plotly. Each of these libraries has its own strengths and weaknesses, catering to different needs and preferences. In this post, we'll explore why Plotly stands out compared to Matplotlib and Seaborn, and also touch upon its limitations.

Why Plotly Shines

1. Interactivity

Plotly is renowned for its interactivity. Unlike Matplotlib and Seaborn, which primarily produce static plots, Plotly generates interactive plots that allow users to zoom, pan, and hover to get more details. This feature is incredibly useful for exploratory data analysis and presentations where deeper insights are often needed.

import plotly.express as px
df = px.data.iris()
fig = px.scatter(df, x='sepal_width', y='sepal_length', color='species')
fig.show()

2. Ease of Use

Plotly's high-level API makes it easy to create complex visualizations with minimal code. Plotly Express, a submodule of Plotly, is particularly user-friendly and allows for quick generation of plots without the need for extensive customization.

import plotly.express as px
fig = px.histogram(df, x="sepal_length", nbins=20)
fig.show()

3. Aesthetics

Plotly's default aesthetics are modern and visually appealing. While Seaborn offers some improvements over Matplotlib in terms of aesthetics, Plotly's output often looks more polished right out of the box. This makes it an excellent choice for creating publication-quality visuals with minimal effort.

4. Integration with Dash

Plotly integrates seamlessly with Dash, a framework for building analytical web applications. This makes it possible to create interactive, web-based dashboards without needing to dive into JavaScript, a significant advantage for Python developers.

5. Support for 3D Plots and Geospatial Data

Plotly provides excellent support for 3D plots and geospatial data visualizations. These capabilities are either limited or require additional libraries in Matplotlib and Seaborn.

import plotly.graph_objects as go

fig = go.Figure(data=[go.Scatter3d(
    x=[1, 2, 3], y=[4, 5, 6], z=[7, 8, 9],
    mode='markers',
    marker=dict(size=5)
)])
fig.show()

Where Plotly Falls Short

1. Performance

While Plotly's interactivity is a strong suit, it comes at the cost of performance. Rendering large datasets can be slow compared to Matplotlib and Seaborn. For extremely large datasets, Matplotlib is often more efficient.

2. Learning Curve

Despite its ease of use for basic plots, mastering Plotly's full capabilities, especially its lower-level graph objects API, can be challenging. Matplotlib, although more verbose, has a more straightforward learning curve for those familiar with traditional plotting paradigms.

3. Dependence on Web Technologies

Plotly's interactive plots are rendered using web technologies like HTML, CSS, and JavaScript. This can be a disadvantage in environments where web access is restricted or not available. In contrast, Matplotlib and Seaborn generate static images that are easy to embed in non-web contexts.

4. File Size and Complexity

Interactive plots can lead to larger file sizes and more complex HTML documents. This can be a concern when sharing results or embedding plots in web pages where performance and simplicity are crucial.

5. Limited Customization Compared to Matplotlib

For highly specialized plots, Matplotlib still holds the crown. Its extensive customization options, though sometimes complex, allow for fine-tuning that is not always possible in Plotly.

Conclusion

Plotly, Matplotlib, and Seaborn each have their own strengths and are suited to different tasks. Plotly excels in interactivity, ease of use, aesthetics, and integration with web technologies, making it an excellent choice for interactive dashboards and exploratory data analysis. However, its performance with large datasets, learning curve, and dependence on web technologies can be limitations.

For those seeking a balance between simplicity and power, Seaborn is a great choice, building on Matplotlib's foundation with enhanced aesthetics and simpler syntax. Meanwhile, Matplotlib remains indispensable for those needing the ultimate level of control and customization.

Choosing the right tool often depends on the specific requirements of the task at hand. Understanding the strengths and weaknesses of each library can help you make an informed decision and leverage the best of what each has to offer.

Creating a Custom Abstract User Model in Django

Arindam Sahoo — Wed, 17 Jan 2024 05:47:11 +0000

Django provides a default user model that is suitable for most projects. However, as the project scales, a customized approach is often required. This guide will demonstrate how to create a custom abstract user model in Django, providing greater flexibility and customization options. This comprehensive tutorial will take you through each step, ensuring a solid understanding of the process.

Step 1: Setting Up a New Django App

To begin with the customization process, we need to create a fresh Django application that will act as the framework for our custom user model. Once this is accomplished, we can proceed with the necessary modifications to tailor the user model to our specific needs.

python manage.py startapp myapp

Replace "myapp" with a name that aligns with your project.

Step 2: Defining the Custom User Model

To create a custom user model, we need to modify the models.py file located within the newly created app. This file contains the AbstractBaseUser and PermissionsMixin classes which we'll extend to create our custom model. By doing so, we can define the fields and attributes that are relevant to our application's requirements. To handle user creation, we'll also create a custom manager that will allow us to customize the process and ensure that it's consistent with our user model. With these modifications, we can create a custom user model that is tailored to our application's specific needs.

# myapp/models.py
from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin
from django.db import models

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('The Email field must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password=None, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)

        return self.create_user(email, password, **extra_fields)

class CustomUser(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(unique=True)
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)

    objects = CustomUserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['first_name', 'last_name']

    def __str__(self):
        return self.email

In this particular instance, we have incorporated a personalized manager named CustomUserManager and formulated a distinctive model called CustomUser. This model comprises multiple fields, such as email, first name, last name, and others, that can be adjusted as per the specific needs of your project.

Step 3: Updating Django Settings

After creating a custom user model, the next step is to instruct Django to use it. This involves going to your project's settings.py file and modifying the AUTH_USER_MODEL setting accordingly. Once updated, Django will recognize your custom user model as the default user model for your project.

# settings.py
AUTH_USER_MODEL = 'myapp.CustomUser'

Remember to replace 'myapp' with the actual name of your app.

Step 4: Creating and Applying Migrations

To ensure your changes are reflected in the database, generate and apply migrations:

python manage.py makemigrations
python manage.py migrate

By completing this step, you will be able to successfully incorporate your personalized user model into the Django project, making it fully functional for authentication and authorization procedures. This integration will ensure that your custom user model is seamlessly incorporated into the project and can be utilized for secure and efficient user management.

Flexibility in Authentication

Django is a high-level Python web framework that offers a lot of flexibility to developers. One of the most powerful features of Django is the ability to create a custom abstract user model that enables developers to tailor authentication to their application's unique needs.

By creating a custom abstract user model, you can define your own set of user fields, including custom fields, and set your own authentication rules. This ensures that your authentication system aligns precisely with your project's requirements, providing a more secure and personalized user experience.

Creating a custom abstract user model is a straightforward process that involves a few simple steps. By following these steps, you can seamlessly integrate your personalized user model into your application, providing a foundation for a scalable and customizable user management system.

Overall, the ability to create a custom abstract user model in Django is a powerful tool that empowers developers with the flexibility they need to build secure, personalized, and scalable web applications.

Understanding Django's Secure Password Encryption

Arindam Sahoo — Tue, 16 Jan 2024 12:43:40 +0000

Django is a popular Python web framework that places a high priority on security. It has a strong focus on ensuring the safety of user passwords, with a robust encryption mechanism that is designed to protect sensitive user data. In this detailed analysis, we will delve into the layers of Django's encryption mechanism and highlight the key elements that make it a reliable protector of user information.

Understanding the Foundation: PBKDF2

Django's password security is designed to protect user passwords from being compromised by malicious actors. At the core of this security system lies the PBKDF2 (Password-Based Key Derivation Function 2) algorithm, which is recognized for its resilience against brute-force attacks. PBKDF2 is a computationally intensive algorithm that makes it difficult for any malicious actor to crack hashed passwords. By using this algorithm, Django ensures that user passwords are stored in a secure and protected manner, making it a reliable and trustworthy platform for users to store their sensitive data.

Salting for Unpredictability

Django introduces the concept of salting to enhance the security of user passwords against attacks. A random and unique salt is generated for each user. This salt is combined with the user's password before hashing, which results in distinct hashed passwords even if two users share the same password. This unique salt ensures that each user's password is protected and difficult to crack by attackers.

Iterations: Striking the Right Balance

PBKDF2 is a widely used algorithm for password hashing. Its strength depends on the number of iterations, which can be configured based on the required level of security. While higher iterations result in stronger security, they also slow down the hashing process. Django, a popular web framework, uses an optimal number of iterations to balance security and performance. This ensures that user experience is not compromised while keeping the system robust and secure.

The Anatomy of Stored Passwords

Django saves passwords in a meticulous format in the database, which includes essential information such as the algorithm used, the number of iterations, the salt, and, of course, the hashed password.

For example,
pbkdf2_sha256$150000$AbCdEfGhIjKl$AbCdEfGhIjKlAbCdEfGhIjKlAbCdEfGhIjKlAbCdEfGhIjKl

Django has a standardized structure that helps to efficiently authenticate passwords during the login process.

Django's Fortification

Django's password encryption approach shows the framework's commitment to user security using PBKDF2, salting, and optimal iterations for defense against unauthorized access.

The complicated process of cryptographic elements guarantees that Django stays a reliable protector, capable of securing user data despite any emerging security threats. As you venture into the world of Django development, you can be confident that your users' passwords are protected by a sturdy and sophisticated system.

React Integration with Django Using Babel & Webpack

Arindam Sahoo — Wed, 03 Jan 2024 05:46:10 +0000

Hi Devs,

In this post, let's try to add React to our Django Project. It is slightly hectic to remember all the steps, so this post will also help me jot down all of them.

Let me just let you know the Current Directory Structure I am assuming you have before getting started:

├── project
│   ├── app
│   │   ├── migrations
│   │   ├── __init__.py
│   │   ├── admin.py
│   │   ├── apps.py
│   │   ├── models.py
│   │   ├── serializers.py
│   │   ├── tests.py
│   │   ├── urls.py
│   │   └── views.py
│   ├── project
│   │   ├── migrations
│   │   ├── __init__.py
│   │   ├── asgi.py
│   │   ├── settings.py
│   │   ├── urls.py
│   │   └── wsgi.py
│   └── manage.py

Now, we have to make another Django App called frontend by typing

django-admin startapp frontend

Inside the Project Directory.

Then we need to get inside the frontend directory and make a few folders inside it for static and templating files. The apps.py file in this frontend directory is going to store all the kinds of stuff related to our frontend.

And our frontend should look like this:

├── frontend
│   ├── migrations
│   │   └── __init__.py
│   ├── src
│   │   ├── components
│   │   │   ├── App.js
│   │   │   └── Home.js
│   │   └── index.js
│   ├── static
│   │   ├── css
│   │   ├── frontend
│   │   └── images
│   ├── templates
│   │   └── frontend
│   │       └── index.html
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── models.py
│   ├── serializers.py
│   ├── tests.py
│   ├── urls.py
│   └── views.py

Now, in the frontend directory we will type in the command:

npm init -y

This is used to initialize a new Node.js project using npm with default values. It automatically generates a package.json file for your project without prompting you for any input.

Following this, we need to type in these commands:

npm i webpack-cli --save-dev

The npm i webpack-cli --save-dev command installs the webpack-cli package as a development dependency. Webpack is a module bundler for JavaScript applications, and webpack-cli provides a command-line interface for webpack.

npm i @babel/core babel-loader @babel/preset-env @babel/preset-react --save-dev

The npm i @babel/core babel-loader @babel/preset-env @babel/preset-react --save-dev command installs several Babel-related packages as development dependencies:

@babel/core: This is the core Babel compiler.
babel-loader: This is a webpack loader that allows you to transpile your JavaScript code using Babel during the webpack build process.
@babel/preset-env: This preset allows you to use the latest ECMAScript features and automatically determines the Babel plugins and polyfills needed based on your target environments.
@babel/preset-react: This preset is specifically for React applications. It enables Babel to understand and transform JSX syntax used in React components.

npm i react react-dom

The npm install react react-dom installs React and ReactDOM as regular dependencies, and they will be added to the "dependencies" section of your package.json file. React is the library for building user interfaces, and ReactDOM is the package that provides integration with the DOM.

npm i @babel/plugin-proposal-class-properties

This command installs the Babel plugin @babel/plugin-proposal-class-properties. This plugin is used to enable support for class properties in your JavaScript code. Class properties allow you to define properties directly on a class rather than in a constructor.

npm i react-router-dom

It installs the react-router-dom package, which is a package for handling routing in React applications, and will help us reroute the pages so that we can go, well, two different pages from a React App.

Now, after all these, we need to set up some configuration scripts that are going to run and handle our Webpack and our Babel. One can copy these files from here because they are going to be the same thing for everyone.

Firstly, we are going to create a new file in the frontend directory named babel.config.json and paste the following into it.

{
  "presets": [
    [
      "@babel/preset-env",
      {
        "targets": {
          "node": "10"
        }
      }
    ],
    "@babel/preset-react"
  ],
  "plugins": ["@babel/plugin-proposal-class-properties"]
}

Next, create another file and name it as webpack.config.js and paste the following into it.

const path = require("path");
const webpack = require("webpack");

module.exports = {
  entry: "./src/index.js",
  output: {
    path: path.resolve(__dirname, "./static/frontend"),
    filename: "[name].js",
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: {
          loader: "babel-loader",
        },
      },
    ],
  },
  optimization: {
    minimize: true,
  },
  plugins: [
    new webpack.DefinePlugin({
      "process.env": {
        // This has effect on the react lib size
        NODE_ENV: JSON.stringify("production"),
      },
    }),
  ],
};

Just to let the reader know, what Webpack does is bundle all of our JavaScript into one file. We can bundle it into multiple files, but anyway, it just takes all this JavaScript code we have makes a bundle of it, and then serves that one file to the browser.

Now, let's move on to the next step. We are going to go to package.json file and what we need to do inside here is where it says scripts, we need to add two scripts, which are going to run this Webpack. The first thing we're going to add is the dev script. What this is going to do is tell us that, we want Webpack to run, we want to run a neat development mode and we want it to be in watch mode. Next, we're going to add a build script.

"scripts": {
    "dev": "webpack --mode development --watch",
    "build": "webpack --mode production"
}

Next up, we are supposed to create an index.js file inside the src directory. What we need to do now is to make our Django App render a page that React will take control of. If you haven't used Django & React before then this isn't going to make much sense. But what we are up to is to have our Django Application render a template, which is going to be some vanilla, plain HTML, and which our React will take over and fill in. So, we will technically have the Django backend rendering the template but then React will manage it after that. For the time being, let's go to the index.html file inside frontend folder in templates directory and paste the following:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Title</title>
    {% load static %}
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
    <link rel="stylesheet" type="text/css" href="{% static "css/index.css" %}"
    />
  </head>
  <body>
    <div id="main">
      <div id="app"></div>
    </div>

    <script src="{% static "frontend/main.js" %}"></script>
  </body>
</html>

I don't want to make this very long. So, if you want an explanation of this HTML code, just ask for it in the comments, I will surely help you out.

Once we are done with this, we will move to the views.py file. Now, what we are up to may seem a bit weird and strange if you are new, but we need to just render the index.html template and then let React take care of it. So, the views.py goes like:

# frontend/views.py
from django.shortcuts import render

def index(request, *args, **kwargs):
    return render(request, 'frontend/index.html')

Now, it's time for the urls.py. Before that make sure that you have included the frontend.urls in the urlpatterns of the main-project urls.py file. Again, if you need help, just comment. However, it should look somewhat like this:

# project/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('app/', include('app.urls')),
    path('', include('frontend.urls'))
]

This is just an example.

Now, time for our frontend's urls.py.

# frontend/urls.py
from django.urls import path
from .views import index

urlpatterns = [
    path('', index),
    # Other URL Patterns...
]

Next, we are supposed to make a React component, and therefore we will create an App.js file in the components directory which kinda goes like this:

import React, { Component } from "react";
import { render } from "react-dom";
// import one other component for simplicity
import Home from "./Home";
// import other components if you need them

export default class App extends Component {
  constructor(props) {
    super(props);
  }

  render() {
    return (
      <div>
        <Home />
      </div>
    );
  }
}

const appDiv = document.getElementById("app");
render(<App />, appDiv);

And now, we just need to import the ./components/App we created just created to the index.js file in the src directory.

// src/index.js
import App from "./components/App";

And now, our entry file imports this file, which runs the code and renders the App.js in the index.html template.

Finally, What we have to do is to make sure that our servers are running properly because we may have done something wrong in this whole long process. Once our server is running fine, we need to run the script that we had put inside of our package.json. So the Webpack module development watch should look at our index.js file. It should see that we're importing App.js. It should bundle it together. It should output something to static front-end and that file should be calling main.js. And then we'll go to the URL endpoint. And now, in the terminal, inside the frontend directory, we should run the development server by typing in:

npm run dev

Finally, make sure to do one thing, which I forget most of the time, eventually, I forgot it even while writing it is that we need to list this frontend Django App in the INSTALLED_APPS in the settings.py file in the main project directory.

# project/settings.py

# ...
INSTALLED_APPS = [
    # ...
    'frontend.apps.FrontendConfig',
]
# ...

That's done. Feel free to comment or DM me, if you face any difficulties.
Have a Nice Day Ahead!!
Thank You!

Building a Web App using React & Django

Arindam Sahoo — Mon, 01 Jan 2024 22:45:06 +0000

Hi Devs!

Happy New Year!!
2 years back, when I initially started with Django, all the resources I followed mostly suggested using HTML & CSS Templating. But I always wanted to use React for my Front-end. Again, finding a resource to learn about it was a pain. However, I found a few which were quite difficult to understand initially.

Eventually, it was easy to understand once I understood the Flow of Interaction between my Frontend and Backend. Building a web application using React for the frontend and Django for the backend, the communication between the two involves several components, including Axios for handling HTTP requests, URLs for routing, serializers for data conversion, and views for handling requests on the Django side. Here's a high-level overview of how these components interact:

React Frontend

React is a JavaScript library for building user interfaces, and it typically runs in the browser. In the context of a web application, React is responsible for creating the user interface components, handling user interactions, and managing the application state.

Axios for HTTP Requests

Axios is a popular JavaScript library for making HTTP requests from the browser. In a React application, Axios is commonly used to send requests to the Django backend to fetch or send data. Perfect for our React app to communicate with the Django backend.

URLs for Routing

In Django, the urls.py file is used to define URL patterns and their corresponding views. These URL patterns determine how requests are routed to different views within the Django backend.

from django.urls import path
from . import views

urlpatterns = [
    path('list/', views.read_all_data, name='read_data'),
    # Other URL Patterns
]

This is an example of urls.py in Django

Serializers for Data Conversion

Serializers in Django are used to convert complex data types (e.g., Django models) to native Python data types, and vice versa.
They are particularly useful when sending data between the frontend and backend in JSON format.

from rest_framework import serializers
from .models import MyModel

class MyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = '__all__'

This is an example of serializers.py in Django

Database Interactions

Django models define the database structure, and ORM (Object-Relational Mapping) simplifies database operations.

from django.db import models

class MyModel(models.Model):
    # Define the model fields here

This is an example of models.py in Django

Views for Request Handling

Django views process incoming requests, interact with models and serializers, and return appropriate responses.

@api_view(['GET'])
def api_data_view(request):
    data = MyModel.objects.all()
    serializer = MyModelSerializer(data, many=True)
    return Response(serializer.data)

This is a code snippet example of views.py in Django

Fetching Data

Use Axios in a React component to fetch data from Django, where the backend interacts with the database.

const fetchData = async () => {
  try {
    const response = await axios.get('/list');
    console.log(response.data);
  } catch (error) {
    console.error('Error fetching data:', error);
  }
};

This is an example of using Axios in a React component

By seamlessly integrating React and Django, including Axios, URLs, serializers, views, and database interactions, we've built a robust web application following RESTful principles.

The database plays a pivotal role in storing and retrieving data, enhancing the overall functionality of our application.

Learning in Public: Hype, or Highway to Mastery?

Arindam Sahoo — Mon, 01 Jan 2024 10:21:00 +0000

Hey, fellow devs!

I recently stumbled upon this intriguing concept called "Learning in Public." The idea of openly sharing one's learning journey – the stumbles, the "aha!" moments, the messy in-between – sparked a fire in a coding soul. Let's dissect this together.

What is it?

By Learning in Public, I don't mean live coding on Twitch under flashing neon lights. It's about the conscious choice to document and share our learning process, be it through blog posts, tutorials, Twitter threads, or even just good old whiteboard discussions with our buddies.

Advantages? Does it really help?

Supercharged Learning: Putting your thoughts out there forces you to articulate and solidify your understanding. Plus, feedback and discussions can turn your "meh" understanding into a "pro" masterpiece.
Community Connection: You become a beacon for fellow learners, attracting kindred spirits and building a support network that makes the coding journey less lonely.
Personal Growth: Owning your learning journey builds confidence, fosters accountability, and makes you a self-reflective learning machine.

Now, the million-dollar question: Who needs this more?

Beginners: Absolutely! Sharing your struggles can resonate with newbies, create a safe space for asking "silly" questions, and show them they're not alone in the coding trenches.
Pros: Don't dismiss it! Seasoned vets can offer a unique perspective, break down complex concepts for noobs, and even rediscover the joy of learning through fresh eyes.
But wait, there's a twist!

Is Learning in Public just a marketing ploy? A desperate plea for likes and followers? Maybe for some. But at its core, it's about connection, growth, and sharing the love of learning. Remember, the code community thrives on collaboration and open knowledge. This is just another way to keep that fire burning.

So, what do you think? Is Learning in Public a thing for us? Share your experiences, doubts, or favorite platforms in the comments below! Let's keep this conversation alive.

I'm curious to hear about your favorite resources or platforms for learning in public!