> ## Documentation Index
> Fetch the complete documentation index at: https://dubhe.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Blockchain Development Fundamentals
> Essential concepts for developers new to blockchain and Move programming
🧠 Blockchain Development Basics
Master the fundamentals of blockchain development and the Move programming language
**New to blockchain?** This guide assumes programming experience but not blockchain knowledge.
## 🎯 What You'll Learn
Understanding decentralized systems and how they work
Introduction to Move programming concepts
How Dubhe simplifies blockchain development
## 📚 Blockchain Fundamentals
### What is a Blockchain?
A blockchain is a distributed ledger that maintains a continuously growing list of records (blocks) that are linked and secured using cryptography. Think of it as a shared database that no single party controls.
**Key Properties:**
* **Decentralized**: No central authority
* **Immutable**: Records cannot be changed once confirmed
* **Transparent**: All transactions are publicly visible
* **Consensus-based**: Network participants agree on the state
### Key Blockchain Concepts
Every user has a unique address (like a bank account number) that identifies them on the blockchain.
```bash theme={null}
# Example Sui address
0x1234567890abcdef1234567890abcdef12345678
```
Actions that modify the blockchain state. Every transaction is:
* Signed by the sender
* Verified by the network
* Recorded permanently
```typescript theme={null}
// Example transaction
await client.executeTransaction({
function: 'move_player',
arguments: [player_id, new_position]
});
```
Programs that run on the blockchain, automatically executing when conditions are met.
```move theme={null}
// Simple Move function
public fun transfer_item(from: address, to: address, item_id: u64) {
// Logic executes on-chain
}
```
Computing resources cost "gas" - a fee paid to execute transactions and prevent spam.
## 🚀 Introduction to Move Language
### Why Move?
**Move's unique feature**: Resources cannot be copied or lost, only moved
Mathematical proofs ensure your code works as intended
### Move vs. Traditional Languages
```move theme={null}
// Resources are linear types - can't be copied
struct Coin has key, store {
value: u64
}
// Functions are explicit about what they do
public fun transfer(from: &mut Coin, to: &mut Coin, amount: u64) {
assert!(from.value >= amount, EInsufficientBalance);
from.value = from.value - amount;
to.value = to.value + amount;
}
```
```javascript theme={null}
// Objects can be copied accidentally
class Coin {
constructor(value) {
this.value = value;
}
}
// Easy to introduce bugs
function transfer(from, to, amount) {
if (from.value >= amount) {
from.value -= amount;
to.value += amount;
}
}
```
### Core Move Concepts
```move theme={null}
// Define data structure
struct Player has key, store {
name: String,
level: u8,
experience: u64,
}
// Create instance
public fun create_player(name: String): Player {
Player {
name,
level: 1,
experience: 0,
}
}
```
```move theme={null}
// Public functions can be called externally
public entry fun level_up(player: &mut Player) {
assert!(player.experience >= 100, ENotEnoughExp);
player.level = player.level + 1;
player.experience = 0;
}
// Private functions are internal only
fun calculate_damage(level: u8): u64 {
(level as u64) * 10
}
```
```move theme={null}
struct Item has store, drop { // Can be stored and discarded
name: String,
rarity: u8,
}
struct UniqueNFT has key { // Can be owned (has address)
id: u64,
metadata: String,
}
```
## 🏗️ Understanding Fully On-Chain Applications
### Traditional vs. Fully On-Chain
```mermaid theme={null}
graph TD
A[User] --> B[Frontend]
B --> C[Backend Server]
C --> D[Database]
C --> E[External APIs]
```
**Characteristics:**
* Central server controls logic
* Database can be modified
* Single point of failure
* Users trust the company
```mermaid theme={null}
graph TD
A[User] --> B[Frontend]
B --> C[Blockchain]
C --> D[Smart Contracts]
D --> E[On-Chain State]
```
**Characteristics:**
* Blockchain handles all logic
* Immutable state and rules
* Distributed across nodes
* Users trust the code
### Benefits of Going Fully On-Chain
Users truly own their digital assets - no company can take them away
Applications can interact with each other like building blocks
All logic is public and verifiable - no hidden mechanics
Applications continue to exist even if the company disappears
## 🎮 Entity Component System (ECS) in Blockchain
### Why ECS for Blockchain?
**Game Development Pattern**: ECS is used by major game engines because it's perfect for managing complex, interactive systems - exactly what blockchain applications need.
```javascript theme={null}
// Hard to extend and modify
class Player {
constructor(name, health, mana, inventory) {
this.name = name;
this.health = health;
this.mana = mana;
this.inventory = inventory;
}
// What if we want flying players? Swimming players?
move(direction) { /* complex logic */ }
attack(target) { /* more complex logic */ }
}
```
```move theme={null}
// Flexible components
struct HealthComponent has store {
current: u64,
maximum: u64,
}
struct PositionComponent has store {
x: u64,
y: u64,
}
struct InventoryComponent has store {
items: vector,
capacity: u32,
}
// Mix and match as needed!
```
### ECS Components in Dubhe
**Unique IDs** that represent objects in your world
```typescript theme={null}
const playerId = await client.createEntity();
const monsterId = await client.createEntity();
```
**Data containers** attached to entities
```typescript theme={null}
await client.setComponent(playerId, 'HealthComponent', {
current: 100n,
maximum: 100n
});
```
**Functions** that operate on components
```move theme={null}
public entry fun damage_system(
target_entity: u64,
damage_amount: u64
) {
let health = get_component(target_entity);
health.current = health.current - damage_amount;
set_component(target_entity, health);
}
```
## 🛠️ How Dubhe Simplifies Development
### The Problem Dubhe Solves
**Without Dubhe**: Blockchain development requires deep expertise in multiple areas:
* Move language intricacies
* Blockchain deployment and management
* Frontend integration complexities
* State synchronization challenges
### Dubhe's Solution
Define your data once, generate everything else automatically
Full type safety from blockchain to frontend
Automatic state synchronization with WebSocket support
Deploy to multiple blockchains with the same code
### Development Workflow Comparison
```bash theme={null}
# Manual, error-prone process
1. Write Move contracts manually
2. Deploy contracts to blockchain
3. Extract ABI and generate types
4. Build custom client integration
5. Implement state synchronization
6. Handle blockchain-specific quirks
7. Repeat for each blockchain
```
```bash theme={null}
# Automated, streamlined process
1. Define schema in one file
2. Run `dubhe generate`
3. Develop business logic
4. Run `dubhe deploy`
5. Frontend automatically synced!
```
## 🎯 Your Learning Path
### Recommended Next Steps
Build your first application with [our quickstart guide](/quickstart)
Follow the step-by-step [counter app tutorial](/tutorials/first-dapp)
Dive deeper with [contract development patterns](/tutorials/contract-development)
Create a game with the [Monster Hunter tutorial](/tutorials/monster-hunter)
## 📝 Key Takeaways
✅ **Blockchain** = Shared, immutable database
✅ **Move** = Resource-safe programming language
✅ **Smart Contracts** = Programs that run on blockchain
✅ **ECS** = Flexible architecture for complex applications
✅ **Dubhe** = Framework that simplifies everything above
## 🤝 Getting Help
**Questions about these concepts?**
* 💬 [Join our Discord](https://discord.gg/nveFk3p6za) for real-time help
* 📚 [Check the glossary](/troubleshooting#glossary) for term definitions
* 🎥 [Watch tutorial videos](https://youtube.com/dubheengine) for visual explanations
* 📧 [Email us](mailto:docs@dubhe.xyz) for detailed questions
## 🚀 Ready to Build?
Jump into development with our quickstart guide
Follow a complete tutorial from start to finish