DEV Community: Jesee Jackson Kuya

Building Buddy: A Full-Stack Travel App Powered by AWS Aurora PostgreSQL and Vercel

Jesee Jackson Kuya — Mon, 29 Jun 2026 11:41:19 +0000

Hackathon submission: This post was written as part of my entry for the H0: Hack the Zero Stack with Vercel v0 and AWS Databases hackathon, sponsored by AWS and Vercel. I used Amazon Aurora PostgreSQL as my database and deployed the entire application on Vercel.

What Is Buddy?

Travel is chaotic. You book a flight, then separately hunt for a hotel, then figure out how you're getting from the airport to your room. Three tabs, three confirmation emails, three things that can go wrong. Buddy is a travel management app that pulls all of it into one place — flights, hotels, and airport transport, coordinated under a single trip.

It's the kind of tool I would have wanted the last time I was scrambling to rearrange bookings after a delayed connection. So I built it.

The Stack at a Glance

Layer	Technology
Frontend & Backend	Next.js 15 (App Router)
Auth	NextAuth v5 (JWT, Credentials)
ORM	Prisma 5 with `driverAdapters`
Database	Amazon Aurora PostgreSQL
DB Connection	`pg` pool + `@prisma/adapter-pg`
IAM Auth	`@aws-sdk/rds-signer`
Hosting	Vercel
UI	Tailwind CSS + shadcn/ui + Framer Motion
Data fetching	TanStack Query + React Hook Form

Why Aurora PostgreSQL?

When the hackathon gave three database options — Aurora PostgreSQL, Aurora DSQL, and DynamoDB — the choice for a travel booking app was straightforward: relational data all the way.

Trips, flights, hotels, and transport bookings are deeply relational. A trip has many bookings. A booking references a specific flight, which belongs to an airline, which operates between two airports. A payment is tied to a booking. Notifications reference trips and users. Trying to model this in a document store would mean either deeply nested documents or endless manual joins in application code. A proper relational schema handles it cleanly.

Aurora PostgreSQL gave me everything I needed:

Full PostgreSQL compatibility — Prisma works with it out of the box.
High availability — Multi-AZ replication without managing it myself.
IAM authentication — Token-based DB auth without embedding a static password anywhere.
Scalable — Aurora scales read capacity independently; important for a search-heavy app like this.
Extensions — I used uuid-ossp, citext, and pg_stat_statements for UUIDs, case-insensitive text matching on emails, and query performance monitoring.

Designing the Database Schema

The schema covers seven main domains:

Users & Profiles
Trips
Flights → Flight Bookings
Hotels → Hotel Bookings
Transport Providers → Transport Bookings
Payments
Notifications

A few design decisions worth calling out:

Soft deletes everywhere. Every user-facing model has a deletedAt field. Booking history and audit trails matter in a travel context — you can't just hard-delete a payment record.

citext for emails. Email addresses are case-insensitive by convention but not by default in PostgreSQL. Using the citext extension means User@Example.com and user@example.com are treated as the same value at the database level, not in application code.

UUID primary keys. All IDs are uuid_generate_v4() defaults. No sequential integers that could be enumerated or guessed via the API.

Enum types. Booking statuses, payment statuses, trip types, and user roles are all PostgreSQL enums. The database enforces valid state values — the application layer can't accidentally insert a typo.

Connecting to Aurora: IAM Authentication

This was the most interesting engineering challenge. Rather than embedding a static database password, I wanted to use AWS IAM token authentication — Aurora generates a short-lived signed token that acts as the password, which is refreshed every 15 minutes.

Here's the core of how it works in lib/prisma.ts:

async function createIamClient(): Promise<PrismaClient> {
  const signer = new Signer({
    region: process.env.AWS_REGION,
    hostname: process.env.DB_HOST,
    port: Number(process.env.DB_PORT),
    username: process.env.DB_USER,
    credentials: {
      accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
      secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
    },
  })

  const token = await signer.getAuthToken()

  const pool = new Pool({
    host: process.env.DB_HOST,
    port: Number(process.env.DB_PORT),
    user: process.env.DB_USER,
    password: token,           // IAM token used as the password
    database: process.env.DB_NAME,
    ssl: { rejectUnauthorized: false },
  })

  const adapter = new PrismaPg(pool)
  return new PrismaClient({ adapter })
}

The client is cached on the global object with a 14-minute expiry — just under the 15-minute token TTL — and recreated automatically before it expires:

if (g.__prismaClient && now < (g.__prismaExpiry ?? 0)) {
  return g.__prismaClient   // reuse cached client
}
// otherwise: generate a new IAM token and reconnect

The exported prisma is a Proxy object that transparently awaits the async client on every call, so the rest of the codebase uses it like a normal synchronous Prisma instance.

If you're running without IAM auth (local dev with a direct connection string), you just set DB_IAM_AUTH=false and it falls back to a standard PrismaClient backed by DATABASE_URL.

The API Layer

The app exposes a clean set of REST endpoints under /api:

POST  /api/auth/register
GET   /api/flights/search
GET   /api/flights/[id]
POST  /api/flights/[id]/book
GET   /api/flights/bookings
GET   /api/hotels/search
GET   /api/hotels/[id]
POST  /api/hotels/[id]/book
GET   /api/hotels/bookings
GET   /api/trips
POST  /api/trips
GET   /api/trips/[id]
GET   /api/trips/[id]/timeline
GET   /api/transport
POST  /api/transport
POST  /api/payments
GET   /api/notifications
PATCH /api/notifications/[id]/read
GET   /api/airports
POST  /api/promotions/validate
GET   /api/profile
PUT   /api/profile

Each route is a thin handler that validates input with Zod and delegates to a domain service (flight.service.ts, hotel.service.ts, etc.) which executes Prisma queries. This keeps route files small and makes the business logic testable in isolation.

Authentication with NextAuth v5

Auth runs on NextAuth v5 (beta) with a Credentials provider. On login, the server:

Validates the submitted email/password with Zod.
Looks up the user in Aurora via Prisma (prisma.user.findFirst).
Compares the submitted password against the stored bcrypt hash.
Returns a JWT session containing the user's ID and role.

export const { handlers, auth, signIn, signOut } = NextAuth({
  ...authConfig,
  providers: [
    Credentials({
      async authorize(credentials) {
        const parsed = credentialsSchema.safeParse(credentials)
        if (!parsed.success) return null

        const user = await prisma.user.findFirst({
          where: { email: { equals: parsed.data.email, mode: 'insensitive' }, deletedAt: null },
          include: { profile: true },
        })

        if (!user || !user.passwordHash) return null
        const valid = await compare(parsed.data.password, user.passwordHash)
        if (!valid) return null

        return { id: user.id, email: user.email, role: user.role, ... }
      },
    }),
  ],
})

Route protection happens in middleware.ts, which checks the session before any protected path (/dashboard, /trips, /flights, etc.) reaches its page or API handler.

Deploying to Vercel

Deploying a Next.js app to Vercel is straightforward, but a Prisma-backed app has one extra requirement: the Prisma client needs to be generated from the schema during the build step. The default next build script doesn't do this.

The fix is a one-line change to package.json:

"build": "prisma generate && next build"

This ensures Vercel generates the typed Prisma client before the TypeScript compilation starts.

The environment variables that need to be set in the Vercel dashboard:

DATABASE_URL
NEXTAUTH_SECRET
NEXTAUTH_URL
DB_IAM_AUTH
DB_HOST
DB_PORT
DB_USER
DB_NAME
AWS_REGION
AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
NEXT_PUBLIC_APP_URL

What I Learned

IAM token rotation is elegant but has edge cases. The 15-minute token TTL meant I had to think carefully about long-lived serverless function instances re-using a stale connection. The 14-minute cache expiry with automatic reconnection handles this cleanly, but it's not something you'd think about with a traditional always-on server.

The Prisma adapter approach is worth the setup. Using @prisma/adapter-pg with a pg.Pool instead of Prisma's built-in connection pooling gives you much more control — especially important when the "password" is a dynamically generated token.

Soft deletes need discipline. Once you add deletedAt to a model, every query that should only return active records needs a where: { deletedAt: null } clause. I handled this at the service layer so it never leaks into route handlers, but it's easy to miss one.

Aurora PostgreSQL extensions are powerful. citext alone saved me from a whole class of subtle auth bugs where email casing could cause a user to fail login or accidentally create a duplicate account.

Architecture

The full architecture diagram is included in the repository (architecture.png), showing how the browser, Vercel platform, Next.js App Router, NextAuth, Prisma, and Aurora PostgreSQL all connect.

Wrapping Up

Buddy started as a frustration with how fragmented travel planning tools are. The H0: Hack the Zero Stack hackathon gave me the right constraints to build it properly — Aurora PostgreSQL for the data layer, Vercel for deployment — and pushed me to solve real infrastructure problems like IAM authentication and Prisma on serverless.

The result is a full-stack travel app that I'd actually use. Which, honestly, is the best thing you can say about something you built in a hackathon.

Built for the H0: Hack the Zero Stack with Vercel v0 and AWS Databases hackathon. Database: Amazon Aurora PostgreSQL. Hosting: Vercel.

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

Building Buddy: A Full-Stack Travel App Powered by AWS Aurora PostgreSQL and Vercel

What Is Buddy?

The Stack at a Glance

Why Aurora PostgreSQL?

Designing the Database Schema

Connecting to Aurora: IAM Authentication

The API Layer

Authentication with NextAuth v5

Deploying to Vercel

What I Learned

Architecture

Wrapping Up

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`