DEV Community: Son DotCom 🥑💙

Understanding AI Agents: How Agentic Systems Actually Work

Son DotCom 🥑💙 — Tue, 20 Jan 2026 16:51:40 +0000

AI is no longer an experiment or a buzzword as it is becoming core infrastructure for how modern software is built and operated.

As AI systems evolve from passive tools into systems that can reason, act, and make decisions, new terms like AI agents are appearing everywhere. Unfortunately, many of these terms are poorly defined and widely misunderstood.

This article aims to fix that.

We’ll start by clarifying what AI actually is, then build up to a clear and practical understanding of AI agents, how they work, what makes them different, and why they matter.

WHAT IS AI

According to IBM, Artificial Intelligence (AI) refers to technology that enables computers and machines to simulate human learning, comprehension, problem-solving, decision-making, creativity, and autonomy.

At its core, AI is not magical. It is a system that works by learning patterns from data, data created and accumulated by humans over time and using those patterns to make predictions, decisions, or generate outputs.

The “intelligence” we observe in AI systems is the result of mathematical models, data, and optimization techniques not consciousness, intent, or awareness.

While there are many forms of AI, most practical systems fall into a few key categories.

Rule-Based Systems

Rule-based systems are the simplest form of AI. They operate entirely on predefined rules written by humans.

They do not learn.
They do not adapt.
They only follow instructions.

Example:

IF the warehouse light is turned on -> say "HELLO"

These systems are predictable and reliable, but extremely limited.

Machine Learning Systems

Machine learning systems differ from rule-based systems in one important way:
they learn patterns from data instead of relying solely on hand-written rules.

Rather than explicitly telling the system what to do, we allow it to observe behavior and infer patterns.

Example:

When is the light turned on today?
When is it turned off?
What about the last 7 days?
What patterns emerge?

Result:

Light turns on around 7:30 AM
Light turns off around 8:00 PM

From this learned pattern, the system can now make a recommendation:

IF light is turned on around 7:30 AM -> say "Hello, Good morning"

At its core its not understanding rather it is pattern recognition based on data.

Large Language Models (LLMs)

Large Language Models are a specific type of machine learning system trained on massive amounts of text data.

They learn how language works by predicting the next token (piece of text) in a sequence, based on the context provided so far.

Despite how human-like they may appear, LLMs do not think or understand in the way humans do. Their outputs are driven by probability, context, and learned patterns not intent or awareness.

What makes LLMs powerful is their ability to:

reason over large contexts
generate structured outputs
adapt responses based on prior information

This idea of context is important, we’ll return to it shortly.

By default, an LLM is stateless, it has no memory unless one is deliberately provided.

Now that we have a clear understanding of what AI is, we can move forward and examine how AI agents emerge from these systems.

AI AGENTS (AGENTIC AI)

AI agents are one of the main reasons AI adoption has accelerated so quickly in recent years. They represent a shift from AI as a passive tool to AI as an active system that can operate toward a goal.

Importantly, AI agents do not give AI “human-like thinking.” Instead, they give AI the ability to act.

An AI agent is a system that can run autonomously, often continuously, and perform tasks on behalf of a user by deciding what actions to take and which tools to use. Rather than responding once and stopping, an agent operates in a loop, observing its environment, making decisions, taking actions, and updating its state until a goal is achieved.

This is what removes one of the biggest limitations of traditional AI systems.

Most AI systems are reactive: they wait for input, produce output, and stop.

AI agents, on the other hand, are goal-driven. They can plan, execute workflows, and adapt based on feedback, often without constant user intervention.

In simple terms, an AI agent is a continuous autonomous loop that works toward a defined objective.

At a high level, every AI agent is composed of three core building blocks:

The AI Model => the decision-making engine (the brain)
The Tools => the mechanisms for interacting with the world (the hands)
The Orchestrator => the system that manages control flow, state, and execution (the nervous system)

We’ll break down each of these components in detail.

The AI Model (The Brain)

The AI model is the core decision-making component of an AI agent. As discussed earlier, it is the same AI system on its own which is a standalone model with no inherent awareness of the environment it operates in.

An AI model does not see files, understand systems, or know what is happening around it unless that information is explicitly provided. It only works with the input it receives and the context made available to it.

Modern AI models are trained on massive amounts of data and are capable of producing highly accurate outputs across a wide range of tasks. However, this capability is entirely dependent on the quality and completeness of the context they are given.

This is why context is critical.

For an AI agent to behave reliably, the model must be supplied with:

the current state of the system
relevant history or memory
clear goals and constraints

Without sufficient context, the model can only guess.

With proper context, it can make informed decisions and select appropriate actions.

In practice, providing rich and accurate context is one of the most important steps in building a robust AI agent workflow.

Example: Language Learning Agent

Imagine we are building a product that helps users learn Portuguese.

To create an effective AI agent workflow, the AI model (LLM) must be provided with detailed and relevant context about each user. This context is typically collected during onboarding and updated over time as the user progresses.

Some useful contextual information might include:

User’s primary language
Whether the user has any prior experience with Portuguese or similar languages (e.g. Spanish)
User type (student, professional, married, etc.)
User age (to adjust explanations vs. direct instruction)
Whether the user is a polyglot (has learned multiple languages before)

Now, consider a new user entering the system.

1. Current State of the System

User is a first-time user
No lessons completed
No progress history

2. Relevant History or Memory

Primary language: English
No prior experience with Portuguese
Familiar with Spanish: No
Age: 35
User type: Married professional
Not a polyglot

3. Goals and Constraints

Goal: Help the user build basic conversational Portuguese from scratch
Constraints:
- Avoid assuming prior language knowledge
- Use clear explanations before introducing grammar rules
- Progress at a beginner-friendly pace
- Prefer practical, real-life examples over abstract theory

With this context, the AI model is no longer guessing.

It can now decide how to teach, what to teach next, and how fast to move all without being explicitly instructed at every step.

The Tools (The Hands)

While the AI model decides what should be done, tools are what actually do the work.

In an agentic system, tools are the mechanisms that allow an AI agent to interact with its environment. They execute actions based on the model’s decisions and have access to parts of the system the model itself cannot see or manipulate directly.

Most tools are backend executors. They can:

read and write files
fetch or store data
call APIs
generate documents
trigger workflows
send notifications or updates to users

The AI model produces structured decisions or instructions, but it is the tools that turn those decisions into real-world effects.

Example: Tools in a Language Learning Agent

Continuing with the Portuguese learning app example, the AI model might decide:

what lesson to present next
how difficult the explanation should be
whether the user needs an example, exercise, or review

The tools then execute these decisions by:

rendering lesson content in the UI
generating personalized exercises
storing progress in the database
creating a tailored study plan
generating a Notion document or downloadable guide for the user

In this setup, the AI model never directly modifies files, databases, or user interfaces.

It outputs decisions.

The tools carry them out.

A key principle

Tools do not think.
They do not reason.
They only execute.

This separation is intentional and critical.

By keeping decision-making (the model) separate from execution (the tools), agent systems become:

safer
easier to debug
easier to extend
easier to control

The AI model chooses what to do.

The tools define what is possible.

The Orchestrator (The Nervous System)

If the AI model decides what should be done and the tools do the work, the orchestrator is what connects everything together.

The orchestrator is responsible for managing the agent’s control flow. It decides when the model should think, when tools should run, how results are evaluated, and whether the agent should continue, adjust, or stop.

After a tool executes an action, the orchestrator:

inspects the result
compares it against the user’s goal
determines whether the outcome is satisfactory
identifies errors or gaps
feeds updated context back to the AI model

This loop is what gives an AI agent its sense of continuity and progress.

Because of this, the orchestrator is the heart of an AI agent.

A powerful model with a weak orchestrator will behave inconsistently, repeat mistakes, or fail silently. A well-designed orchestrator, even with a modest model, can produce reliable and predictable behavior.

What the Orchestrator Actually Does

In practice, the orchestrator is responsible for:

managing the observe => decide => act => evaluate loop
handling retries and failures
enforcing constraints and stopping conditions
updating memory and historical context
determining what the model sees next

This is also where learning at the system level happens.

Not learning in the sense of retraining the model, but learning in how context, preferences, and outcomes are accumulated over time.

What ultimately differentiates one AI agent from another is not the model it uses, but how well its orchestrator manages this loop.

Example: Orchestration in a Language Learning Agent

Continuing with the Portuguese learning app example:

Assume the user provides feedback after the first lesson and indicates that they prefer responses delivered with a core Portuguese speaking accent.

The AI model does not update this preference on its own.

The tool does not understand user intent.

It is the orchestrator that captures this feedback and updates the agent’s historical context so future decisions reflect this preference.

After receiving the feedback, the orchestrator updates the agent state as follows:

1. Current State of the System

User is not a first-time user
One lesson completed
Feedback received on lesson delivery style

2. Relevant History or Memory

Primary language: English
No prior experience with Portuguese
Familiar with Spanish: No
Age: 35
User type: Married professional
Not a polyglot
Prefers responses delivered with a core Portuguese accent

3. Goals and Constraints

Goal: Deliver future lessons using a core Portuguese speaking accent
Constraints:
- Avoid assuming prior language knowledge
- Use clear explanations before introducing grammar rules
- Progress at a beginner-friendly pace
- Prefer practical, real-life examples over abstract theory

With this updated context, the next time the AI model is invoked, it does not need to be re-instructed.

The orchestrator ensures the preference is consistently applied across future interactions.

Bringing It All Together: How AI Agents Actually Work

An AI agent is not a single piece of intelligence. It is a system composed of distinct parts, each with a clear responsibility.

When these parts are combined correctly, they form a continuous loop that allows the agent to operate autonomously, adapt over time, and reliably work toward a goal.

At a high level, the flow looks like this:

The Orchestrator observes the current state

It gathers context: user data, system state, memory, and goals.
The AI Model decides what to do next

Using the provided context, the model reasons and produces a structured decision or plan.
The Tools execute the decision

Tools interact with the environment, updating data, generating content, calling APIs, or triggering workflows.
The Orchestrator evaluates the outcome

It checks whether the action moved the system closer to the goal, identifies errors or feedback, and updates memory.
The loop repeats

With updated context, the agent continues until the goal is met or a stopping condition is reached.

This loop is what transforms AI from a reactive system into an agentic one.

How to think of it

You can think of an AI agent like this:

The AI Model decides what should happen
The Tools make it actually happen
The Orchestrator decides when to think, when to act, and when to stop

None of these components are sufficient on their own.

A powerful model without tools cannot act.

Tools without orchestration become brittle automation.

An orchestrator without a reliable model has nothing useful to execute.

It is the coordination between all three that creates a real AI agent.

Why This Is Important

As AI systems continue to evolve, the model itself will become less of a differentiator. Models will improve, commoditize, and be swapped out over time.

What will matter more is:

how well context is constructed
how safely tools are exposed
how intelligently the orchestration loop is designed

In practice, the quality of an AI agent is determined less by how “smart” the model is, and more by how well the system around it is engineered.

Finally

AI agents are not intelligent beings.

They are disciplined systems.

They work because they:

operate in loops
act under constraints
learn from feedback
and are carefully orchestrated

If you’re currently building AI agents, focus less on swapping models and more on improving how context is constructed, tools are scoped, and orchestration is designed. That’s where most real-world failures and breakthroughs happen.

Rust for Solana – EP04: Structs, Enums, Functions, Traits & Modules

Son DotCom 🥑💙 — Thu, 03 Jul 2025 16:27:21 +0000

Now that you understand the ownership model and data types in Rust, it's time to go deeper into how Rust lets us organize, abstract, and structure logic.

In this episode, you’ll learn:

✅ How to define and use structs

✅ How to model data with enums

✅ How to apply pattern matching

✅ How to write functions and traits

✅ How to organize your code with modules

These tools are the foundation for building scalable Solana smart contracts and apps in Rust.

🧱 Part 1: Structs in Rust

A struct in Rust is used to group related data.

✨ Defining and Instantiating Structs

struct User {
    username: String,
    age: u8,
}

fn main() {
    let user = User {
        username: String::from("alice"),
        age: 30,
    };

    println!("User: {} is {} years old", user.username, user.age);
}

✨ Struct with Associated Function

impl User {
    fn is_adult(&self) -> bool {
        self.age >= 18
    }
}

🔀 Part 2: Enums in Rust

Enums allow you to define a type by enumerating possible variants.

✨ Example: Message Enum

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}

Each variant can carry data or none at all.

✨ Matching Enums

fn process(msg: Message) {
    match msg {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => println!("Move to ({x}, {y})"),
        Message::Write(text) => println!("Write: {text}"),
    }
}

Enums are powerful for representing state, commands, or network messages — perfect for smart contracts.

🎭 Part 3: Pattern Matching

match lets you run code based on pattern logic. It works with enums, primitives, tuples, structs, and more.

✨ Match with `Option<T>`

fn maybe_double(val: Option<i32>) -> i32 {
    match val {
        Some(x) => x * 2,
        None => 0,
    }
}

✨ Match with Structs

let user = User {
    username: "Bob".into(),
    age: 25,
};

match user {
    User { age, .. } if age >= 18 => println!("Adult"),
    _ => println!("Minor"),
}

You can destructure values inside match, if let, and while let for expressive flow control.

🧮 Part 4: Functions in Rust

Functions are reusable blocks of code defined using the fn keyword.

fn greet(name: &str) -> String {
    format!("Hello, {name}!")
}

✨ Key Points

All parameters must have types.
Return type is defined using ->.
The last expression (without a ;) is returned.

fn add(a: i32, b: i32) -> i32 {
    a + b
}

🔌 Part 5: Traits in Rust

Traits define shared behavior that types can implement.

✨ Define a Trait

trait Summary {
    fn summarize(&self) -> String;
}

✨ Implement for Struct

impl Summary for User {
    fn summarize(&self) -> String {
        format!("{} ({})", self.username, self.age)
    }
}

✨ Use Traits in Functions

fn notify(item: &impl Summary) {
    println!("Notification: {}", item.summarize());
}

Traits give Rust powerful polymorphism without runtime overhead.

📦 Part 6: Modules in Rust

Modules let you split your code into organized files and control visibility.

✨ Inline Module

mod greetings {
    pub fn hello() {
        println!("Hello!");
    }
}

fn main() {
    greetings::hello();
}

✨ File-based Modules

src/
├── main.rs
└── utils.rs

`main.rs`

mod utils;

fn main() {
    utils::welcome();
}

`utils.rs`

pub fn welcome() {
    println!("Welcome to Rust for Solana!");
}

📚 Summary Table

Concept	Description
`struct`	Group related data into one logical unit
`enum`	Represent multiple related variants
`match`	Exhaustive pattern matching for control flow
`fn`	Reusable functions with static typing
`trait`	Define and share behavior across types
`mod`	Organize and encapsulate logic across files

🧪 Practice Exercises

1. Define a Struct

Create a struct Product with name, price, and stock. Implement a method is_in_stock().

2. Enum Challenge

Create an enum OrderStatus with Pending, Shipped, Delivered. Match and print their status.

3. Trait Implementation

Define a Displayable trait with display(&self) -> String. Implement it for Product.

4. Module Exercise

Create a math module with add, subtract, multiply, and divide functions. Use them in main.

📘EP01 - Intro to Rust and Solana Dev Setup

Son DotCom 🥑💙 — Tue, 24 Jun 2025 15:30:23 +0000

Welcome to the first episode of our Rust for Solana Bootcamp — a hands-on journey to becoming a smart contract engineer on Solana using Rust. In this class, we’ll explore why Rust is the language of choice for Solana, and walk through the complete environment setup to get you building on the blockchain

Today, we’re starting with:

Why Rust is the go-to language for Solana development
How to set up your development environment
Your first Rust CLI app
A bonus intro to Anchor

🧠 Why Rust for Solana?

Solana is one of the fastest blockchains — boasting over 65,000 TPS — and it's written entirely in Rust. Here's why Rust is perfect for the job:

✅ Performance & Safety

Rust guarantees memory safety at compile time, with no garbage collector, allowing you to write blazing fast and reliable code.

✅ Precise Control

With its ownership and borrowing model, Rust gives you precise control over your memory layout — a must for writing smart contracts.

✅ No Runtime Crashes

Rust’s compiler catches nulls, uninitialized variables, and data races before they happen.

🧰 Prerequisites

A machine running Linux, macOS, or WSL (Windows Subsystem for Linux)
Familiarity with any programming language
Curiosity and willingness to learn 💪

🔧 Step-by-Step Setup for Rust + Solana Dev

🟠 1. Install Rust + Cargo

Run this command:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Check that Rust is installed:

rustc --version
cargo --version

✅ cargo is Rust’s build tool and package manager.

🟣 2. Install the Solana CLI

sh -c "$(curl -sSfL https://release.solana.com/stable/install)"

Confirm it works:

solana --version

Set your network to Devnet:

solana config set --url https://api.devnet.solana.com

🔵 3. Install Anchor (Solana's Rust Framework)

cargo install --git https://github.com/coral-xyz/anchor anchor-cli --locked

Anchor abstracts away boilerplate and makes Solana smart contract dev enjoyable.

Test the install:

anchor --version

🧪 Let’s Write Your First Rust App

Run this in your terminal:

cargo new hello_rust
cd hello_rust

Edit src/main.rs:

fn main() {
    println!("🚀 Hello, Solana Developer!");
}

Run it:

cargo run

You should see:

🚀 Hello, Solana Developer!

Boom. You're now a Rustacean! 🦀

📖 Assignment (Do This Now)

Install Rust, Solana CLI, and Anchor
Create a new Rust CLI project named greeter
Accept the user's name from terminal input and greet them:

use std::io;

fn main() {
    println!("What's your name?");
    let mut name = String::new();
    io::stdin().read_line(&mut name).expect("Failed to read input");
    println!("Welcome to Solana, {}!", name.trim());
}

🧠 Practice Exercises

1. Get Your Public Key

Run:

solana address

Then, print it in your Rust app using:

println!("My Solana address: {}", YOUR_PUBKEY_HERE);

2. Add a Balance Checker (Mock)

Add a variable let balance = 2.5; and print if the user is eligible for an airdrop based on their balance.

🧨 Bonus: Initialize Your First Anchor Project

anchor init mysolanaapp
cd mysolanaapp
anchor build

You’ll see:

Program ID: ...
Built in target/deploy/

Just like that, your first on-chain Solana program is ready to deploy!

🎯 What’s Next?

In the next episode EP02 – Rust Ownership & Borrowing Explained, we’ll explore Rust’s ownership model, borrowing rules, and how it leads to memory safety — critical for writing secure blockchain programs.

🙌 Let’s Connect

💬 Questions? Drop a comment below
🧠 Want to follow the full course? Bookmark or follow me
📦 GitHub repo for this series:Here

If you liked this post, consider clapping 👏 and sharing with other Rust-curious blockchain devs!

Why 'Not Your Keys, Not Your Crypto' Is Failing Web3—and How CeFi Can Fix It

Son DotCom 🥑💙 — Mon, 31 Mar 2025 12:30:07 +0000

The Decentralized Dream Is Stalling. Here’s Why Centralized Finance with MPC Could Be the Key to Mass Adoption.

I’ve spent four years in Web3, and I’m calling it: the 'not your keys, not your crypto' mantra is a roadblock. It’s built on assumptions that crumble outside the crypto echo chamber—and if we want a billion users, we need to rethink it.

First flaw: It assumes everyone can custody their own keys. Reality check—over 70% of the world isn’t technical. My grandma isn’t securing seed phrases or debugging wallet errors. Most won’t.

Second flaw: Self-custody is a UX nightmare. Sign this, approve that, lose your phrase—you’re screwed. Smart contracts? More signatures. It’s not freedom; it’s friction. Adoption’s stuck because we’re building for the 1%, not the 70%.

Here’s the fix: Centralized Finance (CeFi)—but not the old kind. Think CeFi 2.0: systems using Multi-Party Computation (MPC) to secure keys for us. No single point of failure, no seed phrase stress. Your keys are split, encrypted, and managed—CEO can’t touch them, but you’re still in control. Coinbase is already doing this. Devs, take note: this is where the puck’s going.

Picture it: businesses auto-signing transactions securely. No pop-ups, no babysitting. Pair it with Google-auth simplicity, and suddenly Web3 isn’t just for nerds. Purists will cry 'centralization!'—but pure decentralization is a fantasy that gatekeeps the masses.

The next killer app isn’t another DEX. It’s a secure, scalable CeFi layer that unlocks blockchain for everyone. Devs, stop preaching dogma. Build for the real world. Who’s in?"

Mastering Rust's Ownership: The Key to Memory Safety and Efficiency

Son DotCom 🥑💙 — Mon, 14 Aug 2023 08:29:19 +0000

The ownership mechanism in Rust is a unique feature that sets it apart from other mainstream programming languages. It's what makes Rust both memory-safe and efficient while avoiding the need for a garbage collector, a common feature in languages like Java, Go, and Python. Understanding ownership is crucial for becoming proficient in Rust. In this article, we will explore the following topics:

Stack and Heap
Variable Scope
Ownership
Borrowing (Referencing)
Mutable Reference

Note: This article is beginner-friendly. Familiarity with Rust's basic syntax, variable declaration within functions, and basic data types is assumed. If you need a quick refresher, you can check out this guide.

Stack AND Heap

Memory in Rust can be divided into two main parts: the stack and the heap. Both of these are available during both compile time and runtime and serve different purposes. Understanding their mechanics is crucial for writing efficient Rust code.

Stack

The stack is used to store data with known sizes at compile time. The size of data stored on the stack is fixed and cannot be changed during runtime.

The stack operates using a First In, Last Out (FILO) mechanism, similar to stacking plates. The first plate added is the last one removed.

Rust automatically adds primitive types to the stack:

fn main() {

    let num: i32 = 14;
    let array = [1, 2, 4]; 
    let character = 'a'; 
    let tp = (1, true); 

    println!("number = {}, array = {:?}, character = {}, tp = {:?}", num, array, character, tp); 
}

The stack layout for the main method would be as follows:

Address	Name	Value
3	tp	(1, true)
2	character	'a'
1	array	[1,2,4]
0	num	14

In this table, the num variable, being the first added, will be the last removed when the function scope ends.

Note: Address column uses numbers as representation, ideally addresses in computers are not just numbers.

Heap

The heap is used for data with sizes unknown at compile time. Types like Vec, String, and Box are stored on the heap automatically.

fn main() {

    let num: i32 = 14;
    let new_str = String::new(); 
}

The memory mapping for data on the heap is as follows:

STACK MEM

Address	Name	Value
1	new_str	ptr1
0	num	14

HEAP MEM

Address	Name	Value
ptr1		""

When storing data on the heap, a pointer (like ptr1) is first stored on the stack. This pointer then references the actual data on the heap. This additional step makes heap access slower compared to stack access.

With stack and heap mechanisms understood, let's delve into variable scope.

Variable Scope

Variable scope defines the range in code where a variable is valid. In Rust, curly braces create blocks, and variables within these blocks are scoped to them.

fn main() {
// everything here is scoped to this block
 let hello = "Hello World";
// ...
}

Variables within a block cannot be accessed outside that block:

fn main() {
 let hello = "Hello World"; 

  // inner block
  {
    let num = 20;
  }

 // This will fail to compile
 println!("{} {}", hello, num);
}

From the above you can't use num outside the inner block because it is scoped only to the inner block.

Rust runs functions from top to bottom, allocating stack and heap memory as needed. When the scope ends, Rust calls the drop method internally to deallocate memory, a crucial concept for understanding Rust's approach to memory management.

Ownership

Here we come to the heart of the article, where we explore ownership and its impact on Rust programming. Remember these ownership rules as we proceed:

Ownership Rules

There can only be one owner of a value at a time.
Each value has an owner.
If the owner goes out of scope the value is dropped.

Lets see what this mean below:

fn main() {
    let array = vec![1,2,3]; 
    let title = String::new(); 

    let new_array = array;
    let new_title = title; 

    println!("array {:?} title {} new_array {:?} new_title {}", array, title, new_array, new_title);
 }

The compilation error "borrow of moved value" arises because both array and title are being owned by multiple variables simultaneously. This violates the ownership rules.

Rust's memory layout for the code above is as follows:

STACK MEM

Address	Name	Value
3	new_title	ptr2Copy
2	new_array	ptr1Copy
1	title	ptr2
0	array	ptr1

HEAP MEM

Address	Name	Value
ptr2 and ptr2Copy		""
ptr1 and ptr1Copy		vec![1,2,3]

As seen from above because vectors and strings are non fixed size types Rust allocates them to the heap and can be accessed via pointer from the stack.

The ptr1Copy pointer is a copy of ptr1 pointer and the ptr2Copy pointer is a copy of ptr2 pointer.

When Rust is done it then calls the drop method, the drop method walks through the stack remember FILO we explained above? It starts by removing the last item added to the stack which is new_title then finds out it has a pointer(ptr2Copy) goes to the heap memory via that pointer and removes the string value. It continues to the next element on the stack new_array which also has a pointer ptr1Copy and removes the vector from the heap memory too. It again continues to the next which is title and has a pointer ptr2 but when it follows the pointer it realises that the data no longer exits as it has been removed via ptr2Copy this why it throws error for title the same thing goes for the array variable.

The Ownership rules apply only to Rust types on the heap. Primitive types on the stack don't follow these rules:

fn main() {
    let array = [1,2,3]; 
    let title = "hello"; 

    let new_array = array;
    let new_title = title; 

    println!("array {:?} title {} new_array {:?} new_title {}", array, title, new_array, new_title);
 }

For readers familiar with other languages, reassigning values to new variables while they're on the heap might seem intuitive. How do we achieve this in Rust?

We can use the .clone method, which duplicates the heap value and stores it in a new location on the heap:

See below:

fn main() {
    let array = vec![1,2,3]; 
    let title = String::new(); 

    let new_array = array.clone();
    let new_title = title.clone(); 

    println!("array {:?} num {} new_array {:?} new_num {}", array, title, new_array, new_title);
}

From the above the code works now, let's see how the translation is done on the stack and heap

STACK MEM

Address	Name	Value
3	new_title	ptr2Copy
2	new_array	ptr1Copy
1	title	ptr2
0	array	ptr1

HEAP MEM

Address	Name	Value
ptr2Copy		""
ptr1Copy		vec![1,2,3]
ptr2		""
ptr1		vec![1,2,3]

While this approach works, it might result in unnecessary memory consumption and inefficiencies.

Borrowing

In Rust, borrowing (or referencing) allows us to use values without taking ownership. To reference a value, we use the & sign.

fn main() {
    let hello = String::from("hello");
    let another_hello = &hello;

    let arr = vec![1];
    let another_arr = &arr;

    println!("hello = {} another_hello = {} {:?} {:?}", hello, another_hello, another_arr, arr)
  }

By referencing values, we can read data without copying it, avoiding unnecessary memory overhead.

This is also applicable for functions parameters. Function parameters have their own scope, passing a value to it will automatically move the ownership to the parameters.

fn main() {
    let name = String::from("John");
    say_hello(name);
    println!("{}", name)
}

fn say_hello(name: String) {
    println!("hello {}", name)
}

The above failed because the ownership of value "John" was moved to the function params.

We can resolve this error by borrowing from the name owner, see below

fn main() {
    let name = String::from("John");
    say_hello(&name);
    println!("{}", name)
}

fn say_hello(name: &String) {
    println!("hello {}", name)
}

We don't have anymore errors, looks good so far.

All these while we've only read the value from the owner what if we want to update that value and still not take ownership?

Mutable References

Mutating values in Rust requires the mut keyword, and to mutate a value via reference, we use the &mut keyword.

fn main() {
  let mut name = String::from("John");

  full_name(&mut name);

  println!("Your full name is: {}", name);
}

fn full_name(name: &mut String) {
  name.push_str(" Doe");
}

From above the full_name function is able to update the name value without taking ownership of the value.

One thing to always remember is at any given time, you can have either one mutable reference or any number of immutable references.
So the following code will fail to compile:

fn main() {
    let mut s = String::from("hello");

    let r1 = &mut s;
    let r2 = &mut s;

    println!("{}, {}", r1, r2);
}

Even if we are just reading the value hello as far as we have a single mutable reference rust complains. The below still fails to compile

fn main() {
    let mut s = String::from("hello");

    let r1 = &s;
    let r2 = &s;
    let r3 = &mut s;

    println!("{}, {}, {}", r1, r2, r3);
}

The reason for this is to avoid data inconsistencies because rust cannot guarantee at what point the reading or data change will happen.

We can make the above work with scope.

fn main() {
    let mut s = String::from("hello");

    // inner scope 
    {
     let r1 = &mut s;
     println!("{}", r1);
    }

    let r2 = &mut s;
    println!("{}", r2);

}

Also we can read all read references and be done with them before mutating.

fn main() {
 let mut s = String::from("hello");

    let r1 = &s; // no problem
    let r2 = &s; // no problem
    println!("{} and {}", r1, r2);
    // variables r1 and r2 will not be used after this point

    let r3 = &mut s; // no problem
    println!("{}", r3);
}

Rust enforces us to think of our code properly to avoid writing buggy code that are hard to fix.

Conclusion

In the world of programming languages, Rust stands out as a remarkable choice due to its ownership mechanism. This mechanism, while initially challenging to grasp, is the cornerstone of Rust's memory safety and efficiency. By strictly adhering to rules that enforce single ownership, Rust mitigates the risk of memory leaks, data inconsistencies, and other common programming pitfalls.

Through this article, we've explored the intricate workings of Rust's ownership concept. We began with a foundational understanding of the stack and heap, the pillars that support memory allocation. The stack, efficient for fixed-size data, and the heap, accommodating dynamic data, together enable Rust to balance performance and flexibility.

The significance of variable scope became evident as we delved into the importance of block-level scoping. Rust's rigorous scope management not only simplifies code but also assists in automating memory deallocation through the drop mechanism.

Ownership, the core of Rust's memory management philosophy, teaches us the invaluable lesson that only one entity can own a value at any given time. This principle may initially seem restrictive, but it's an essential safeguard against data races and memory issues.

We learned how to navigate these ownership rules by utilizing borrowing, a mechanism that allows controlled access to values without compromising ownership. We saw how references (&) and mutable references (&mut) facilitate this process, enabling both reading and manipulation without sacrificing data integrity.

In a landscape where memory safety is often sacrificed for convenience, Rust shines as a language that compels developers to adopt best practices. While the ownership model can be challenging, mastering it will make you a more disciplined and effective Rust programmer.

As you continue your journey with Rust, remember that ownership isn't just a technicality; it's a mindset. Embrace it, let it guide your coding decisions, and you'll unlock the true potential of this language. Rust's ownership is not merely a hurdle to overcome; it's a superpower to wield responsibly.

So, as you write your Rust code, keep these ownership principles in mind, and you'll be well on your way to creating robust, efficient, and reliable software that stands the test of time.

Introduction to Common Programming Concepts in Rust

Son DotCom 🥑💙 — Fri, 21 Jul 2023 04:52:47 +0000

In this article, we'll explore some fundamental programming concepts present in Rust, such as variables, conditions, and basic types. To make the most out of this article, it's recommended to have some prior experience with at least one programming language like Python, JavaScript, or Java.

What is Rust

Rust is a statically typed programming language designed for performance and safety. Originally developed at Mozilla, it caters to system-level programmers who work with low-level byte tweaking code. You can learn more about the history of Rust here.

Installation

As this article primarily focuses on teaching programming concepts, we won't delve deep into installation. If you wish to install Rust globally on your computer, you can follow the instructions here. Alternatively, you can code along with the article using the Rust Playground app.

Let's dive right in and start exploring Rust!

Variables

Declaring variables in Rust is straightforward. We use the let keyword to do so.

   let even_number = 2;

This is similar to the let keyword in JavaScript, but Rust treats it differently. By default, variables in Rust are immutable, meaning you can't change the value assigned to a variable.

As shown above, our code fails because we are unable to change the value of our variable even_number. To change the value of a variable, we must add the mut keyword, which stands for "mutate."

 let mut even_number = 2;

Now, our code runs fine and prints an output (Note: ignore the warning signs for now, they only indicate that we haven't used the even_number variable).

A variable in Rust can only have one type, which can either be explicitly assigned or inferred by the Rust compiler. Unlike JavaScript, once a type is assigned to a variable in Rust, it cannot be changed.

 let mut even_number = 2;
// This will not compile
 even_number = true;

As seen above, the Rust compiler throws an error for "mismatched types." It expects the even_number variable to always be an integer but got a boolean type.

Basic Types

Boolean

A Boolean type is a type that can have only two values: true or false. To declare a boolean in Rust, we use the bool keyword.

let is_valid: bool = true;

By default, variables declared as bool are automatically set to false.

let is_updated: bool; // will be false

Boolean types are mainly used in conditionals, such as if and else statements, where you can check if a variable is true and proceed accordingly.

Integers

Integers in Rust are numbers without decimal points. There are two types of integers in Rust: signed and unsigned integers.

Signed Integers

Signed integers can be positive or negative. Examples include: 20, -20, 34, -34, etc. Signed integers are represented by adding an i at the start of the integer range.

  let count: i64 = 1501

Unsigned Integers

Unsigned integers are only positive integers. Examples include: 20, 34, 42, 382728289, etc. Unsigned integers are represented by adding a u at the start of the integer range.

  let age: u8 = 54

The integer type specifies the length of data that the variable can hold.

For Signed:

Length	Signed	Range
8-bit	i8	-128 to 127
16-bit	i16	-32,768 to 32,767
32-bit	i32	-2.147e9 to 2.147e9
64-bit	i64	-9.223e18 to 9.223e18
128-bit	i28	-1.701e38 to 1.701e38

For Unsigned:

Length	UnSigned	Range
8-bit	u8	0 to 255
16-bit	u16	0 to 65,535
32-bit	u32	0 to 4.295e9
64-bit	u64	0 to 1.844e19
128-bit	u28	0 to 3.403e38

If we use an integer type and assign a value below or above the range of that type, Rust will panic.

Example:

   // this will not compile 
   let counter: i8 = 128;

Floats

Floats are numbers with decimal points. All float types in Rust are signed. There are two types of floats in Rust: f32 and f64.

Example:

   let amount: f32 = 20.50;

Character

This type is similar to character in other programming languages and is represented with the char keyword.

Example:

  let alphabet: char = 'a';

Notice that the value of the char type must be enclosed in single quotes.

Compound Types

Arrays

Arrays are used to group data of the same type together. Unlike arrays in JavaScript, Rust arrays are not dynamic. Rust arrays are stored on the stack, so their size and length must be known during initialization.

To declare an array, use the syntax [type; size], where type is the type of data to store, and size is the number of elements in the array.

Example:

   let students_age: [u8; 5] = [10, 12, 9, 11, 10];

Values in an array must be of the same type. You can't have a char inside an array of numbers like you could in JavaScript.

Example:

The above example fails because the char type was included in the list.
Notice that we didn't explicitly add the array type because Rust can infer it from the provided data.

Accessing and Updating Arrays

Accessing an array element in Rust is similar to other programming languages: we use the element's index.

Example:

fn main() {
   let numbers = [3,2,3,5,7,8,9]; 
   println!("{}", numbers[0]); // 3
   println!("{}", numbers[4]); // 7
}

To update or mutate an array, we must use the mut keyword.

Example:

fn main() {
   let mut numbers = [3,2,3,5,7,8,9]; 
   numbers[0] = 1; 
   println!("{:?}", numbers) // [1,2,3,5,7,8,9]; 
}

As shown from the above the first number in the array was changed from 3 to 1.
NB: The :? is a debug trait, you shouldn't worry about that now but you will need to include that to display the array of numbers.

Vectors

Vectors are similar to arrays but are dynamic, meaning their sizes can change. They are stored on the heap rather than the stack. To represent a vector type, use Vec<T> and initialize it with vec![...].

Example:

   let counter: Vec<i8> = vec![4, -5, 7];

From the above we declare a vector of type i8 with three values.

We can also declare a vector with zero initial values using: Vec::new()

Example:

   let mut current_counts: Vec<i8> = Vec::new();
   println!("{:?}", current_counts); // []

To add more values to a vector, use the .push method.

Example

  let mut current_counts: Vec<i8> = Vec::new();
   current_counts.push(5);
   println!("{:?}", current_counts) // [5]

To remove items from the vector, use the .pop method.

Example:

   let mut counter: Vec<i8> = vec![4, -5, 7]; 
   counter.pop(); 
   counter.pop(); 
   println!("{:?}", counter) // [4]

From the above we call the pop method twice which removed two elements from the vector.

Also just link arrays we also use the index of elements to access those elements in the vector.

Example:

   let counter: Vec<i8> = vec![4, -5, 7]; 
   println!("{}", counter[1] ); // -5

Conditions

Rust conditionals work similarly to other programming languages. To conditionally run a block of code, use the if else expression.

Example

fn main() {
   let count = 2;
    if count > 2 {
        println!("Count is greater than 2");
    } else {
        println!("Count is less than 2");
    }
}

The conditions must always evaluate to a bool type. The code below will not compile:

   let count = 2;
   // This will fail 
    if count {
        println!("Count is greater than 2");
    } else {
        println!("Count is less than 2");
    }

count is an integer type, not a bool type. Unlike JavaScript, Rust does not implicitly typecast.

Loops

Rust offers three kinds of loops: for, while, and loop.

For loop

The for loop in Rust is similar to for-in loops in JavaScript. It is used primarily with arrays and allows you to loop over each element.

Example:

fn main() {
   let numbers = [3,2,3,5,7,8,9]; 

    for num in numbers {
        println!("the number is: {num}");
    }
}

You can also loop over a range with the Rust for loop.

Example:

fn main() {
    for num in 0..10 {
        println!("the number is: {num}");
    }
}

While loop

While loops execute a block of code repeatedly as long as a condition is true. The loop breaks when the condition becomes false.

Example:

fn main() {
    let numbers = [3,2,3,5,7,8,9]; 
    let mut cal = 0;
    let mut index = 0;

    while cal <= 20 {
        println!("the current calculated value is: {}", cal);
        cal += numbers[index];
        index += 1;
    }
}

From the above the loop will continue to until the variable cal is greater than 20 then it stops.

loop

The loop executes a block of code infinitely until you manually stop it using the break keyword.

Example:

fn main() {
   let mut counter = 0;

    loop {
        counter += 1;
        println!("The counter is currently {counter}");
        if counter == 10 {
           counter = counter * 2;
            break;
        }
    };

    println!("Total counter is {counter}");
}

Function

Declaring a function in Rust is similar to other programming languages. So far, we have seen the main function, which serves as the entry point that Rust looks for when running our code.

We can create our own functions with different names and use them in the main function.

fn main() {
  let result = addition(20, 20);
  println!("result: {}", result);

 }

 fn addition(num1: i8, num2: i8) -> i8 {
      num1 + num2
 }

In the above example, we created a function named addition with two arguments, num1 and num2, both of type i8, and a return type -> i8.

Notice that within the addition function, we didn't explicitly add the return keyword. This is valid because Rust will implicitly return any line within the function that doesn't end with a semicolon

Exercise

Now that we've covered a lot of ground, it's time to test your skills with an exercise:

Write a program that uses println! to print all the numbers from 1 to 100, with two exceptions. For numbers divisible by 3, print "Fizz" instead of the number, and for numbers divisible by 5 (but not 3), print "Buzz" instead. For numbers divisible by both 3 and 5, print "FizzBuzz".

In conclusion, this article provided an introductory overview of common programming concepts in Rust. We explored variables, conditions, basic types, and compound types like arrays and vectors. Additionally, we covered loops, functions, and even challenged ourselves with an exercise to solidify our understanding. Rust's focus on performance and safety makes it an excellent choice for system-level programming and low-level optimizations. As you continue your journey with Rust, remember that practice is key to mastering any programming language. Embrace the power of Rust's expressive syntax and its robust features to build efficient and secure applications. Happy coding!

A beginner's guide to Blockchain

Son DotCom 🥑💙 — Tue, 06 Apr 2021 09:33:12 +0000

Concept of Blockchain

Imagine an open platform in which anyone can join similar to whatsapp groups, before any message is delievered on this platform it most go through validation (certain rules set by the group), this validation is done by some selected platform members known as validators.
Also anyone who joins in will have a copy of all previous messages sent to the platform, say the platform was created on the 3rd of January and you joined on the 10th of Febuary, you will get a copy of all messages sent to the group since it creation.
Lastly every new message successfully delievered will come along with previous messages and everyone has their own copy.

That is it, in a simple level this is what blockchain is, the message delievered on the platform represents a block (which is a record of data), and the messages are delievered along with previous messages and that creates a chain of messages hence blockchain (records of data that are chain together by a cryptographic algorithm).

The validators are responsible for verifying that a block is valid within the blockchain, so they check that the block is not malicious and that it conforms to the rules of the system.

What is Blockchain

The blockchain is a timestamped series of immutable records of data managed by tons of computers and not controlled by a single entity ( eg: Google, Amazon, Reddit etc ).

An example of what a block looks like

source: https://etherscan.io/

From the above this looks like a ledger where activities of this block is recorded.

Okay Charles why is this really important?

Why Blockchain

The nature of blockchain brings a lot of ground breaking benefits, in fact it is the game changer! some of these benefits includes.

Decentralization
Immutability
Transparency

Decentralization

Most applications makes use of a centralized system, an example of such are your bank apps. The problem with this system is, if for whatever reason the system is down, the users wont be able to use the app. Also if for whatever reason the system crashes the users looses all their money (terrible!).
Blockchain is a decentralized system in that records are stored in various nodes (computers) participating in the network.

source: https://101blockchains.com/decentralized-vs-centralized/

Immutability

Informations such as your account balance and transactions are stored in a central database. Lets say you have $5000 in you bank account, if an attacker have access to the central database, the attacker can easily update your $5000 to $500 and that becomes your new balance.
Due to the nature of blockchain which nodes in the network has copy of all records on the blockchain if an attacker decides to update a users account balance in a specific node he/she will also need to update that users account balance in all other nodes which is not possible.

Transparency

This is one of the most misunderstood concept of blockchain, alot of folks think blockchain is like a "black market" where users activities are hidden. Well that is not true.
This misconception comes from the fact that on the blockchain network a user is not know by their fullname, username or email but by their address.
An example of such address is
The blockchain is transparent to everyone on the network and whatever transaction an address does is known by everyone (Remember every node has a copy!).

Summary

Blockchain is an open ledger which all transactions done on the network is open to everyone, It is not owned by one person so no one person can bring it down, It is immune to attackers.

Blockchain is still relatively new and there are still much to learn. I hope this article helps you have at least a little understanding of what blockchain is. For a more in-depth study I will recommend https://blockgeeks.com/guides/what-is-blockchain-technology/#Is_Blockchain_Technology_the_New_Internet

NB: Yes blockchain is not Bitcoin, Bitcoin use the blockchain technology for its processes, and because Bitcoin was the first to successfully used this technology people use both words interchangeably.

DEV Community: Son DotCom 🥑💙

Understanding AI Agents: How Agentic Systems Actually Work

WHAT IS AI

Rule-Based Systems

Machine Learning Systems

Large Language Models (LLMs)

AI AGENTS (AGENTIC AI)

The AI Model (The Brain)

Example: Language Learning Agent

1. Current State of the System

2. Relevant History or Memory

3. Goals and Constraints

The Tools (The Hands)

Example: Tools in a Language Learning Agent

A key principle

The Orchestrator (The Nervous System)

What the Orchestrator Actually Does

Example: Orchestration in a Language Learning Agent

1. Current State of the System

2. Relevant History or Memory

3. Goals and Constraints

Bringing It All Together: How AI Agents Actually Work

How to think of it

Why This Is Important

Finally

Rust for Solana – EP04: Structs, Enums, Functions, Traits & Modules

🧱 Part 1: Structs in Rust

✨ Defining and Instantiating Structs

✨ Struct with Associated Function

🔀 Part 2: Enums in Rust

✨ Example: Message Enum

✨ Matching Enums

🎭 Part 3: Pattern Matching

✨ Match with Option<T>

✨ Match with Structs

🧮 Part 4: Functions in Rust

✨ Key Points

🔌 Part 5: Traits in Rust

✨ Define a Trait

✨ Implement for Struct

✨ Use Traits in Functions

📦 Part 6: Modules in Rust

✨ Inline Module

✨ File-based Modules

main.rs

utils.rs

📚 Summary Table

🧪 Practice Exercises

1. Define a Struct

2. Enum Challenge

3. Trait Implementation

4. Module Exercise

📘EP01 - Intro to Rust and Solana Dev Setup

🧠 Why Rust for Solana?

✅ Performance & Safety

✅ Precise Control

✅ No Runtime Crashes

🧰 Prerequisites

🔧 Step-by-Step Setup for Rust + Solana Dev

🟠 1. Install Rust + Cargo

🟣 2. Install the Solana CLI

🔵 3. Install Anchor (Solana's Rust Framework)

🧪 Let’s Write Your First Rust App

📖 Assignment (Do This Now)

🧠 Practice Exercises

1. Get Your Public Key

2. Add a Balance Checker (Mock)

🧨 Bonus: Initialize Your First Anchor Project

🎯 What’s Next?

🙌 Let’s Connect

Why 'Not Your Keys, Not Your Crypto' Is Failing Web3—and How CeFi Can Fix It

Mastering Rust's Ownership: The Key to Memory Safety and Efficiency

Stack AND Heap

Stack

Heap

Variable Scope

Ownership

Ownership Rules

Borrowing

Mutable References

✨ Match with `Option<T>`

`main.rs`

`utils.rs`