DEV Community: tomomomomo

My First Blockchain Code with Rust!

tomomomomo — Thu, 13 Mar 2025 07:56:59 +0000

Today I started learning blockchain with Rust, and I’m really excited about it.
Here’s what I learned today:

I understood the difference between use super:: (relative path) and use crate:: (absolute path). It was confusing at first!
I’m getting used to writing struct and adding functions with impl. Sometimes I forget pub though, oops.
I wrote this simple blockchain code with Proof of Work. It mines until the hash starts with "0000".

use super::transaction::Transaction;//相対パス
use sha2::{Digest, Sha256};
use std::time::{SystemTime, UNIX_EPOCH};

#[derive(Debug, Clone)]
pub struct Block {
    pub index: u64,
    pub timestamp: u128,
    pub transactions: Vec<Transaction>,
    pub previous_hash: String,
    pub hash: String,
    pub nonce: u64,
}

impl Block {
    pub fn new(index: u64, transactions: Vec<Transaction>, previous_hash: String) -> Self {
        let timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis();


        let mut block = Block {
            index,
            timestamp,
            transactions,
            previous_hash,
            hash: String::new(),
            nonce: 0,
        };
        block.hash = block.mine();
        block
    }

    pub fn caluculate_hash(&self)-> String {
        let txs_string: String = self.transactions.iter().map(|tx| tx.to_string()).collect();
        let input = format!(
            "{}{}{}{}{}", 
            self.index, self.timestamp, txs_string, self.previous_hash, self.nonce
        );
        let mut hasher = Sha256::new();
        hasher.update(input);
        let result = hasher.finalize();
        hex::encode(result)
    }


    fn mine(&mut self) -> String {
        loop {
            let hash = self.caluculate_hash();
            if hash.starts_with("0000") {
                return hash;
            }
            self.nonce += 1;
        }
    }
}

Yesterday, I coded a Softmax backward function, so Vec is my friend now (maybe one-sided love?). iter, map, and zip are buddies too, though I didn’t use zip today.

It’s been less than a week since I started, and I’m proud of this progress. It’s so fun to build something! Any tips or feedback would be awesome. Next, I want to try P2P. Thanks for reading!

My Approach to Building a Developer Portfolio

tomomomomo — Thu, 13 Mar 2025 01:29:07 +0000

I was thinking about whether I should create my portfolio on GitHub.
So I had ChatGPT check my code, and it pointed out a lot of issues.
But I want to document my learning process as I progress.
So it’s a good idea to write about the process here.
Later, I’ll upload my code to GitHub.

Rust Beginnings: Coding a Perceptron with Struggles and Hope

tomomomomo — Sun, 09 Mar 2025 19:44:46 +0000

This is my first Rust code!

pub struct LogicGate {
    weights: Vec<f64>, //重み
    bias: f64,       //バイアス
    inputs: Vec<f64>, //入力
}


impl LogicGate {
    pub fn new(weights: Vec<f64>, bias: f64, inputs: Vec<f64>) -> Self {
        LogicGate { weights, bias, inputs }
    }
}


pub trait Gate {
    fn and(gate: &Self) -> f64;
    fn or(gate: &Self) -> f64;
    fn nand(gate: &Self) ->f64;
    fn xor(gate: &Self) -> f64;

}

impl Gate for LogicGate {
    fn and(gate: &Self) -> f64 {
        let sum: f64 = gate.inputs.iter().zip(gate.weights.iter())
            .map(|(x, w)| x * w).sum();

        if sum + gate.bias > 0.0 { 1.0 } else { 0.0 }
    }

    fn nand(gate: &Self) ->f64 {
        let sum: f64 = gate.inputs.iter().zip(gate.weights.iter())
            .map(|(x, w)| x * w).sum();

        if sum + gate.bias <= 0.0 { 1.0 } else { 0.0 }
    }

    fn or(gate: &Self) -> f64 {
        let sum: f64 = gate.inputs.iter().zip(gate.weights.iter())
            .map(|(x, w)| x * w).sum();

        if sum + gate.bias > 0.0 { 1.0 } else { 0.0 }
    }

    fn xor(gate: &Self) -> f64 {
        let nand_out = Self::nand(gate);
        let or_out = Self::or(gate);
        let and_inputs = vec![nand_out, or_out];
        let and_gate = LogicGate::new(vec![0.5, 0.5], 0.7, and_inputs);
        Self::and(&and_gate)

    }
}

I faced tons of errors while writing it, but those errors actually helped me learn a lot.

I tried implementing a Perceptron.
The code doesn't use Generics or lifetime yet-honestly I haven't understood them so far.

When I use Laravel before, I only knew MVC and Controller was very messy.
This time, I tried to think about responsibilities and put this Rust code in an "entities" folder.
It feels like a big step forward for me!

There are still problems, though.
First, the inner product calculation is repeated in every function.

let sum: f64 = gate.inputs.iter().zip(gate.weights.iter())
            .map(|(x, w)| x * w).sum();

Second, I made a struct with an initialization function, but the bias isn’t working as expected.

The code runs, but the logic gates don’t always give the right output.

I left it as is for now—it’s part of my learning journey.

By the way, I also implemented the same logic gates in Python first.

Python feels very intuitive to me—it’s so easy to write and test quickly.

After finishing the Python version, I rewrote it in Rust.

This workflow works really well for me.

Here's my Python code for the AND gate:

def AND(x1, x2):
    inputs = np.array([x1, x2])
    weight = np.array([0.5, 0.5])
    bias = -0.7
    sum = np.sum(weight * inputs) + bias
    if sum <= 0:
        return 0
    else: 
        return 1

I love np.sum!!! It makes the math so simple and clean!

I’m still confused about &self vs Self in Rust.

I just bought "Programming Rust" (O’Reilly), so I’ll read it and write about what I learn next.

Thanks for reading!

My First Rust Lesson: String vs &str

tomomomomo — Sat, 08 Mar 2025 23:45:23 +0000

Today I’ve learned the difference between &str and String.
String is a wrapper of Vec, with capacity, len, and ptr.
&str is a reference to an existing string. It’s unchangeable.
To change it, you need a new String with a new heap area.
&str has no overhead.
If I want to make a Web app, there are so many places to use String.
But when I want to make an AI model, I might use &str more often, I think.

When I was using Laravel, I didn’t recognize the existence of heap and stack.　The two seem very interesting and attractive.

Yesterday, a very kind person told me about Rust’s two string types.
So I read about them in the book.
It’s a very nice start.
Thank you!

My New Journey Starts Today

tomomomomo — Sat, 08 Mar 2025 07:31:39 +0000

Yesterday, I quit my job. I was a web developer working with Laravel, building websites and APIs.

From today, I’m diving into Rust and Python. I’m a total beginner, but I’m eager to learn.

I’ve also decided to improve my English. I want to connect with people here, share my progress, and learn from you all.

Thanks for reading my first post! I’d love any tips for a newbie starting Rust, Python, or English.

Tags: #beginners #rust #python #english