DEV Community: Yulei Chen

Vibe Hosting with Cursor

Yulei Chen — Tue, 03 Feb 2026 14:40:00 +0000

What if you could list your services, inspect service logs, and even fix failed deployments without leaving Cursor? That’s vibe hosting: you stay in the flow, and your AI assistant talks to Sliplane for you via the Sliplane MCP server. Deploy from chat, read logs in chat, and say “fix it” when a build fails. This post walks you through setup and a short showcase so you can try it yourself.

Prerequisites

Before installing the Sliplane MCP server in Cursor, have:

A Sliplane account (start free trial if you don’t have one).
Your API key and Organization ID from your Team. You’ll paste these into Cursor later.

Installation

Click the button below to add the Sliplane MCP server to Cursor.

Add to Cursor

Cursor will open the install flow and open the configuration page for you. All you need to do is to paste your API key and Organization ID.

Showcase

Here’s a simplified use case from a Git repo to deploying on Sliplane and debugging a failed build with Cursor and the Sliplane MCP server.

Warning: LLMs can make mistakes. Always double-check what the agent is doing and verify the plan before approving any actions.

Step 1: Prepare the repo

For this example we use a small Git repo sliplane-mcp-demo with a minimal Docker static deployment.

Dockerfile – builds a tiny static site and serves it (e.g. with a minimal web server).

FROM nginx:alpine
COPY index.html /usr/share/nginx/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

index.html – a single page that displays “Hello Sliplane” centered on the screen.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Hello Sliplane</title>
    <!-- CSS is omitted here -->
</head>
<body>
    <h1>Hello Sliplane</h1>
</body>
</html>

That’s it: two files, one container, one page.

Step 2: Deploy the repo on Sliplane

Open container.new.
Select project → Select server → Add service → Repository.
Choose your repo. In our example it's sliplane-mcp-demo. Noted that you may need to configure repo access for the first time.
Add service and then Deploy. Wait until the service is running.

Step 3: List services in Cursor chat

In Cursor, open chat and ask something like: “List my Sliplane services”. The model will use the MCP server to call the Sliplane API and show your services.

Step 4: Introduce a typo

In your repo:

In the Dockerfile, change the line that references index.html to indexl.html (typo).

FROM nginx:alpine
- COPY index.html /usr/share/nginx/html/ 
+ COPY indexl.html /usr/share/nginx/html/  
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Commit and push the change.

The next build will fail because the file doesn’t exist.

Step 5: Fix in Cursor chat

In Cursor chat, ask like: "Show me the logs for the service sliplane-mcp-demo.” The model will fetch the latest logs and report that the build failed. Then, in the same conversation, say: “Fix it.” The model should correct the Dockerfile back to index.html. Again, commit and push your change. Checkout the log, you will find everything works now.

Vibe hosting is exactly this: your services and deployments stay on Sliplane, and Cursor + the Sliplane MCP server give you a single place to check services, read logs, and iterate on fixes. The example above focused on listing services and debugging failed builds from logs, but that’s only the beginning. With the Sliplane MCP server, you can also:

Create new services, e.g. “Add a new service from this repo to my project”.
Deploy databases, e.g. “Deploy a Postgres service”.
Deploy AI workflow automation, e.g "Deploy n8n to my project".
Inspect events, domains, volumes, and settings without leaving Cursor.

... and more. Enjoy and have fun with vibe hosting!

5 Awesome Ways to Deploy Flowise

Yulei Chen — Sat, 17 Jan 2026 13:38:14 +0000

Flowise is a powerful open-source platform for building AI agents visually. Choosing the right deployment method depends on your needs for complexity, cost, and control. Here are five ways to deploy Flowise, from one-click solutions to enterprise setups.

Quick Comparison

Method	Complexity	Base Price (2026)	Customizability	Best For
Sliplane	⭐ Very Easy	€9 per month per server	⭐⭐⭐ Good	Quick deployment, production-ready
Hetzner VPS	⭐⭐⭐ Moderate	€3.49 per month for 2 vCPU	⭐⭐⭐⭐⭐ Full	Cost-conscious, full control
Local Docker	⭐⭐ Easy	Free	⭐⭐⭐⭐ High	Development, testing
Kubernetes	⭐⭐⭐⭐⭐ Very Complex	Variable	⭐⭐⭐⭐⭐ Full	Enterprise, large scale
Flowise Cloud	⭐ Very Easy	Free for 2 flows, then $35 per month	⭐⭐ Limited	Zero maintenance

1. Sliplane: The Easy Production Way

Sliplane is a Container-as-a-Service platform that makes deploying Flowise simple. One-click deployment, automatic SSL, and zero server management.

Complexity: ⭐ Very Easy - Deploy in seconds via container.new/flowise. No Docker Compose or server config needed. For detailed instructions, see our guide to deploying Flowise with Sliplane.

Base price: €9/month - Pay per server, deploy unlimited containers. Run Flowise with databases, APIs, and workers on the same server.

Customizability: ⭐⭐⭐ Good - Full control over environment variables, container config, resource limits, custom domains, and volume mounts.

Best for: Production-ready deployment without DevOps overhead, running multiple services cost-effectively.

2. Hetzner VPS: The DIY Approach

Deploying Flowise on a Hetzner VPS gives you complete control at a low cost. You manage everything yourself, from server setup to security updates.

Complexity: ⭐⭐⭐ Moderate - Requires provisioning a server, installing Docker, setting up reverse proxy for SSL, and configuring backups. See our detailed guide for step-by-step instructions.

Base price: Hetzner offers excellent VPS prices in Europe, starting from €3.49/month for 2 vCPU.

Customizability: ⭐⭐⭐⭐⭐ Full - Complete control over OS, software, networking, firewall, and monitoring. Run multiple services on one server.

Best for: Cost-conscious developers who want full control and enjoy managing infrastructure.

3. Local Docker: Development & Testing

Running Flowise locally with Docker is perfect for development, testing, and learning. It's free and requires minimal setup.

Complexity: ⭐⭐ Easy - Install Docker Desktop, create a Docker Compose file, and run the container. See our guide for detailed instructions.

Base price: Free - Uses your own hardware, no hosting fees.

Customizability: ⭐⭐⭐⭐ High - Modify Docker Compose, mount volumes, set environment variables, test different versions. Limited by local machine resources.

Best for: Development, testing, learning, and experimentation without public access.

4. Kubernetes: Enterprise Scale

Deploying Flowise on Kubernetes offers unmatched scalability for large-scale deployments, but it's the most complex option. As we've written before, Kubernetes isn't for everyone.

Complexity: ⭐⭐⭐⭐⭐ Very Complex - Requires cluster setup, Pod/Service/Ingress configuration, persistent volumes, monitoring, and security policies. You'll also need Ingress controllers, SSL certificates, and more. See Docker vs Kubernetes for when it makes sense.

Base price: Variable - Depends on cloud provider (AWS EKS, Google GKE, Azure AKS), cluster size, load balancers, and storage.

Customizability: ⭐⭐⭐⭐⭐ Full - Auto-scaling, multi-region deployments, advanced networking, fine-grained resource management.

Best for: Enterprise deployments with dedicated DevOps teams, running hundreds of services, or specific scaling requirements.

Reality check: Most teams don't need Kubernetes. It was built for Google-scale problems. If you're running a few services, simpler options like Sliplane or a VPS are usually better choices.

5. Flowise Cloud: Zero Maintenance

Flowise Cloud is the official managed service where everything is handled for you. It's the easiest option but comes with higher costs and less customization.

Complexity: ⭐ Very Easy - Sign up and start building. No setup, configuration, or maintenance required.

Base price: Free tier includes 2 flows. Paid plans start from $35/month. Check Flowise pricing for current rates.

Customizability: ⭐⭐ Limited - Standard configurations only, no server-level access, limited environment variable control. Can't modify infrastructure or install custom software.

Best for: Zero maintenance, official support, guaranteed uptime and SLAs, managed service preference.

Detailed Comparison

Feature	Sliplane	Hetzner VPS	Local Docker	Kubernetes	Flowise Cloud
Setup Time	seconds	hours	minutes	days/weeks	seconds
Base Price (2026)	€9/month	€3.49/month for 2 vCPU	Free	Variable	Free for 2 flows, then $35+/month
Complexity	Very Easy	Moderate	Easy	Very Complex	Very Easy
Maintenance	None	High	Low	Very High	None
Customizability	Good	Full	High	Full	Limited
Scalability	Server limits	Manual	Local only	Auto-scaling	Managed
SSL/HTTPS	Automatic	Manual setup	N/A	Manual setup	Automatic
Backups	Automatic	Manual setup	Manual	Manual setup	Managed
Public Access	Yes	Yes (with setup)	No	Yes	Yes
Best For	Production, quick deploy	Cost-conscious, full control	Development, testing	Enterprise scale	Zero maintenance
Technical Skills	Beginner	Intermediate	Beginner	Expert	None

Which Option Should You Choose?

Sliplane - Best balance of simplicity, cost, and production-readiness. Perfect for startups and small teams.

Hetzner VPS - Lowest cost with full control. Great for cost-conscious developers who enjoy managing infrastructure.

Local Docker - Free option for development, testing, and learning. No public access needed.

Kubernetes - Enterprise-scale infrastructure. Only consider if you have a DevOps team and simpler options can't meet your needs.

Flowise Cloud - Zero maintenance with official support. Premium pricing for managed service.

For most users, Sliplane offers the sweet spot: production-ready deployment in minutes with predictable pricing and enough flexibility.

START YOUR FREE TRIAL NOW!

FAQ

Q: Can I migrate between deployment methods?
A: Yes! Flowise data is stored in a database, so you can export and import workflows between different methods.

Q: Which option is most cost-effective for multiple services?
A: Sliplane's server-based pricing (€9/month for unlimited containers) is usually the most cost-effective managed option. A Hetzner VPS (starting from €3.49/month) can be cheaper if you manage it yourself.

Q: Do I need Kubernetes for production?
A: No. Most production deployments work fine with Sliplane or a VPS. Kubernetes is only necessary for auto-scaling across multiple regions or running hundreds of services.

Q: Can I start locally and deploy to production later?
A: Absolutely! Start with local Docker for development, then deploy to Sliplane or a VPS when ready. If you hit real scale, you can use Kubernetes. Docker Compose configuration is similar across environments.

Q: What about security and backups?
A: Sliplane handles SSL, security updates, and backups automatically. With a VPS, you set these up yourself. Flowise Cloud includes managed backups and security.

Self-hosting Flowise on a Hetzner Ubuntu Server

Yulei Chen — Fri, 16 Jan 2026 18:41:06 +0000

Want to build AI agents using Flowise but prefer to fully control your infrastructure? By self-hosting Flowise on a Ubuntu server, you can cut down costs and manage your data yourself!

Looking for something simpler? If you'd rather skip server management and deploy Flowise in just 1 minute for €9/month, check out our guide on how to deploy Flowise using Sliplane.

Follow along this easy-to-understand guide to learn how you can deploy your own Flowise instance using Docker and Caddy Web server for automatic HTTPS.

For this post, we're using an affordable server from Hetzner. Hetzner is known to provide great service at an exceptional price/performance ratio, making it an excellent choice for hosting AI applications like Flowise.

Prerequisites

Before we start, make sure you have a Hetzner Cloud account (or be ready to create one).

Step 1: Setup Your Hetzner Server

If you don't have a Hetzner server yet, follow these steps to create one (the video tutorial is attached below):

Go to the Hetzner Cloud Console, choose a project or create a new one, then navigate to Servers → Add Server
Follow Hetzner's guidelines to choose:
- Server type: Select a server type that fits your needs.
- Location: Choose a data center location closest to you or your users.
- Image: Select Ubuntu (latest LTS version recommended).
Add SSH key: Add your SSH public key for secure access. If you don't have an SSH key yet, you can generate one using ssh-keygen:
```
ssh-keygen -t ed25519 -C "your_email@example.com"
```
Click Create & Pay to provision your server

Once your server is created, note down its IP address. You'll use this to connect via SSH in the next step.

Step 2: Update Your Server

Open your terminal and log into your Ubuntu server via SSH:

ssh root@[your-IP-address]

and update the system to ensure it has the latest security patches and updates:

sudo apt-get update
sudo apt-get upgrade -y

Once finished, your server is ready for installing the software.

Step 3: Install and Configure UFW Firewall

Only keep necessary ports open: SSH (22), HTTP (80), HTTPS (443).

Install UFW and configure the firewall as follows:

sudo apt install ufw -y
sudo ufw allow 22    # SSH
sudo ufw allow 80    # HTTP
sudo ufw allow 443   # HTTPS
sudo ufw enable

Check your firewall configuration:

sudo ufw status verbose

Note: Docker can sometimes ignore UFW rules. To tackle this, verify extra settings as explained here.

Step 4: Docker Installation

Docker will be the container system running Flowise. Install Docker by running these commands:

Setup dependencies and Docker's GPG key:

sudo apt-get update
sudo apt-get install ca-certificates curl gnupg

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
| sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

Add Docker repository:

echo \
  "deb [arch=$(dpkg --print-architecture) \
signed-by=/etc/apt/keyrings/docker.gpg] \
https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo $VERSION_CODENAME) stable" \
| sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt-get update

Install Docker Engine and compose-plugin:

sudo apt-get install docker-ce docker-ce-cli \
containerd.io docker-buildx-plugin docker-compose-plugin -y

Check installation:

sudo docker run hello-world

If you see the "hello-world" message, Docker is ready.

Step 5: Installing Caddy for Automatic HTTPS

Caddy simplifies HTTPS configuration since it handles SSL certificates automatically from Let's Encrypt.

Install Caddy:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' \
| sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' \
| sudo tee /etc/apt/sources.list.d/caddy-stable.list

sudo apt update
sudo apt install caddy -y

Before configuring Caddy, you need to point your domain to your server's IP address. If you haven't configured DNS yet, follow these steps:

Configure DNS for Your Domain

Log into your domain registrar's dashboard (where you purchased your domain)
Navigate to the DNS settings or DNS management section
Add an A record with the following settings:
- Type: A
- Name: @ (for root domain) or a subdomain like flowise (for flowise.yourdomain.com)
- Value/Target: Your Hetzner server's IPv4 address
Add an AAAA record for IPv6 support:
- Type: AAAA
- Name: @ (for root domain) or the same subdomain you used for the A record
- Value/Target: Your Hetzner server's IPv6 address

Note: DNS changes can take a few minutes to several hours to propagate. You can check if your DNS is configured correctly using tools like dig or online DNS checkers. Once the DNS record is active, you can proceed with Caddy configuration.

Configure Caddy

Edit the Caddyfile configuration file:

sudo nano /etc/caddy/Caddyfile

Enter your domain and configure reverse proxy. Replace "yourdomain.com" with your actual domain name:

yourdomain.com {
    reverse_proxy localhost:3000
}

If no domain yet, use this temporarily:

:80 {
    reverse_proxy localhost:3000
}

Restart Caddy to load the config:

sudo systemctl restart caddy

Step 6: Running Flowise with Docker Compose

We're going to use Docker Compose for easier setup. First create a directory for Flowise and navigate to it:

mkdir ~/flowise
cd ~/flowise

Create compose.yml with the following content:

services:
  flowise:
    image: flowiseai/flowise:3.0.12
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - flowise_data:/root/.flowise
    environment:
      - DATABASE_PATH=/root/.flowise
      - SECRETKEY_PATH=/root/.flowise
      - LOG_PATH=/root/.flowise/logs
      - BLOB_STORAGE_PATH=/root/.flowise/storage

volumes:
  flowise_data:

This setup ensures:

Your database persists across container restarts
Secrets don't reset
Logs and file uploads are kept between restarts

Now deploy Flowise by running Docker compose:

sudo docker compose up -d

Docker pulls the Flowise image and runs it in background mode using port 3000.

Step 7: Accessing Your Self-Hosted Flowise Instance

Visit your domain in any web browser. Your Flowise instance should now load successfully at https://yourdomain.com. Follow the setup steps in the interface to complete your initial setup.

Security Recommendations

Public servers should always be secure. The following practises are recommended:

Regularly apply updates and security patches.
Set strong passwords and control user access.
Monitor server logs for suspicious activity.
Install tools like Fail2ban for extra security.

Updating your Flowise Installation

When you want to update your Flowise instance, first check the latest version on Docker Hub, then update the image version in your compose.yml file and run:

sudo docker compose pull
sudo docker compose up -d

Docker will download updated versions automatically and replace your current containers.

Cost Comparison with Other Providers

Self-hosting Flowise typically results in lower cost compared to hosted services:

Provider	vCPU	RAM	Disk	Monthly Cost
Render.com	1	2 GB	40 GB	~$35
Fly.io	2	2 GB	40 GB	~$17–20
Railway	2	2 GB	40 GB	~$15–30
Sliplane.io	2	2 GB	40 GB	~€9.50 flat
Hetzner Cloud (self-hosted)	2	2 GB	40 GB	~€5–10/month

You maintain complete control and avoid additional usage-based charges by self-hosting. But of course there is no free lunch and you're now responsible for managing your own server!

Deploy Flowise in minutes with Sliplane now!

How to Deploy Flowise

Yulei Chen — Fri, 09 Jan 2026 16:57:18 +0000

Flowise is a powerful open-source platform that enables you to build AI agents visually. Depending on your infrastructure and usage requirements, Flowise can be deployed in multiple ways. This guide will introduce two ways to deploy Flowise:

Locally, using Docker Compose
In the cloud, using Sliplane (the easy / production-ready way)

If you want to try Flowise on your machine, go local. If you need a public URL with less setup, skip to the cloud section.

Deploy locally

In this section, we’ll deploy Flowise locally with Docker Compose. We’ll provide a minimal, working compose file and walk through a few common Docker Compose commands. By the end, you’ll have a running local setup.

Prerequisites

Before we get started, make sure you have Docker Desktop installed and running.

Step 1: Create the Docker Compose file

Create a file named compose.yml, then copy the following code into your file:

services:
    flowise:
        image: flowiseai/flowise:3.0.12
        ports:
            - 3000:3000

This is the minimum setup needed to get Flowise running.

Step 2: Start the service

Run the following command in the same directory as your compose.yml:

docker compose up -d

The -d indicates that the service is running in the background, so if you want to check if it's running:

docker compose ps

You should see the flowise service marked as Up, then you can open your browser and go to http://localhost:3000.

Logs can be checked with:

docker compose logs -f

The -f flag streams the logs in real time, just like tail -f, so you can watch new log output as it happens.

To stop and remove the service:

docker compose down

Further steps (recommended)

By default, Flowise stores data inside the container. This means all data will be lost if the container is removed. To persist data across deploys and restarts, mount a volume and set the required environment variables:

services:
    flowise:
        image: flowiseai/flowise:3.0.12
        ports:
            - 3000:3000
        volumes:
            - ~/.flowise:/root/.flowise
        environment:
            - DATABASE_PATH=/root/.flowise
            - SECRETKEY_PATH=/root/.flowise
            - LOG_PATH=/root/.flowise/logs
            - BLOB_STORAGE_PATH=/root/.flowise/storage

This setup ensures:

Your database persists
Secrets don’t reset
Logs and file uploads are kept between restarts

Deploy with Sliplane

Sliplane is a fully managed Container-as-a-Service platform that makes hosting Docker containers ridiculously simple.

Sliplane supports one-click deployment for Flowise. All you need to do is:

Go to container.new/flowise
Select a project
Select a server
Click Deploy!

The deployment will start immediately and you’ll be redirected to your project page, where you can see the deployment status.

Once it changes to "Successful", you can visit the domain

and your Flowise is right there! 🎉

Deploy Flowise in Seconds with Sliplane Now!

Further steps

From the Sliplane project settings,

you can:

Add, remove, or edit environment variables
Add healthchecks
View container logs

... and more.

FAQ

Q: Is Flowise free?
A: Flowise is open-source and free to self-host. If you self-host Flowise on Sliplane, there is no Flowise license cost.

Q: What is Sliplane pricing like?
A: Sliplane uses simple, server-based pricing. You pay for the server you run, and you can deploy unlimited containers on that server at no extra cost. The monthly cost of Sliplane is €9. You can try Sliplane for free for 2 days.

Q: What is the difference between Flowise and n8n?
A: Flowise is AI-first and designed for building LLM-based apps like chatbots and agents, while n8n is a general-purpose automation tool focused on integrating services and orchestrating workflows. By the way, just like Flowise, n8n can also be deployed seamlessly on Sliplane. Check out here to deploy your n8n workflows with Sliplane preset in just 1 click.

[Boost]

Yulei Chen — Fri, 09 Jan 2026 12:42:53 +0000

Tech Stack Lessons from scaling 20x in a year

Jonas Scholz ・ Jan 9

#webdev #docker #devops #startup

Data structures and algorithms

Yulei Chen — Thu, 15 May 2025 17:24:59 +0000

When I learn some stuff in computer science, e.g. lexers, I always have this kind of feeling that it's easy to build it in my mind but I don't know where to start when I'm about to implement it.

I asked myself a series of questions,

"Why I can't implement it?",
"Is there any certain way to think about it?",
"How can I think in the way computers think when facing a problem?",
"What's the input of a problem, and how to present the input?",
"Ahh! Data structures are the understandable data source?",
"Then how to deal with the logic and interaction between data structures?"
"Algorithms!!???",
"Jesus, why I realized this after almost 8 years from the first time I learned data structures and algorithms"

See, this is another example of THINK INSIDE.

Twilight

Yulei Chen — Sun, 04 May 2025 18:02:34 +0000

There’s a word in Chinese called “西晒“ which means the strong west-facing sunlight in the afternoon. The window of my room is directly facing west, so it has “西晒“ and it’s extremely hot in the summer afternoons. But after the “西晒“, here comes the stunning twilight—a sky fading from deep blue to orange-red, with a crescent moon hanging above—I’m obsessed with. So, don’t get upset by your current obstacle, because the next second you will probably see the twilight.

Digital minimalism

Yulei Chen — Sat, 26 Apr 2025 19:42:10 +0000

For a long period of time, I was used to buying stuff online. But after moving to Germany, I sort of get used to buying stuff offline. Online shopping is obviously more convenient, but offline shopping makes me feel ALIVE.

Another thing I realized after I moved to Germany is that I can live without phone, because digital payment is not a must and paper menu is still common.

It's high time to reduce screen time and practice digital minimalism now. I do the following things:

Make my phone dumb

Buy a lovely notebook
Keep the laptop in the bag in class

Life is fragments

Yulei Chen — Thu, 24 Apr 2025 16:22:24 +0000

I used to learn all the things in a linear way. “You must read the first 2 chapters until you start the third chapter”, I always said to myself. However, it turned out I always gave it up in the second chapter, because my original curiosity can’t support me to finish the first 2 chapters.

One day it came to me that I could directly read the third chapter! I can even skip, jump, repeat and go back, as long as I can connect the relationship between knowledge.

Jeanette Winterson said in her book, Why Be Happy When You Could Be Normal, that

Life is layers, fluid, unfixed, fragments. I never could write a story with a beginning, a middle and an end in the usual way because it felt untrue to me. That is why I write as I do and how I write as I do. It isn’t really an ethos; it’s me.

Mental model and intuition

Yulei Chen — Tue, 22 Apr 2025 15:49:07 +0000

I'm learning Python.

The first thing I want to learn is to build the mental model. Naomi Ceder gives me the inspiration from her blog Notes on Teaching Python — Mental Models. We’re standing one the shoulder of giants and I really appreciate it. With her words and my understanding, Python’s mental model is pretty similar to JavaScript’s. In Python world, there’re immutable and mutable values and we can use wires/labels to connect them with variables, and the counterparts in JavaScript are respectively primitive and object.

Today, while I was reading Neural Networks and Deep Learning by Michael Nielsen, I felt another enlightening and charming wording as mental model is “neural networks intuition“ which just suddenly erased all the cloud in front of me.

The importance of mental models

Yulei Chen — Mon, 21 Apr 2025 09:08:04 +0000

I worked as a JavaScript developer for 3 years. However, I didn’t know what a mental model of JavaScript meant during the first 2 years until I read Dan Abramov’s book Just JavaScript, where I realized how important it is to build a correct mental model.

For example, how do you understand variable? Consider the following mindless code:

const a = { one: 1 }
const b = a
a.one = 2
console.log(b)

People with container/bucket model may say b is { one: 1 } , but people with wire/label model can give { one: 2 } without any hesitation.

Mental model is not about how something is implemented under the hood. It’s all about thinking inside, which is why I didn’t say “people with reference model”.

Next blog I will share how I build my mental model as a Python beginner.

I will write a tiny blog every day for 3 weeks

Yulei Chen — Sun, 20 Apr 2025 18:09:30 +0000

Inspired by cbvivi’s blog which introduces Tiny Experiments, I decide to start my first tiny experiment—write a tiny blog every day for 3 weeks, and this blog itself is the first one of them.

Just as the name is, this is an experiment instead of a habit or a goal, in which I allow myself dislike it and never do it again after 3 weeks. Also, this is a TINY experiment, which means I take not much time to finish it.

I will not use any LLM to help me correct my grammar mistakes or polish my tiny article. This experiment is all about done or failed, instead of being correct or perfect.

Just do it.