DEV Community: James Faith

A Noob's Journey to Blockchain Development in Rust

James Faith — Mon, 02 Mar 2026 16:32:26 +0000

Introduction

When I picked up Rust, I wanted more than just another programming language. My goal was to build a foundation strong enough to carry me into blockchain development. I also decided to explore low-level programming , as opposed to Python and Javascript, which I was already familiar with (I know some will say Rust is a partial low-level language). I wanted to challenge and change how I think about systems programming.

This drive led me to my first hands-on project, setting the stage for bigger things ahead. This article is the first chapter of that journey. I'll share how I built a ticket validator CLI in pure Rust, what I learned along the way, and how this project fits into my larger roadmap: moving from Rust fundamentals to Solana, Near, and eventually Substrate (yeah, it seems like a lot, but I plan to explore features in these blockchains mentioned, with primary focus on Solana).

I'm taking a domain-based path here, applying what I learn directly to blockchain scenarios so I don't just memorize syntax and forget it. This approach helps me retain knowledge by building projects related to my goals.

The Reason I Picked Rust

Rust seemed like a good option due to current articles, videos, and reviews about its usage in production, highlighting its performance, safety, and memory management. Its strictness seemed like a nice choice if I intend to create a reliable blockchain that is to have a no-trust system.

I considered Go and Python, but Go seems not to be heavily used in the crypto world, and Python's dynamic types were a no, as I planned to go with a statically typed language. It is not as performant as Rust (and yes, I love Python). This is a personal opinion, as I have no desire to involve myself in language or framework wars.

Rust's borrow checker has caught memory bugs in my code that Python's flexibility might overlook, and its speed edges out Go in high-stakes blockchain environments where every millisecond counts.

With Rust chosen, the real test began: struggling and understanding its unique rules and rethinking my coding habits.

Learning Curve

Rust had me on the ropes😅🥲. The ownership system made me rethink my approach to data and usage before I even began coding. Each piece of data became extremely important to understand, not just another variable to use. I learnt to approach my code thinking about each data's lifetime to avoid using a value that has been dropped from memory and might create a dangling pointer (accessing data in memory that has been deleted).

Rust does not have a garbage collector, so it enforces rules that make you consider each piece of data and the memory it occupies on the system, be it on the stack or heap, since Rust automatically cleans data that goes out of scope.

This gave me more insight into how data used in my code is stored and accessed. For example, in my CLI project, I hit a wall trying to borrow a string after moving it to a function. Rust forced me to clone it instead, teaching me to plan data ownership upfront and avoid runtime errors that could plague a blockchain app.

Resources That Helped

The official Rust Book was my holy grail. I read it online chapter by chapter, focusing on text to skip bandwidth-heavy videos due to data limitations😅. Paired with Rustlings exercises (a ~50MB download of interactive CLI drills), it reinforced concepts like borrowing through hands-on fixes. This combo kept things practical and domain-focused, letting me apply lessons straight to blockchain ideas instead of being stuck in tutorial hell.

You can spin up an offline version of the rust book with rustup after installation:

rustup doc --book

for the standard library

rustup doc --std

Journey So Far

After getting to Chapter 12 of the Rust Book, I decided to create a ticket validator CLI app to implement what I've learned, as my goal is to link it to the blockchain and make a working app which allows users to buy and sell tickets for events, with minimal gas fees to maximize profits.

What does it do so far? In pure Rust, it handles basic ticket creation, validation, and hashing using crates like serde for JSON serialization and ed25519-dalek for signing secure checks, making it modular and efficient for future Web3 integration.

For now, this CLI serves as a solid proof of concept, showing Rust's power in action. I'll share more details about my progress with the ticket CLI app in future posts. This article is just an introduction.

Conclusion

Building the ticket validator taught me more than syntax. It showed me how Rust enforces discipline through ownership, error handling, and modular design. These lessons are exactly what I’ll need as I move into blockchain frameworks where reliability and security are non-negotiable. This project is just the beginning. Next, I’ll be working with Solana’s Anchor framework to mint tickets at scale.

If you’re also learning Rust or curious about blockchain, I hope my journey gives you a clear example of how starting small can lead to bigger systems. Follow along, and let’s grow together.

RESOURCES

Ticket Validator CLI: https://github.com/blackpandan/Ticket-Validator
Rust Book: https://doc.rust-lang.org/stable/book/index.html
Rustlings: https://rustlings.rust-lang.org/
Serde: https://serde.rs/
Ed25519-Dalek: https://docs.rs/ed25519-dalek/latest/ed25519_dalek/index.html

Setting Up Django Rest Framework

James Faith — Fri, 27 Nov 2020 22:06:27 +0000

Django Rest Framework (DRF)

Django framework is a powerful toolkit for building web API's

its comes with many interesting features which include:

a web_browsable_api
serialization that supports ORM

an API(application programming interface) gives us data when requests are sent to it.

this data is usually in the form of JSON(JavaScript Object Notation).

yes, it is not only for javascript

Django rest framework(DRF) helps us customize the requests handling and the outputs down to status codes.

to install it Django and python is required

python -m venv env

to create a virtual environment

pip install django

install django

pip install djangorestframework Markdown django-filter

install django rest framework

django-admin startproject api

start a django project
change directory to api/api
open settings.py
under installed apps
add the following lines to the end of the list

"rest_framework",
"rest_framework.authtoken"

change directory to the root api

python manage.py migrate

python manage.py runserver

Tech is your bestie

James Faith — Thu, 26 Nov 2020 16:46:39 +0000

A guide to getting comfortable in tech and overcoming impostor syndrome

Starting in tech is usually exciting, the fact that you just discovered, that you can do more with your computer or phone than you think gives you the trills, this makes you relate to quote by Nikola Tesla

I do not think there is any thrill that can go through the human heart like that felt by the inventor as he sees some creation of the brain unfolding to success. Such emotions make a man forget food, sleep, friends, love, everything.

but as time goes by you get involved with more people in the developer community, and you discover this vast ocean of knowledge, this makes you happy, but at the same time, you feel that you just know only a drop of knowledge from that ocean compared to other programmers you see out there and it frightens you and makes you feel like you don't belong here.

this is pretty normal for everybody, but one thing I realized was that, I was just beginning my journey, you are just beginning your journey, those that are here before us, started from somewhere and there was a time they felt left out too, and if we look back we will discover that we have made great progress although it seams little,

from knowing what HTML means to playing around with javascript framework and knowing how to use API's its crazy,

but just know that you have come a long way, and some people are currently where you started, the best thing to do is to continue exploring that ocean of knowledge and enjoy doing it because that's what is important.

P.s always seek help from those above you

appreciations:

Photo by Fab Lentz on Unsplash

OG Photo by Emma Matthews Digital Content Production on Unsplash

Cover Photo by Drew Beamer on Unsplash

Intro to HTML5

James Faith — Thu, 26 Nov 2020 11:47:04 +0000

This is a continuation of the intro to web dev series,

Html means Hyper Text Markup Language it is used to design the structure of the page, and collect user inputs.

html deals with tags e.g

<!DOCTYPE html>

this is a simple html tag that is used for declaration of html5 , there are different versions of html , that's why a declaration is needed.

an example of a simple html5 structure:

 <!DOCTYPE html>
 <html>
   <head>
     <meta charset="utf-8" />
   </head>
   <body>
     <h1>hi there
   </body>
 </html>

we will go through most tags in this series

the first tag we will be looking at is the :

 <!DOCTYPE html>

as explained above it is used for declaration of html5

the next tag is the:

 <html> </html>

this tag is used to indicate the starting pointer of your html document
it is also used to declare the language to use e.g
```
 <html lang="en">
```

the next tag is the:

  <head> </head>

this tag is the head tag, it is used to contain data for the metadata which is the data for the about the html document, which will not usually be displayed, it is used to set the properties of the html document such as the style, view-port, character set, scripts e.t.c
```
 
<head> 
<meta charset="utf-8" />
<meta name="author" content="faith james" />
<script src="./index.js" />
<link type="text/css" rel="stylesheet"  href="./main.css" />
</head> 
```

the next tag is the :

  <body>  </body>

this tag is used to contain the content of the html document e.g paragraphs, headings, images, tables e.t.c
most of the content of this tags are visible in the browser.

example

<body>
 <h1>This is the first Heading </h1>
 <p> this is a paragraph </p>
 <img src="./sample.jpg" alt="this is a simple image" />
&lt/body>

we will discuss about more about tags in the next article in this series

Cover Photo by Vishnu R Nair on Unsplash

Photo by James Harrison on Unsplash

HTML Tutorial with mobile phone

James Faith — Fri, 20 Nov 2020 12:19:10 +0000

Setting up Acode

.
We will be continuing the web development series , click the link to check out the previous series, we are going to look at html5

First of all Goto your phone's appstore search Acode

or go to their website
https://acode.foxdebug.com

open the Acode app
click the kebab menu

click on open folder

click on internal storage

click the plus icon

click on new folder

rename it to learn

search and open the learn folder

click the plus icon again and create new file

rename the file to index.html

click on select folder

Click the hamburger menu ,then click the learn folder and your index.html

You just created your first HTML file, we will start talking about HTML tags in the next series

cover image source:
Greg Rakosy - unsplash

Intro to web development(a series) HTML5 to

James Faith — Fri, 20 Nov 2020 05:46:05 +0000

Web development in simply the process of creating a website, it can be divided into:

frontend (client side) and
backend (server side).

The frontend deals with what the user sees and what the user will experience, we use languages like:

HTML5, XML (for structure and data collection)
CSS (for the design) and
JavaScript (for sending request and Making the website more dynamic).

the backend deals with the storage and manipulation of data based on requests sent by the frontend, we use languages like:

php
python
C#
dart
java
we also use runtime environments like node.js.

HTML 5

We will be looking at HTML5 which is hyper text markup language, it is used to create the structure of the website, it is the foundation of a website, it makes use of tags for it's syntax e.g

<p> hello </p>

The series will continue....

Edited:
Part 2 - intro to HTML