Developing on Solana：From Native to Anchor

If you are also an Ethereum developer like me, you must have been as confused as I was when trying to develop on Solana. Solana is so different and unique. In this post, I will show you a well-designed roadmap that will guide you to start developing on Solana as quickly as possible.

Before getting started, I assume that you already have some basic knowledge about Solana, including its account model and program system, as well as a basic understanding of the Rust programming language. It’s totally fine if you’re not deeply familiar with these topics, basic knowledge is sufficient for this post.

Moreover, I assume that you are using a Linux system and have already installed rust, solana-cli, node.js and anchor. If you are a Windows user, I highly recommend using WSL2, as anchor does not provide good support for Windows.

A Ethereum Developer's View on Solana

I started developing on the Ethereum platform in 2017, and I have to say that Solidity was an extraordinary design for its time. Its simple syntax makes it easy to learn, and tools like Remix simplify testing and deployment. For more complex projects, frameworks like Truffle and Hardhat can satisfy your requirements. However, Solidity is far from perfect. The challenges of upgradeability and its limited processing capability make Solidity less suitable for large-scale projects.

I started learning Solana development in 2023. Solana has a completely different design compared to Ethereum. It has been quite a challenging journey for an Ethereum developer to learn Solana. In this post, we will discuss the most significant differences between Ethereum and Solana: the account model, the program system, and the token program.

C++20 Big Four: Range

This article concludes the “Big Four” series of C++20. Many readers may wonder: what exactly is the “Ranges” feature that places it among the Big Four?

Initially, I had the same question. The first three features in C++20 were “revolutionary”: Modules transformed project organization, Coroutines redefined concurrency, and Concepts brought the biggest change to template programming since its inception. So, what makes Ranges deserving of the Big Four? It fundamentally changes the way we handle loops by providing a higher level of abstraction.

The Big Four of C++20: Concept

Preface: The Evolution of C++ Templates

The evolution of templates is a highly significant milestone in the history of C++ development. Personally, I believe that Concepts represent the most impactful feature along this trajectory. Before diving into the details of Concepts, let us first review the development of templates over time.

timeline
    title C++ Templates Evolution
    1979 : C with Classes - First Implementation
    1988 : First Formal Proposal of Templates
    1998 : Templates Enter the Standard (Function/Class Templates, SFINAE)
    2011 : C++11 Variadic Templates
    2014 : C++14 Variable Templates, Generic Lambda
    2017 : C++17 Template Parameter Deduction, if constexpr
    2020 : C++20 Concepts

The Big Four of C++20: Coroutine

In the previous blog, we introduced C++20 modules. This article dives into C++20 coroutines through three executable examples. The content is divided into three parts: the first part conceptually discusses the differences between coroutines and regular functions; the second part presents two complete coroutine code examples and delves into the compiler level, providing an in-depth analysis of promise_type and its workflow; the third part explains the purpose and working principles of co_await, which is the most challenging section to understand.

Read more

The Big Four of C++20: Module

Preface

What is the most significant feature of C++20?
—The most significant feature is that, to date, no compiler has fully implemented all its features.

Read more

C++14 and C++17 New Features – Everything You Need to Know

C++14 Features

Compared to C++11, C++14 introduces only minor improvements.
The main change can be summarized in one sentence:
👉 Expanding the scope of automatic type deduction.

The remaining changes are mostly small refinements, including:

• Function return type deduction
• Generic lambdas

C++11 Feature Highlights: New Library

The new version of the standard library introduces many new features.
This article only provides a brief overview of their usage without delving into the underlying principles,
as a deeper exploration would make the article excessively long.

C++11 Feature Highlights: New Semantics

This article is the second part of the C++11 New Features series, primarily documenting the new semantics introduced in C++11.

C++11 Feature Highlights: New Keywords

C++11 introduced a large number of new features. This article provides a brief overview of each feature without going into too much detail—covering every aspect thoroughly would require an entire blog post for each feature.

To organize these new features, this series is divided into three parts: new keywords, new semantics, and new additions to the standard library. Initially, I planned to include all three sections in a single blog post, but it turned out to be too long, so I decided to split them into separate articles.

Code Analysis of std::move and std::forward

In the previous blog post, we explored move semantics and perfect forwarding.
During this discussion, we used two new standard functions: std::move and std::forward.

• Purpose of std::move: Converts an lvalue into an rvalue.
• Purpose of std::forward: Preserves the lvalue or rvalue property of an argument during forwarding.

Now that we understand move semantics and perfect forwarding,
it is worth examining the internal implementation of std::move and std::forward.
This requires some basic knowledge of C++ templates.

C++11: Rvalue References, Move Semantics, and Perfect Forwarding

Before C++11, terms like lvalue and rvalue were rarely discussed.
However, with the introduction of rvalue references in C++11, many people—including myself—were left wondering:
What exactly is an rvalue?

To be precise:

1. Lvalue: An identifier that has a distinct memory address.
2. Rvalue: Anything that is not an lvalue.
3. Lvalue Reference: An alias for an lvalue identifier, commonly referred to as a reference.
4. Rvalue Reference: An alias for an rvalue identifier.

Developing a DApp on Windows 10 (Part 0):Starting from Scratch

I’ve always been a bit of a latecomer. It wasn’t until the end of December 2017 that I started investing in cryptocurrency and diving deeper into blockchain. Here, I’ll reflect on my journey from a beginner’s perspective, sharing what I’ve learned in hopes it may be useful to others.