DEV Community: Jesee Jackson Kuya

Many Days Later

Jesee Jackson Kuya — Sat, 28 Mar 2026 01:04:20 +0000

I owe you an apology.
I said I was going to document my journey learning Rust daily…

Yeah… that didn’t happen 😅

Life happened. Work happened. Overthinking happened.

But I didn’t stop learning.

And honestly, that’s what matters.

So here we are — many days later.

Quick Recap

Last time, we:

Installed Rust
Built a simple guessing game
Learned basic syntax (let, mut, match, use)

At that point, Rust felt…

“Not that scary.”

But then I kept going.

And I finally met the thing everyone warns you about:

Ownership

The Project

Before we dive in, let me make this real.

I’m not just learning Rust for fun.

I’m building something.

A ride sharing app.

Think:

requesting rides
matching drivers
tracking trips
handling payments (eventually)

Why this?

Because it’s complex enough to force me to actually understand Rust, not just play with syntax.

So… What is Ownership?

Let me explain this in the simplest way possible.

Ownership is basically:

Who owns a piece of data in your program

And Rust is VERY strict about this.

Imagine This

You have money.

Only one person can own it at a time.

You can:

give it away
borrow it
or keep it

But you can’t have two real owners at the same time.

That’s exactly how Rust treats data.

Example Time

let s1 = String::from("hello");
let s2 = s1;

Looks harmless, right?

Wrong.

After this:

s1 is no longer valid
s2 now owns the data

If you try to use s1, Rust will stop you immediately.

Why Does Rust Do This?

Because Rust wants to prevent:

memory leaks
crashes
weird bugs

Languages like JavaScript or Python hide this from you.

Rust says:

“No. You will deal with memory properly.”

At first, it feels annoying.

Then you realize:

This is actually protecting you.

The First Confusing Moment

When I saw this, I was like:

Wait… why can’t I use s1 anymore?

It felt unnecessary.

But then it clicked.

Rust is making sure:

There is only one clear owner of data at any time.

Borrowing (This Saved Me)

Instead of giving away ownership, you can borrow.

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

    let len = calculate_length(&s1);

    println!("Length: {len}");
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

Notice this:

&s1

That & means:

“I’m borrowing this, not taking it.”

So:

s1 is still valid
the function just uses it temporarily

Real Life Meaning

Think of it like this:

Ownership → giving someone your car
Borrowing → letting someone drive your car

Big difference.

Why This Matters (Especially for My Project)

Remember the ride sharing app?

We’ll have:

users
drivers
trips
locations

Data will be moving everywhere.

Without ownership rules, things could get messy:

multiple parts of the app modifying the same data
crashes
inconsistent states

Rust prevents this at compile time.

Meaning:

Bugs are caught BEFORE the app runs.

That’s huge.

My Honest Experience

Ownership is:

confusing at first
frustrating in the beginning
but makes sense over time

I won’t lie…

I had to re-read parts of the Rust book multiple times.

But once it clicks, you start seeing:

“Oh… this is actually clean.”

What I’ve Learned So Far

After spending more time with Rust:

It forces discipline
It doesn’t allow shortcuts
It makes you think before coding

And I’m starting to understand why people say:

Rust changes how you think about programming

What’s Next

Now that ownership is (kind of) making sense…

Next up:

borrowing deeper
references
lifetimes (yes… that scary word)
and starting the ride sharing backend

Final Thoughts

I didn’t keep up with daily updates.

That’s on me.

But I didn’t quit.

And honestly, that’s the real journey.

We’re still going from:

0 → 1

Just not in a straight line.

RUST:MY JOURNEY FROM 0 TO 1(Day 1)

Jesee Jackson Kuya — Thu, 12 Mar 2026 08:50:06 +0000

You’ve probably heard the rumors and hype surrounding Rust.

The language that does everything.
The language developers fear.
The language AI supposedly struggles with.
The language companies are rewriting their entire codebases in.

And so on...

But how much of this is actually true?

This series is my journey to debunk the rumors. I want to see for myself what Rust is really about.

The goal is simple:

Learn Rust and ship a real product to production.

And I’ll track how many days it actually takes.

I’m a firm believer in learning the hard way, so instead of watching 50 tutorials on YouTube, I’ll be using the official Rust documentation:

The Rust Book

https://doc.rust-lang.org/book/

Installation

Installing Rust is surprisingly easy.

I’m using Manjaro Linux, which is Arch-based. On most Linux distributions, you can install Rust with a single command.

Open your terminal and run:

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

This installs Rust using rustup, the official installer and version manager.

Honestly, this might be one of the smoothest language installations I’ve ever done.

Important Note

There’s one thing that can cause installation errors.

Rust requires a C compiler during installation.

If you don't already have one installed, install gcc first.

On Arch / Manjaro:

sudo pacman -S base-devel

If the installation command fails, you can follow the official guide here:

https://doc.rust-lang.org/book/ch01-01-installation.html

Jumping Right Into Rust

The first example in the Rust book is a number guessing game.

Here’s the full code:

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

If you're new to Rust, this code might look a little unusual at first.

But surprisingly, it becomes readable pretty quickly.

Let’s break it down.

Understanding `use`

The first thing you notice is the code starting with:

use std::cmp::Ordering;
use std::io;
use rand::Rng;

The use keyword is essentially Rust’s import system.

It tells the compiler which functionality from other modules we want to use.

Think of it like:

Language	Import syntax
Python	`import random`
JavaScript	`import fs from "fs"`
Rust	`use rand::Rng`

For example:

use std::io;

This imports Rust’s input/output library so we can read input from the terminal.

And this line:

use rand::Rng;

imports a trait that allows us to generate random numbers.

Generating the Secret Number

This line creates the number the user must guess:

let secret_number = rand::thread_rng().gen_range(1..=100);

What’s happening here?

thread_rng() creates a random number generator.
gen_range(1..=100) generates a number between 1 and 100.

So every time the game runs, a new number is generated.

Variables in Rust

This line creates a variable:

let mut guess = String::new();

Two important things are happening here.

`let`

let declares a variable.

`mut`

Rust variables are immutable by default.

That means their value cannot change unless you explicitly say they can.

Example:

let x = 5;

This value cannot be changed.

But this can:

let mut x = 5;
x = 6;

Rust forces you to be explicit about mutation, which helps prevent bugs.

Reading User Input

This section reads input from the terminal:

io::stdin()
    .read_line(&mut guess)
    .expect("Failed to read line");

What this does:

Waits for user input
Stores it in the guess variable
Crashes with a helpful message if something fails

Rust prefers explicit error handling, which you’ll see a lot.

Pattern Matching

One of Rust’s most powerful features is pattern matching.

This block converts the input into a number:

let guess: u32 = match guess.trim().parse() {
    Ok(num) => num,
    Err(_) => continue,
};

Here’s what’s happening:

The program tries to convert the input into a number.
If it succeeds → use the number.
If it fails → ignore it and ask again.

This avoids crashes if the user types something like:

hello

Instead of breaking the program, Rust simply loops again.

Comparing the Guess

Now we compare the guess with the secret number.

match guess.cmp(&secret_number) {

Rust compares the values and returns:

Less
Greater
Equal

Then we print the appropriate message.

What I Learned on Day 1

After writing this small program, a few things became clear.

Rust is strict

Rust forces you to write safe code.

This can feel annoying at first, but it prevents many bugs.

Rust is very explicit

Nothing happens magically.

You must clearly state:

variable types
mutability
error handling

Rust is not as scary as people say

So far, it actually feels logical and structured.

Yes, the syntax is different, but it's not impossible to understand.

The Plan

The challenge continues.

My goal is to go from zero to production with Rust.

Over the next posts I will explore:

ownership
borrowing
lifetimes
crates
building a real project
deploying it

And eventually ship something real.

Final Thoughts

The hype around Rust is massive.

But after the first day, one thing is clear:
Rust is just another common language.

Let’s see how far this rabbit hole goes.

Zero-Downtime Go Module Updates Using AI and CLI Automation

Jesee Jackson Kuya — Sat, 10 May 2025 21:36:15 +0000

This is a submission for the Amazon Q Developer "Quack The Code" Challenge: Crushing the Command Line

What I Built

I built a CLI tool in Go that automates safe dependency upgrades in Go projects using Amazon Q Developer. The tool addresses the common pain point of manually updating dependencies, which is often error-prone and time-consuming due to compatibility issues. Here's what it does:

Auto-scans Go projects for outdated dependencies

Uses Amazon Q to generate AI-powered compatibility reports

Predicts potential code conflicts before upgrading

Automatically applies safe upgrades, runs tests, and opens a GitHub PR

The tool streamlines the entire upgrade pipeline while integrating AI-powered risk analysis before making any changes — something that's often missing in conventional dependency managers

Demo

Demo Flow:

    Run the CLI: ./q-dep-updater -path=~/dev/myproject -repo=me/myproject

    See predicted conflicts before upgrades

    PR automatically created once tests pass

Code Repository

🔗 GitHub Repository – cli-rules

How I Used Amazon Q Developer

Amazon Q Developer was the intelligence behind this tool. I used the q chat CLI interface to:

Scan the project and extract outdated dependencies in structured JSON

Predict compatibility conflicts based on code patterns and version diffs

Generate a compatibility report with AI-based suggestions for refactoring

By integrating Amazon Q directly into the upgrade workflow, I was able to:

Detect breaking changes before installation

Avoid unnecessary manual debugging

Ensure only conflict-free upgrades move forward

Tip:

I found Amazon Q Developer's ability to contextualize Go code very effective when fed with detailed prompts about version differences. Using structured output like JSON made it easy to integrate with the CLI logic.

Understanding Runes in Go

Jesee Jackson Kuya — Tue, 30 Jul 2024 12:01:10 +0000

Introduction to Runes
The American Standard Code for Information Interchange(ASCII) is a character set representing uppercase letters, lowercase letters, digits, and various punctuations and device-control characters. The issue with the ASCII is it does not include most characters used in the world like Chinese characters and other character sets used by different languages. This limitation led to the invention of Unicode characters. Unicode is a superset of ASCII; It contains all the characters present in today's global writing system and it assigns each character a special Unicode Code Point. This Unicode Code Point is known as runes in Golang.

Below is a representation of the ASCII table.

Oct   Dec   Hex   Char                        Oct   Dec   Hex   Char
────────────────────────────────────────────────────────────────────────
000   0     00    NUL '\0' (null character)   100   64    40    @
001   1     01    SOH (start of heading)      101   65    41    A
002   2     02    STX (start of text)         102   66    42    B
003   3     03    ETX (end of text)           103   67    43    C
004   4     04    EOT (end of transmission)   104   68    44    D
005   5     05    ENQ (enquiry)               105   69    45    E
006   6     06    ACK (acknowledge)           106   70    46    F
007   7     07    BEL '\a' (bell)             107   71    47    G
010   8     08    BS  '\b' (backspace)        110   72    48    H
011   9     09    HT  '\t' (horizontal tab)   111   73    49    I
012   10    0A    LF  '\n' (new line)         112   74    4A    J
013   11    0B    VT  '\v' (vertical tab)     113   75    4B    K
014   12    0C    FF  '\f' (form feed)        114   76    4C    L
015   13    0D    CR  '\r' (carriage ret)     115   77    4D    M
016   14    0E    SO  (shift out)             116   78    4E    N
017   15    0F    SI  (shift in)              117   79    4F    O
020   16    10    DLE (data link escape)      120   80    50    P
021   17    11    DC1 (device control 1)      121   81    51    Q

A Unicode Code Point uniquely identifies a character in Unicode, where runes represent these characters as numbers. For instance, rune 32 denotes a space character. In Golang, UTF-8 encoding is utilized for characters (Unicode code points), represented by a sequence of 1 to 4 bytes. This makes runes the preferred method for string manipulation in Golang, facilitating direct interaction with characters. As software evolves, developers increasingly use runes to manage Unicode complexities, ensuring applications support multilingualism, emojis, and other Unicode functionalities.

In Golang, a byte, an alias for uint8, spans 1 to 255, while a rune, aliasing int32, signifies a Unicode code point, with characters encoded using UTF-8. Runes empower developers to engage directly with characters.
Working with Runes in Golang
There are different ways to initialize a rune in Golang. Let's use the Japanese Yen as an example. The Unicode code point of the Yen is U+00A5.
To initialize the yen, we can do so directly with the character or the Unicode representation of the character. This representation can be as an integer or a hexadecimal. The yen can also be initialized by an escape sequence. This escapes the U and + of the Unicode code point making it to be \u00A5. The same escape as an octal escape will be \245.

package main


func main() {
   yen := '¥'                  //initializing with the rune literal
   japYen := 165               //initializing with an integer
   jYen := 0x00A5              //initializing with a hex
   japanYen := '\u00A5'        //initializing with escape sequence
   japnYen := '\245'
}

To print the rune as a character. You can use fmt.Printf with the %c or type cast the rune variable to a string.

package main


import "fmt"


func main() {
   yen := '¥'           // initializing with the rune literal
   japYen := 165        // initializing with an integer
   jYen := 0x00A5       // initializing with a hex
   japanYen := '\u00A5' // initializing with escape sequence
   japnYen := '\245'


   fmt.Printf("%c\n", yen)
   fmt.Printf("%c\n", japYen)
   // jYen is an int type, type cast it to rune then string to print the character.
   fmt.Println(string(rune(jYen)))
   fmt.Println(string(japanYen))
   fmt.Printf("%c\n", japnYen)
}

This program will print the '¥' character on the terminal as shown below.

\test$ go run .
¥
¥
¥
¥
¥
\test$

Slicing a string will give you a byte. In string manipulation, that is not ideal because as stated earlier; strings in go are encoded as a sequence 1 t0 4 bytes.
To get the individual characters in a string. Range over the string to get the runes.

package main


import "fmt"


func main() {
   str := "Happy Coding"


   // Range str to get the individual characters
   for _, v := range str {
       //This will print the characters one by one
       fmt.Println(string(v))
   }
}

The above code will print the individual characters as follows;

/test$ go run .
H
a
p
p
Y


C
o
d
i
n
g
/test$

To get the first character in a string. Range over, slicing it will give you the first byte, not the first character.

package main


import "fmt"


func main() {
  str := "💞 code"


  // slicing a string gives you a byte not the character
  // not ideal for string manipulation
  fmt.Println(string(str[0]))


  // Range str to get the first character
  for i, v := range str {
     if i == 0 {
        fmt.Println(string(v))
     }
  }
}

The first printing will give you this character ð. This is not the first character that you wanted. Ranging the string gives you the right character as shown below.

/test$ go run .
ð
💞
/test$

To better understand how to work with runes, let us develop a function that works as a Stconv.Atoi package where it takes a string and returns an integer type.

// Atoi takes a string and returns an int with an error message
func Atoi(str string) (int, error) {
   var num int
   neg := false //check for negative numbers
   // str[0] gives us a byte. In this case the first byte
   // since the negative sign is an Ascii character. It is encoded as 1 byte
   //non-ASCII characters are encoded as sequences of 2 to 4 bytes
   //Slicing, or indexing a string gives you a byte, not a rune
   if string(str[0]) == "-" {
       neg = true
       str = str[1:]
   }


   // To get the runes in the string, range over the string
   //Ranging a string gives you a rune, not a byte
   for _, v := range str {
       // In the ascii table. The characters 0 to 9 are arranged in order
       if v >= '0' && v <= '9' {
           // Let's say v is the character 5 with the rune of 54
           // subtracting 54 from the rune of 0 which is 49
           // gives you 5
           num = num*10 + int(v-'0')
       } else {
           // characters with runes less than 49 and
           // runes greater than 58 will return 0 and a
           // parsing error
           return 0, fmt.Errorf(" parsing %v: invalid syntax", str)
       }
   }
   if neg {
       num *= -1
   }
   return num, nil
}

Let’s write a program to test the function.

package main


import "fmt"


func main() {
  // I'm not checking for errors
  num, _ := Atoi("45")
  num1, _ := Atoi("89")
  // Print the sum of num and num1
  fmt.Println(num + num1)


  // I am checking for errors
  num2, err2 := Atoi("ax56")
  if err2 != nil {
     fmt.Println(err2)
  }
  // num2 will be zero
  fmt.Println(num2)
}

The above program will output the following;

/test$ go run .
134
parsing ax56: invalid syntax
0
/test$

In summary, runes in Golang are fundamental for handling Unicode characters effectively within strings. They provide a way to represent and process individual characters in a way that is essential for robust and internationalized software development.

DEV Community: Jesee Jackson Kuya

Many Days Later

Quick Recap

The Project

So… What is Ownership?

Imagine This

Example Time

Why Does Rust Do This?

The First Confusing Moment

Borrowing (This Saved Me)

Real Life Meaning

Why This Matters (Especially for My Project)

My Honest Experience

What I’ve Learned So Far

What’s Next

Final Thoughts

RUST:MY JOURNEY FROM 0 TO 1(Day 1)

Installation

Important Note

Jumping Right Into Rust

Understanding use

Generating the Secret Number

Variables in Rust

let

mut

Reading User Input

Pattern Matching

Comparing the Guess

What I Learned on Day 1

Rust is strict

Rust is very explicit

Rust is not as scary as people say

The Plan

Final Thoughts

Zero-Downtime Go Module Updates Using AI and CLI Automation

What I Built

Demo

Code Repository

How I Used Amazon Q Developer

Understanding Runes in Go

Understanding `use`

`let`

`mut`