DEV Community: elysianx

Raw Pointers VS Smart Pointers, Which One Should Beginners Learn First

elysianx — Tue, 28 Jul 2026 14:04:24 +0000

These days, I've been learning C++ and have posted some articles about it. Since I started to learn C++ with raw pointers, I naturally hit some common questions: new/delete, manual memory manage, and so on.C++ Traps That Caught Me Off Guard — A Beginner's Log - Coder Legion

A few days ago, I discussed this topic with some C++ developers. As far as I'm concerned, I believe that raw pointers are fundamental and it's necessary for beginners to build a mental model of RAII and memory management before moving to smart pointers.

On the other hand, some developers think that raw pointers are not a suitable topic for beginners - we have the safer and more modern smart pointers to manage, so why not start with them directly?

Actually, it's up for debate whether beginners should learn these constructs. From my own experience learning C++ through raw pointers, I believe beginners can benefit from a moderate understanding of them.

As for performance, there's no absolute winner. Smart pointers are safer and work well for most scenarios, especially when code maintainability matters. Raw pointers still have their place in performance-critical or low-level contexts. The key is knowing both and choosing wisely.

Which one would you learn first if you are a beginner? And why?

A Letter to My Younger Self -- 4 Years Later, Are you Catching Your Time

elysianx — Sat, 25 Jul 2026 14:44:57 +0000

Hi👋I'm Elias, this's a letter to every university student who is still learning or feeling confused about the future.

Most people waste their youth, not because they are stupid and lazy, but because no one tells them how valuable these moments are.
They always think that they are young and have plenty of time, that their life hasn't started yet. But the truth is : this is your life. The importance of these years is way beyond what you can imagine.

Unfortunately, by the time someone realizes that, it's already too late. When people talk about not wasting your youth, some may think you're telling them to become a ruthless machine.
Actually, that's not what I mean. what I really want to express is: direction.

Most young people's lives actually don't have a direction --- They wake up, watch videos, play games. By the time they're 23 or 24, they will realize the youth has been wasted and wonder where all the time went.

Let me do the math for you:
If you spend one hour on learning a useful skill --- a language, a craft, a sport or diving into a business --- and you persist for one year, that's 365 hours.
If you persist for 4 years during your youth, that's over 1,500 hours.
You will do better than most people at anything. Not because you're a genius --- because you showed up.

You might say: "I want to learn a language, but I didn't follow my plan because I was hanging out with my friends or playing games." You feel sad. You regret. You call yourself a loser.
Don't worry. Planning is one thing, sticking to it is another. That's okay.

Actually, everyone needs to relax themselves. It's okay
to watch videos and play games.
The real problem is when they become Your whole life.

One day, you'll wake up and realize those years are gone. You'll ask yourself:
Did I waste it, or did I catch it?

There is an old saying in my country:
**花有重开日, 人无再少年* --- Flowers may bloom again, but youth never returns.*

The answer is being written right now --- by the choice you make today.

C++ Traps That Caught Me Off Guard — A Beginner's Log

elysianx — Thu, 23 Jul 2026 09:11:34 +0000

Learning C++ has been a journey full of traps. Here are three I hit — hope they save you some debugging time.

🎣 Trap 1: `new[]` + `delete`(instead of `delete[]`)

Wrong Code

 int* a = new int[3];

 // delete a; ❌ --> undefined

class MyClass{
public:
    ~MyClass(){
        std::cout<<"delete successfully"<<std::endl;
    }
}
int main(){
    MyClass* mc = new MyClass[2];
    //delete mc;  ❌ -> only outputs one "delete successfully"

What Happens

C++ standard clearly states that this is undefined behavior. Relying on it is extremely dangerous — different compilers, optimization levels, and platforms may behave completely differently.

new[] + delete only calls the destructor once, while delete[] calls it for every element in the array. Using delete instead of delete[] causes resource leaks for the remaining elements.

How to Fix

 int* a = new int[3];

 delete[] a;  -> ✔

class MyClass{
public:
    ~MyClass(){
        std::cout<<"delete sucessfully"<<std::endl;
    }
};
int main(){
    MyClass* mc = new MyClass[2];
    delete[] mc; -> ✔ outputs "delete successfully" twice
}

🎣 Trap 2: `cin` + `getline` eating your input

Wrong Code

int age;
std::string name;

std::cout<<"Enter age: ";
std::cin>>age;

std::cout<<"Enter name: ";
std::getline(cin, name); // ❌ name ends up empty!

std::cout<<name<<std::endl;

What Happens

cin leaves a newline character (\n) in the input buffer, and getline reads it immediately — so it stops before you even type anything.

Why

cin >> reads the value you type but leaves \n in the buffer. getline stops reading when it encounters \n, so it grabs that leftover newline and returns an empty string.

How to Fix

std::cin >> age;
cin.ignore();    // 👈 Eat the leftover newline
std::getline(cin, name);

🎣 Trap 3: `Copy constructor` vs `copy assignment`

class FixArray{
    std::string name_;
    int* data_;
    size_t size_;
public:
    ~FixArray(){
        delete[] data_;
    }

    FixArray(const FixArray& other) : FixArray(other.size_, other.name_){
        std::copy(other.data_, other.data_ + size_, data_);
    }

    FixArray& operator=(const FixArray& other){
        if(this != &other){
            int* new_data = new int[other.size_];
            std::copy(other.data_, other.data_ + other.size_, new_data);
            delete[] data_;
            data_ = new_data;
            size_ = other.size_;
            name_ = other.name_;
        }
        return *this;
    } 
};

Many beginners can't tell the difference between a copy constructor and a copy assignment. Actually, it's quite simple:

// Copy constructor: creating a new object from an existing one
FixArray fa(10, "example");
FixArray fb = fa;    // 👈 copy constructor called

// Copy assignment: assigning to an already-existing object
FixArray fc(5, "other");
fc = fa;            // 👈 copy assignment called

Copy constructor — creates a brand new object as a copy of an existing one.

Copy assignment — replaces the contents of an already-existing object with another object's data.

The key difference: copy constructor builds something from nothing; copy assignment replaces something that already exists.

These are three traps I hit while learning C++. If you're a beginner too, I hope this saves you some debugging time. Have you encountered other tricky C++ traps? Share them below!

Still holding on? A letter to those who chose the unconventional path

elysianx — Tue, 21 Jul 2026 14:10:36 +0000

Have you ever felt like you're running a race you never signed up for?

Yeah, I have. Actually, everyone around me feels the same way.

"Involution" is so common in my country that you don't have the power to choose your own life. Everyone's life seems to be planned (your only task is learning to get higher scores when you were a child). You might think you're free when you're a university student. Yeah, I thought so too. But unfortunately, society expects you to study hard so you can get an easier job or go to a more prestigious university. When you become an adult, you have to endure "996"—go to work at 9 am, go home at 9 pm, six days a week. Or "PUA"—a common workplace tactic where managers constantly criticize and gaslight you.

Have you ever been told you're "not doing proper work"?

You will be told you're "not doing proper work" if you go against society.

During my college years, I tried to solve some problems I noticed. I built a website to collect practice problems and learning resources — hoping to help students who wanted to learn something new but couldn't find suitable materials. But I failed. I kept asking myself: should I persist? Is it right?

"Why not study hard and find a good job?", "Your classmates study so hard." Sometimes I ask myself: am I being irresponsible to myself by choosing a different way?

I still remember that time in university when I first built and released my first product. It failed.

To be honest, that experience taught me something unforgettable. As developers, we always dive into the mud, chasing bleeding-edge technology while ignoring how users feel. Though others laughed at me, I took away one key lesson from that failure — "Technology is not supreme, but rather serves people." That's a lesson I still carry with me today.

Even though everyone — or society — tries to persuade me to give up, I will never, never give up, until the day I die. If I could start over, I would still choose this path.

Do you have a similar experience? Would you still choose a different path if you had a chance to restart?

How to Start Docker for Beginners

elysianx — Fri, 03 Jul 2026 14:00:38 +0000

What's Docker

Docker is a containerization platform that packages applications with all dependencies into portable utils called containers.

Learn the foundational concepts of `Docker`

Core concepts:

Image: A read-only blueprint containing app code,libraries,and environment settings.
Container: A running instance of an image.
Dockerfile: Script defining how to build an image.
Volume: Persistent storage outside the container lifecycle.
Network: Enables communication between containers.

Example: Building and Running a Container

FROM node:18
WORKDIR /app
COPY package.json ./
RUN npm install
COPY .
EXPOSE 3000
CMD ["npm", "start"]

docker build -t my-node-app

docker run -p 3000:3000 my-node-app

Managing Multi-Container Apps with Docker Compose

version: '3'
services:
 app:
   build:
   ports:
     - "3000:3000"
   depends_on:
     - mongo
 mongo:
   image: mongo
   volumes:
     - mongo-data:/data/db
volumes:
 mongo-data:

RUN with:

docker-compose up

Best Practices

Use .dockerignore to exclude unnecessary files(e.g.,.git,node_modules).
Avoid :latest tags;pin versions for stability.
Run containers as non-root for security.
Use multi-stage builds to reduce image size.
Store secrets in .env files or Docker secrets, not in images.

When to Use Docker

[Y] Consistent dev/prod environments
[N] Small static sites or quick scripts where setup overhead outweighs benefits.

Next Steps

Learn Docker networking(bridge, host, overlay)for container communication.
Explore Docker volumes for persistent data.
Integrate Docker into CI/CD pipelines for automated builds and deployments.

With these fundamentals, you can confidently containerize, run, and manage applications in any environment.

How to Submit the First Formal PR for Beginners?

elysianx — Thu, 02 Jul 2026 13:39:35 +0000

After spending some time contributing to open source,I’ve realized the biggest hurdle for beginners isn’t finding a sustainable project-it’s submitting your first PR. If you’re also a beginner aiming to create your first PR, keep reading.

Step 1:Prepare

If you don't have git on your machine, install it.

Step 2:Fork this repository

Fork this repository by clicking on the fork button on the top of this page.
This will create a copy of this repository in your account.

Step 3:Clone the repository

Now clone the forked repository to your machine. Go to your GitHub account, open the forked repository, click on the code button, then on SSH tab and then click the copy url to clipboard icon.

Open a terminal and run the following git command:

git clone "url you just copied"

Step 4:Find a `good-first-issue`

Now search for an issue you like

Communicate with the maintainer about what you should do! Don't worry you can't do it well. You will be assigned, then work.

Step 5:Create a branch

Change to the repository directory on your computer

cd my-first-contributions

Make necessary changes and commit those changes

Open Contributors.md file in a text editor and issue,add your name to it.Save your file.

If you go to the project directory and execute the command git status, you'll see there are changes.

Add those changes to the branch you just created using the git add command:

git add Contributors.md

Now commit those changes using the git commit command:

git commit -m "Add your-name to Contributors list"

replacing your-name with your name.

Push changes to GitHub

Push your changes using the command git push:

git push -u origin your-branch-name

replacing your-branch-name with the name of the branch you created earlier.

Communicate with the maintainer about what to do. Don't worry if it's not perfect — they'll guide you. Get assigned, then get to work.

I Build a blog API with Redis - Here's every problem I Hit

elysianx — Tue, 23 Jun 2026 14:21:13 +0000

I build a blog API with FastAPI + Redis + MySQL.
Three cache problems almost killed my app.
If you also face these problems!
Here's how I fixed each one.

1. Cache Penetration

What's Cache Penetration?

Cache Penetration refers to a scenario where the requested data exists neither in cache nor in the database,causing every request to hit the database directly,thereby increasing the database load.

How to solve?

1.Caching null values

Steps:

When a queried key exists in neither the cache nor the database,the result (such as null or an empty value) is cached with a short TTL.
This way,subsequent identical requests can be served directly from the cache,avoiding frequent database access.

Example:

...
redis = get_redis()
data = redis.get(cache_key)

# First, check the cache. If the cache entry exists, check whether it is __NULL__
if data is not None:
    if data == "__NULL__":
        return {"data": None, "source": "cache"}
    return {"data": data, "source": "cache"}

# Second, cache miss, query database
value = query_database(cache_key)

# Third, cache the result whether it exists in DB or not
if value is not None:
    redis.setex(cache_key, 60, value)          # cache real data
else:
    redis.setex(cache_key, 10, "__NULL__")     # cache null sentinel (short TTL)

return value

2.Cache breakdown

What's Cache breakdown?

Cache breakdownoccurs when a popular data entry expires in the cache while a massive number of concurrent requests are hitting that same data at the exact same time.All those requests penetrate straight through to the database,putting enormous pressure on it and potentially causing system performance issues.

How to solve?

Lock mechanism:When the cache expires,use a locking mechanism to ensure that only one thread can access the database and update the cache.The other threads wait util the cache is rebuilt before reading the data.

Example:

# Generate a lock key based on the given key
lock_key = f"mutex:{key}"

# Use SETNX operation to acquire the lock. If the key does not exist, set it with an expiration time of 300 seconds.
# This prevents concurrent access.
lock_acquired = redis_client.set(lock_key, "1", nx=True, ex=300)

if lock_acquired:
    try:
        # Successfully acquired the lock, query the database
        value = db_query_func(key)
        if value is not None:
            # Write the result to the cache with an expiration time of 3600 seconds
            redis_client.setex(key, 3600, value)
        return value
    finally:
        # Release the lock
        redis_client.delete(lock_key)
else:
    # Failed to acquire the lock, sleep for 0.1 seconds and then retry
    time.sleep(0.1)
    return get_data_with_mutex(key, redis_client, db_query_func)

3.Cache avalanche

What's cache avalanche?

Cache avalancerefers to a situation where a large amount of cached data expires at the same time or the cache service goes down. As a result, all requests are directly sent to the database, causing a sudden surge in the database's pressure and even leading to its downtime.

How to solve?

Randomized TTL

The core idea is to avoid a large number of keys expiring simultaneously.
When setting the expiration time for the cache, add a random value.

Example:

import random

expire_time = time + random.randint(0,300)
redis.set(key,value,ex=expire_time)

What about you?

Have you run into any of these cache problems in your projects?
Or do you use a different strategy? Let me know in the comments 👇

If this was helpful, follow me for more backend deep dives.

DEV Community: elysianx

Raw Pointers VS Smart Pointers, Which One Should Beginners Learn First

A Letter to My Younger Self -- 4 Years Later, Are you Catching Your Time

C++ Traps That Caught Me Off Guard — A Beginner's Log

🎣 Trap 1: new[] + delete(instead of delete[])

Wrong Code

What Happens

How to Fix

🎣 Trap 2: cin + getline eating your input

Wrong Code

What Happens

Why

How to Fix

🎣 Trap 3: Copy constructor vs copy assignment

Still holding on? A letter to those who chose the unconventional path

How to Start Docker for Beginners

What's Docker

Learn the foundational concepts of Docker

Core concepts:

Example: Building and Running a Container

Managing Multi-Container Apps with Docker Compose

Best Practices

When to Use Docker

Next Steps

How to Submit the First Formal PR for Beginners?

Step 1:Prepare

If you don't have git on your machine, install it.

Step 2:Fork this repository

Step 3:Clone the repository

Step 4:Find a good-first-issue

Step 5:Create a branch

Make necessary changes and commit those changes

Push changes to GitHub

I Build a blog API with Redis - Here's every problem I Hit

1. Cache Penetration

What's Cache Penetration?

How to solve?

1.Caching null values

2.Cache breakdown

What's Cache breakdown?

How to solve?

3.Cache avalanche

What's cache avalanche?

How to solve?

What about you?

🎣 Trap 1: `new[]` + `delete`(instead of `delete[]`)

🎣 Trap 2: `cin` + `getline` eating your input

🎣 Trap 3: `Copy constructor` vs `copy assignment`

Learn the foundational concepts of `Docker`

Step 4:Find a `good-first-issue`