DEV Community: Quinterabok

try this article

Quinterabok — Tue, 07 Oct 2025 20:44:58 +0000

Fly.io

Quinterabok ・ Oct 7

Fly.io

Quinterabok — Tue, 07 Oct 2025 20:39:43 +0000

Complete Fly.io Deployment Guide for Rails App

A beginner-friendly, step-by-step guide to deploying Ruby on Rails applications to Fly.io with Supabase database, custom domain, and email setup.

Prerequisites
Part 1: Install Fly CLI
Part 2: Set Up Supabase Database
Part 3: Deploy to Fly.io (Testing)
Part 4: Create Admin User
Part 5: Deploy to Production
Part 6: Buy and Connect Domain
Part 7: Set Up Email Forwarding
Part 8: Managing Your App
Troubleshooting

Prerequisites

Before starting, ensure you have:

✅ A Rails application ready to deploy
✅ Git installed and your code committed
✅ AWS S3 bucket set up for file storage (or similar)
✅ Terminal/Command line access
✅ Credit/debit card for domain purchase (~$10/year)

Cost Estimate:

Fly.io hosting: $5-10/month
Supabase database: FREE
Domain name: ~$10/year
Email: FREE (forwarding)
Total: ~$70-130/year

Part 1: Install Fly CLI

Step 1: Install Fly.io Command Line Tool

For macOS/Linux:

curl -L https://fly.io/install.sh | sh

For Windows (PowerShell):

powershell -Command "iwr https://fly.io/install.ps1 -useb | iex"

Step 2: Sign Up / Login

# Sign up for new account
fly auth signup

# Or login if you have an account
fly auth login

Follow the browser prompts to complete authentication.

Step 3: Verify Installation

fly version

You should see the Fly CLI version number.

Part 2: Set Up Supabase Database

Why Supabase?

✅ FREE tier (500MB database)
✅ Automatic backups
✅ Great dashboard
✅ Saves $38/month vs Fly Postgres

Step 1: Create Supabase Account

Go to: https://supabase.com
Click "Start your project"
Sign up with GitHub, Google, or Email

Step 2: Create Organization (First Time)

Enter organization name (e.g., "My Company")
Click "Create organization"

Step 3: Create New Project

Fill in the form:

Name: your-app-name-prod (e.g., name-website-prod)
Database Password: Click refresh icon to generate
- IMPORTANT: Copy and save this password!
- Example: Kx9mP#vL2nQ8wR5t
Region: Choose closest to your users
- Southeast Asia (Singapore)
- West EU (Ireland)
- East US (North Virginia)
Pricing Plan: FREE (already selected)

Click "Create new project" and wait 1-2 minutes.

Step 4: Get Database Connection String

Click ⚙️ Settings (left sidebar)
Click "Database"
Scroll to "Connection string"
Click "URI" tab
Copy the connection string
Replace [YOUR-PASSWORD] with your actual password from Step 3

Example final URL:

postgresql://postgres.abcdefghijklmno:Kx9mP#vL2nQ8wR5t@aws-0-ap-southeast-1.pooler.supabase.com:6543/postgres

Save this URL - you'll need it soon!

Part 3: Deploy to Fly.io (Testing)

Step 1: Navigate to Your Project

cd /path/to/your-rails-app

Step 2: Initialize Fly.io App

fly launch --no-deploy

You'll be asked several questions:

Question 1: Copy existing fly.toml?

Answer: N (No) - Start fresh

Question 2: App name

Enter: your-app-test (e.g., name-website-test)

Question 3: Organization

Select: Personal (or your organization)

Question 4: Region

Select: Closest to you or your users (e.g., sin for Singapore)

Question 5: Tweak settings?

Answer: Y (Yes)

Step 3: Configure Settings in Browser

A browser window opens with configuration form:

Fill in:

App name: your-app-test (already filled)
Organization: Personal (already selected)
Region: Keep your selection
Internal port: 8080
VM Memory: 2GB (select from dropdown)
Postgres Provider: Select none (we're using Supabase)
Tigris Object Storage: Select Disabled (using S3)
Redis: Keep none
Sentry: Keep Disabled

Click "Confirm Settings"

Step 4: Set Environment Secrets

Back in your terminal, set your secrets:

Generate SECRET_KEY_BASE:

rails secret

Copy the output.

Set Database URL (from Supabase):

fly secrets set DATABASE_URL="postgresql://postgres.abc:yourpassword@aws-0-region.pooler.supabase.com:6543/postgres" --app your-app-test

Set Rails Secret:

fly secrets set SECRET_KEY_BASE="paste-secret-from-rails-secret-command" --app your-app-test

Set AWS S3 Credentials (if using S3):

fly secrets set AWS_ACCESS_KEY_ID="your-aws-key" --app your-app-test
fly secrets set AWS_SECRET_ACCESS_KEY="your-aws-secret" --app your-app-test
fly secrets set AWS_REGION="your-region" --app your-app-test
fly secrets set BUCKET_NAME="your-bucket-name" --app your-app-test
fly secrets set AWS_ENDPOINT_URL_S3="your-s3-endpoint" --app your-app-test

Verify All Secrets:

fly secrets list --app your-app-test

You should see all your secrets listed (shows digests, not actual values).

Step 5: Update fly.toml Configuration

Open fly.toml in your editor and ensure it looks like this:

app = 'your-app-test'
primary_region = 'sin'
console_command = '/rails/bin/rails console'

[build]

[env]
  PORT = '8080'
  RAILS_ENV = 'production'
  RAILS_LOG_TO_STDOUT = 'true'

[processes]
  app = './bin/rake litestream:run ./bin/rails server'

[http_service]
  internal_port = 8080
  force_https = true
  auto_stop_machines = 'stop'
  auto_start_machines = true
  min_machines_running = 0
  processes = ['app']

  [[http_service.checks]]
    interval = '10s'
    timeout = '2s'
    grace_period = '5s'
    method = 'GET'
    path = '/up'
    protocol = 'http'
    tls_skip_verify = false
    [http_service.checks.headers]
      X-Forwarded-Proto = 'https'

[[vm]]
  memory = '2gb'
  cpu_kind = 'shared'
  cpus = 1

Step 6: Deploy Your App

fly deploy --app your-app-test

Wait 3-5 minutes for the build and deployment to complete.

Watch logs in another terminal:

fly logs --app your-app-test

Step 7: Run Database Migrations

fly ssh console --app your-app-test -C "rails db:migrate"

Step 8: Test Your App

fly open --app your-app-test

Your app opens at: https://your-app-test.fly.dev

✅ Test Environment is Live!

Part 4: Create Admin User

Step 1: SSH into Your App

fly ssh console --app your-app-test

Step 2: Start Rails Console

./bin/rails console

Or:

bundle exec rails console

Step 3: Create Admin

Admin.create!(
  email: 'admin@example.com',
  password: 'TestPassword123!',
  password_confirmation: 'TestPassword123!'
)

Note: Replace Admin with User if your model is called User. Adjust fields based on your model.

Step 4: Verify Admin Created

Admin.last

Should show your newly created admin.

Step 5: Exit

exit  # Exit Rails console
exit  # Exit SSH

Alternative: One-Line Command

From your local terminal:

fly ssh console --app your-app-test -C "./bin/rails runner \"Admin.create!(email: 'admin@example.com', password: 'TestPassword123!', password_confirmation: 'TestPassword123!')\""

Step 6: Test Admin Login

Visit your app: https://your-app-test.fly.dev/admin
Login with credentials you just created
Verify everything works ✅

Part 5: Deploy to Production

Now that testing works, let's create a production environment.

Step 1: Create Production App

fly launch --no-deploy

Configuration:

App name: your-app-prod
Region: Same as test or closer to users
Tweak settings: Y (Yes)

Step 2: Configure Production Settings

In the browser form:

App name: your-app-prod
Region: Choose production region
Internal port: 8080
VM Memory: 2GB (more for production)
Postgres: none (using Supabase)
Tigris: Disabled

Click "Confirm Settings"

Step 3: Create Production Supabase Database

Option A: Use Same Database

Use the same Supabase database for production
Good for small projects
Cost: FREE

Option B: Create Separate Database (Recommended)

Go to Supabase dashboard
Create new project: your-app-prod
Get new DATABASE_URL
Keep test and production data separate ✅

Step 4: Set Production Secrets

# Generate NEW secret for production
rails secret

# Set database URL
fly secrets set DATABASE_URL="your-production-supabase-url" --app your-app-prod

# Set NEW secret key base
fly secrets set SECRET_KEY_BASE="new-secret-from-rails-secret" --app your-app-prod

# Copy AWS credentials (or use different production bucket)
fly secrets set AWS_ACCESS_KEY_ID="your-aws-key" --app your-app-prod
fly secrets set AWS_SECRET_ACCESS_KEY="your-aws-secret" --app your-app-prod
fly secrets set AWS_REGION="your-region" --app your-app-prod
fly secrets set BUCKET_NAME="your-production-bucket" --app your-app-prod
fly secrets set AWS_ENDPOINT_URL_S3="your-s3-endpoint" --app your-app-prod

# Verify
fly secrets list --app your-app-prod

Step 5: Update Production fly.toml

Open fly.toml and update:

app = 'your-app-prod'
primary_region = 'sin'

[env]
  PORT = '8080'
  RAILS_ENV = 'production'

[http_service]
  internal_port = 8080
  force_https = true
  auto_stop_machines = 'suspend'
  auto_start_machines = true
  min_machines_running = 1  # Keep 1 always running in production

[[vm]]
  memory = '2gb'
  cpu_kind = 'shared'
  cpus = 2  # More CPU for production

Step 6: Deploy Production

fly deploy --app your-app-prod

Wait for deployment to complete.

Step 7: Run Migrations

fly ssh console --app your-app-prod -C "rails db:migrate"

Step 8: Create Production Admin

fly ssh console --app your-app-prod -C "./bin/rails runner \"Admin.create!(email: 'admin@yourdomain.com', password: 'StrongProductionPassword123!', password_confirmation: 'StrongProductionPassword123!')\""

Save these credentials securely!

Step 9: Test Production App

fly open --app your-app-prod

Visit: https://your-app-prod.fly.dev

✅ Production is Live!

Part 6: Buy and Connect Domain

Step 1: Buy Domain from Namecheap

Why Namecheap?

✅ Cheapest overall (~$10/year)
✅ FREE privacy protection forever
✅ FREE email forwarding
✅ Easy DNS management
✅ Great support

Purchase Process:

Go to: https://www.namecheap.com
Search for your desired domain
Add to cart
At checkout:
- ✅ Check: WhoisGuard (Privacy Protection) - FREE
- ❌ Uncheck: PremiumDNS
- ❌ Uncheck: Email hosting
- ❌ Uncheck: Website builder
- ❌ Uncheck: SSL certificate
Complete purchase (~$10-13)

Step 2: Get Fly.io IP Addresses

# Get your production app's IPs
fly ips list --app your-app-prod

Output shows:

VERSION  IP                      TYPE    REGION
v4       66.241.125.202         public  global
v6       2a09:8280:1::a0:a7a4:0 public  global

Copy both IPs - you'll need them next!

Step 3: Add Domain to Fly.io

# Add main domain
fly certs add yourdomain.com --app your-app-prod

# Add www subdomain
fly certs add www.yourdomain.com --app your-app-prod

Example:

fly certs add name.com --app name-website-prod
fly certs add www.noblmed.com --app name-website-prod

Step 4: Configure DNS in Namecheap

Login to Namecheap:

Go to: https://www.namecheap.com
Click "Sign In"
Enter credentials

Go to Domain Management:

Click "Domain List" (left sidebar)
Find your domain
Click "Manage" button

Open Advanced DNS:

Click "Advanced DNS" tab

Delete Old Records:

Look for and DELETE any existing:

A Records with @ or blank host
CNAME Records with @ or blank host
Parking page records

Add New DNS Records:

Record 1 - A Record (IPv4):

Type: A Record
Host: @
Value: 66.241.125.202  (your IPv4 from Step 2)
TTL: Automatic

Click ✅ to save.

Record 2 - AAAA Record (IPv6):

Type: AAAA Record
Host: @
Value: 2a09:8280:1::a0:a7a4:0  (your IPv6 from Step 2)
TTL: Automatic

Click ✅ to save.

Record 3 - CNAME Record (WWW):

Type: CNAME Record
Host: www
Target: your-app-prod.fly.dev.  (note the dot at end!)
TTL: Automatic

Click ✅ to save.

Save All Changes:

Scroll to bottom and click "SAVE ALL CHANGES"

Step 5: Wait for DNS Propagation

Wait 10-30 minutes for DNS changes to spread worldwide.

Check DNS Status:

# Check main domain
dig yourdomain.com

# Check www subdomain
dig www.yourdomain.com

Or check online: https://www.whatsmydns.net/

Step 6: Verify SSL Certificates

After 15-20 minutes:

# Check main domain certificate
fly certs show yourdomain.com --app your-app-prod

# Check www certificate
fly certs show www.yourdomain.com --app your-app-prod

When ready, you'll see:

The certificate for yourdomain.com has been issued.
Status: Ready ✅

Step 7: Test Your Domain

Open browser and visit:

Both should:

✅ Load your website
✅ Show 🔒 padlock (secure HTTPS)
✅ Work perfectly!

🎉 Your Custom Domain is Live!

Part 7: Set Up Email Forwarding

Step 1: Enable Email Forwarding

In Namecheap (still on your domain's management page):

Look for "Mail Settings" or "Email Forwarding" section
Click "Add Forwarder" or "Enable Email Forwarding"

Step 2: Add Email Forwards

Create forwarding rules:

Example forwards:

Alias	Forwards To
admin@yourdomain.com	your-email@gmail.com
info@yourdomain.com	your-email@gmail.com
contact@yourdomain.com	your-email@gmail.com
support@yourdomain.com	your-email@gmail.com
hello@yourdomain.com	your-email@gmail.com

How to add each:

Click "Add Forwarder"
Alias: Enter admin (without @domain)
Forward to: Enter your Gmail
Click "Add" or ✅
Repeat for other addresses

Step 3: Save Email Settings

Click "Save Changes"

Step 4: Test Email Forwarding

Send test email to: admin@yourdomain.com
Check your Gmail inbox
Should receive within 1-2 minutes ✅

Step 5: Set Up Gmail "Send As" (Optional)

To reply from admin@yourdomain.com:

Open Gmail
Click ⚙️ Settings → "See all settings"
Click "Accounts and Import" tab
Find "Send mail as:"
Click "Add another email address"
Enter:
- Name: Your Name / Company
- Email: admin@yourdomain.com
- Uncheck "Treat as an alias"
Click "Next Step"
For SMTP, you need paid email service (Google Workspace, Zoho, etc.)

Note: Free forwarding only receives emails. To send, you need:

Google Workspace ($6/month)
Zoho Mail (free for up to 5 users)
Or reply from your Gmail (recipient sees Gmail address)

Part 8: Managing Your App

View App Status

# Check if app is running
fly status --app your-app-prod

# List all machines
fly machine list --app your-app-prod

# View recent logs
fly logs --app your-app-prod

Stop App (When Not in Use)

To save costs when not needed:

# Stop all machines
fly scale count 0 --app your-app-prod

What happens:

✅ App stops completely
✅ No compute charges (only storage)
✅ Visitors see "503 Service Unavailable"
✅ Database and files remain safe

Start App Again

# Start 1 machine
fly scale count 1 --app your-app-prod

What happens:

✅ App starts in 10-30 seconds
✅ Website works normally
✅ Everything restored

Auto-Stop Configuration

Edit fly.toml to automatically stop when idle:

[http_service]
  auto_stop_machines = 'stop'      # Auto-stop when no traffic
  auto_start_machines = true       # Auto-start when visitor arrives
  min_machines_running = 0         # Allow stopping completely

Benefits:

✅ Automatically stops after 5 minutes of no traffic
✅ Automatically starts when someone visits
✅ Saves money on low-traffic sites
⚠️ First visitor waits ~10 seconds for startup

For always-on production:

[http_service]
  auto_stop_machines = false
  auto_start_machines = true
  min_machines_running = 1  # Always keep 1 running

Restart App

fly apps restart your-app-prod

View Dashboard

fly dashboard --app your-app-prod

Opens web dashboard in browser.

SSH into App

fly ssh console --app your-app-prod

Run Rails Console

fly ssh console --app your-app-prod -C "./bin/rails console"

Update App

After making code changes:

# Commit changes to git
git add .
git commit -m "Your changes"

# Deploy update
fly deploy --app your-app-prod

# Watch deployment
fly logs --app your-app-prod

Scale Resources

# Add more memory
fly scale memory 4096 --app your-app-prod

# Add more machines
fly scale count 2 --app your-app-prod

# Change VM type
fly scale vm shared-cpu-2x --app your-app-prod

View Costs

fly orgs show

Shows your current usage and estimated costs.

Troubleshooting

Issue: "Database connection failed"

Solution:

# Verify DATABASE_URL is set
fly secrets list --app your-app-prod

# Re-set if needed
fly secrets set DATABASE_URL="your-correct-url" --app your-app-prod

# Restart app
fly apps restart your-app-prod

Issue: "DNS not resolving"

Solution:

Check DNS records in Namecheap
Verify IPs match: fly ips list --app your-app-prod
Wait 30 more minutes for propagation
Clear browser cache or try incognito

Issue: "SSL certificate not issued"

Solution:

# Check certificate status
fly certs show yourdomain.com --app your-app-prod

# If stuck, remove and re-add
fly certs remove yourdomain.com --app your-app-prod
fly certs add yourdomain.com --app your-app-prod

# Wait 15 minutes

Issue: "App not starting"

Solution:

# Check logs for errors
fly logs --app your-app-prod

# Common issues:
# - Missing SECRET_KEY_BASE
# - Wrong DATABASE_URL
# - Port configuration (should be 8080)

# Verify secrets
fly secrets list --app your-app-prod

# Check fly.toml port settings
cat fly.toml | grep port

Issue: "Can't create admin"

Solution:

# SSH into app
fly ssh console --app your-app-prod

# Check your model name
./bin/rails runner "puts User.column_names"
# or
./bin/rails runner "puts Admin.column_names"

# Create with correct fields
./bin/rails console
Admin.create!(email: 'test@example.com', password: 'password123', password_confirmation: 'password123')

Issue: "File uploads not working"

Solution:

# Verify S3 credentials are set
fly secrets list --app your-app-prod

# Should see:
# - AWS_ACCESS_KEY_ID
# - AWS_SECRET_ACCESS_KEY
# - AWS_REGION
# - BUCKET_NAME
# - AWS_ENDPOINT_URL_S3

# Test S3 connection in Rails console
fly ssh console --app your-app-prod -C "./bin/rails console"
# Then test upload

Issue: "Out of memory errors"

Solution:

# Check current memory
fly status --app your-app-prod

# Increase memory
fly scale memory 4096 --app your-app-prod

# Or reduce memory if overprovisioned
fly scale memory 1024 --app your-app-prod

Issue: "Emails not forwarding"

Solution:

Check Namecheap email forwarding settings
Verify Gmail isn't marking as spam
Wait 30 minutes for DNS changes
Test with different email provider

Get Help

# Fly.io community forum
# https://community.fly.io

# Fly.io documentation
# https://fly.io/docs

# View all Fly commands
fly help

# Get help for specific command
fly help deploy

Quick Command Reference

Deployment

# Initialize app
fly launch --no-deploy

# Deploy app
fly deploy --app your-app-name

# Deploy with specific fly.toml
fly deploy --app your-app-name --config fly.toml

App Management

# View status
fly status --app your-app-name

# View logs
fly logs --app your-app-name

# Restart app
fly apps restart your-app-name

# Stop app
fly scale count 0 --app your-app-name

# Start app
fly scale count 1 --app your-app-name

# Open app in browser
fly open --app your-app-name

SSH & Console

# SSH into app
fly ssh console --app your-app-name

# Run Rails console
fly ssh console --app your-app-name -C "./bin/rails console"

# Run one-off command
fly ssh console --app your-app-name -C "rails db:migrate"

Secrets

# List secrets
fly secrets list --app your-app-name

# Set secret
fly secrets set KEY="value" --app your-app-name

# Unset secret
fly secrets unset KEY --app your-app-name

Domain & SSL

# Add domain
fly certs add yourdomain.com --app your-app-name

# Check certificate
fly certs show yourdomain.com --app your-app-name

# List all certificates
fly certs list --app your-app-name

# Remove certificate
fly certs remove yourdomain.com --app your-app-name

Scaling

# Scale number of machines
fly scale count 2 --app your-app-name

# Scale memory
fly scale memory 2048 --app your-app-name

# Change VM type
fly scale vm shared-cpu-2x --app your-app-name

Database

# Run migrations
fly ssh console --app your-app-name -C "rails db:migrate"

# Create database
fly ssh console --app your-app-name -C "rails db:create"

# Seed database
fly ssh console --app your-app-name -C "rails db:seed"

# Reset database (CAREFUL!)
fly ssh console --app your-app-name -C "rails db:reset"

Cost Breakdown

Monthly Costs

Service	Cost	Notes
Fly.io Compute	$5-10/month	Depends on usage
Supabase Database	FREE	Up to 500MB
AWS S3 Storage	$1-5/month	Depends on files
Domain Name	~$1/month	$10-13/year
Email Forwarding	FREE	Via Namecheap
SSL Certificates	FREE	Via Let's Encrypt
Total	$7-16/month	$84-192/year

Ways to Save

Use auto-stop: App stops when not in use
Use free tier Supabase: Instead of paid Postgres
Share S3 bucket: Use same bucket for test/prod
Buy domain for multiple years: Slight discount
Use email forwarding: Instead of Google Workspace

Next Steps

After completing this guide, you can:

Add monitoring: Set up Sentry or error tracking
Add analytics: Google Analytics, Plausible, etc.
Set up CI/CD: GitHub Actions for auto-deploy
Add custom email: Google Workspace or Zoho
Scale up: Add more machines, memory, regions
Add CDN: Cloudflare for better performance
Set up backups: Automate database backups
Add staging: Create staging environment

Summary

You've learned how to:

✅ Install Fly CLI and set up account
✅ Create FREE Supabase database
✅ Deploy Rails app to Fly.io (test and production)
✅ Create admin users
✅ Buy and connect custom domain
✅ Set up FREE email forwarding
✅ Manage, stop, and start your app
✅ Troubleshoot common issues

Your app is now live with:

Custom domain with SSL
Professional email addresses
Free database
Scalable hosting
All for ~$7-16/month!

Congratulations! 🎉

Support & Resources

Fly.io Docs: https://fly.io/docs
Fly.io Community: https://community.fly.io
Supabase Docs: https://supabase.com/docs
Namecheap Support: https://www.namecheap.com/support
Rails Guides: https://guides.rubyonrails.org

Made with ❤️ for beginners

Understanding Rust Concepts

Quinterabok — Sat, 31 May 2025 05:59:48 +0000

What Are Data Structures?

Think of Data Structures Like Containers in Real Life

Imagine your kitchen:

Spice rack = Array/Vector (items in order, numbered shelves)
Dictionary = HashMap (look up word → definition)
Chain of paper clips = LinkedList (each connects to the next)

Why Do We Need Data Structures?

// Without data structures - messy!
let student1_name = "Alice";
let student1_grade = 85;
let student2_name = "Bob";
let student2_grade = 92;
// This gets crazy with 100 students!

// With data structures - organized!
let mut students = HashMap::new();
students.insert("Alice", 85);
students.insert("Bob", 92);
// Easy to add 100 more!

Ownership - The Heart of Rust

What Is Ownership? (Simple Analogy)

Think of ownership like owning a car:

Only ONE person can own a car at a time
When you sell your car, you can't drive it anymore
You can lend your car (borrow) but you're still the owner
When the owner dies, the car is destroyed

The Three Rules of Ownership

// Rule 1: Each value has exactly ONE owner
let x = String::from("Hello");  // x owns the string "Hello"

// Rule 2: When owner goes out of scope, value is dropped
{
    let y = String::from("World"); // y owns "World"
} // y goes out of scope here, "World" is destroyed

// Rule 3: There can only be one owner at a time
let a = String::from("Test");
let b = a;  // Ownership moves from 'a' to 'b'
// println!("{}", a); // ERROR! 'a' no longer owns anything
println!("{}", b); // This works, 'b' is the owner

Why Does Rust Do This?

Problem in other languages:

// C code - dangerous!
char* ptr1 = malloc(100); //memory allocation(malloc)
char* ptr2 = ptr1;  // Both point to same memory
free(ptr1);         // Memory freed
printf("%s", ptr2); // CRASH! Using freed memory

Rust solution:

// Rust prevents this at compile time!
let s1 = String::from("Hello");
let s2 = s1;  // s1 can no longer be used
// println!("{}", s1); // Compile error - prevents crash!

Understanding Move vs Copy

Some types are "Copy" (cheap to duplicate):

let x = 5;      // integers are Copy
let y = x;      // x is copied to y
println!("{} {}", x, y); // Both work! 5 5

Some types are "Move" (expensive to duplicate):

let s1 = String::from("Hello");  // String is not Copy
let s2 = s1;                     // s1 moves to s2
// println!("{}", s1);           // ERROR! s1 no longer valid
println!("{}", s2);              // OK! s2 owns the string

When Does Ownership Transfer?

fn take_ownership(s: String) {
    println!("I now own: {}", s);
} // s goes out of scope and is dropped

fn main() {
    let my_string = String::from("Hello");
    take_ownership(my_string);  // Ownership moves to function
    // println!("{}", my_string); // ERROR! No longer own it
}

Borrowing - Using Without Owning

What Is Borrowing? (Real Life Analogy)

Like borrowing a friend's book:

You can read it, but you don't own it
You must return it when done
The owner can't throw it away while you're reading
Multiple people can read it, but only one can write in it

Immutable Borrowing (Reading Only)

fn read_string(s: &String) {  // &String means "borrow a String"
    println!("I'm reading: {}", s);
    // I can read but not modify
} // Borrow ends here, ownership returns to caller

fn main() {
    let my_string = String::from("Hello");
    read_string(&my_string);  // Lend the string
    println!("I still own: {}", my_string); // Still have it!
}

Mutable Borrowing (Reading and Writing)

fn modify_string(s: &mut String) {  // &mut = mutable borrow
    s.push_str(" World");  // I can modify it
}

fn main() {
    let mut my_string = String::from("Hello");
    modify_string(&mut my_string);  // Lend it mutably
    println!("Modified: {}", my_string); // "Hello World"
}

The Borrowing Rules

// Rule 1: Many immutable borrows are OK
let s = String::from("Hello");
let r1 = &s;  // OK
let r2 = &s;  // OK
let r3 = &s;  // OK - multiple readers
println!("{} {} {}", r1, r2, r3);

// Rule 2: Only ONE mutable borrow at a time
let mut s = String::from("Hello");
let r1 = &mut s;  // OK
// let r2 = &mut s;  // ERROR! Can't have two mutable borrows
r1.push_str(" World");

// Rule 3: Can't mix mutable and immutable borrows
let mut s = String::from("Hello");
let r1 = &s;      // Immutable borrow
// let r2 = &mut s;  // ERROR! Can't borrow mutably while immutably borrowed
println!("{}", r1);

Why These Rules?

// Without rules, this could happen:
let mut vec = vec![1, 2, 3];
let first = &vec[0];        // Borrow first element
vec.clear();                // This would invalidate 'first'!
// println!("{}", first);   // CRASH! Reading invalid memory

// Rust prevents this:
let mut vec = vec![1, 2, 3];
let first = &vec[0];        // Immutable borrow
// vec.clear();             // ERROR! Can't modify while borrowed
println!("{}", first);      // Safe!

Lifetimes - How Long Do References Live?

What Are Lifetimes? (Simple Analogy)

Think of lifetimes like library book due dates:

Every borrowed book has a return date
You can't keep the book longer than allowed
The library (compiler) checks you return on time

Basic Lifetime Example

fn main() {
    let r;                // Declare a reference
    {
        let x = 5;        // x lives in this scope
        r = &x;           // r borrows x
    }                     // x dies here
    // println!("{}", r); // ERROR! r points to dead value
}

Why Do We Need Lifetime Annotations?

// This function is confusing to Rust:
fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x  // Return might come from x
    } else {
        y  // Or from y
    }
}
// Rust asks: "How long will the returned reference live?"

Adding Lifetime Annotations

// 'a is a lifetime parameter - like a generic type but for lifetimes
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
// This says: "The returned reference lives as long as the shorter of x or y"

fn main() {
    let string1 = String::from("long string is long");
    {
        let string2 = String::from("xyz");
        let result = longest(&string1, &string2);
        println!("The longest is {}", result); // OK - both live here
    }
    // result can't be used here because string2 is dead
}

Lifetime in Structs

// This struct holds a reference
struct ImportantExcerpt<'a> {
    part: &'a str,  // This reference must live as long as the struct
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");

    let i = ImportantExcerpt {
        part: first_sentence,  // Borrow from novel
    };

    println!("Excerpt: {}", i.part);
    // novel must live as long as 'i' exists
}

Data Structures

Vectors - Dynamic Arrays

Think of Vec like a expandable shelf:

Items are numbered (indexed)
Can add more items at the end
All items are the same type

// Creating vectors
let mut numbers = Vec::new();           // Empty vector
let mut fruits = vec!["apple", "banana"]; // With initial values

// Adding items
numbers.push(1);
numbers.push(2);
fruits.push("orange");

// Accessing items - two ways:
// 1. Panics if index doesn't exist
let first = numbers[0];  // Gets 1, panics if empty

// 2. Safe access - returns Option
match numbers.get(0) {
    Some(value) => println!("First: {}", value),
    None => println!("Vector is empty"),
}

// Iterating
for number in &numbers {
    println!("Number: {}", number);
}

// Ownership with vectors
let mut vec = vec![1, 2, 3];
let first = vec.remove(0);  // Takes ownership of element
println!("Removed: {}", first);
println!("Remaining: {:?}", vec); // [2, 3]

HashMap - Key-Value Storage

Think of HashMap like a phone book:

Look up by name (key) to get phone number (value)
Very fast lookups
No particular order

use std::collections::HashMap;

// Creating
let mut scores = HashMap::new();

// Adding data
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Red"), 50);

// Looking up - safe way
match scores.get("Blue") {
    Some(score) => println!("Blue team: {}", score),
    None => println!("Team not found"),
}

// Updating values - the entry API
let text = "hello world wonderful world";
let mut word_count = HashMap::new();

for word in text.split_whitespace() {
    let count = word_count.entry(word).or_insert(0);
    *count += 1;
}
println!("{:?}", word_count); // {"hello": 1, "world": 2, "wonderful": 1}

// Ownership considerations
let mut map = HashMap::new();
let key = String::from("color");
let value = String::from("blue");

map.insert(key, value);
// key and value are now owned by the map!
// println!("{}", key); // ERROR! No longer own key

LinkedList - Chain of Items

Think of LinkedList like a chain:

Each link points to the next
Easy to insert/remove in middle
Harder to find specific items

use std::collections::LinkedList;

let mut list = LinkedList::new();

// Adding items
list.push_back(1);    // Add to end
list.push_front(0);   // Add to beginning
list.push_back(2);

// Result: 0 -> 1 -> 2

// Iterating
for item in &list {
    println!("Item: {}", item);
}

// When to use LinkedList vs Vec:
// Vec: Almost always better (fast access, cache-friendly)
// LinkedList: Only when you frequently insert/remove in middle
//             AND you have pointers to the nodes

Putting It All Together - Practical Examples

Example 1: Student Grade Manager

use std::collections::HashMap;

struct Student {
    grades: Vec<f32>,
}

impl Student {
    fn new() -> Student {
        Student {
            grades: Vec::new(),
        }
    }

    fn add_grade(&mut self, grade: f32) {
        self.grades.push(grade);
    }

    fn average(&self) -> f32 {  // Note: &self (borrowing)
        if self.grades.is_empty() {
            0.0
        } else {
            self.grades.iter().sum::<f32>() / self.grades.len() as f32
        }
    }
}

fn main() {
    let mut class = HashMap::new();

    // Create students
    let mut alice = Student::new();
    alice.add_grade(85.0);
    alice.add_grade(92.0);

    let mut bob = Student::new();
    bob.add_grade(78.0);
    bob.add_grade(88.0);

    // Add to class
    class.insert("Alice", alice);
    class.insert("Bob", bob);

    // Calculate averages
    for (name, student) in &class {  // Borrow the HashMap
        println!("{}: {:.1}", name, student.average());
    }
}

Example 2: Understanding Ownership Flow

fn demonstrate_ownership_flow() {
    // Step 1: Create owned data
    let mut words = vec![
        String::from("hello"),
        String::from("world"),
        String::from("rust")
    ];

    // Step 2: Borrow for reading
    print_words(&words);  // words is borrowed, not moved

    // Step 3: Borrow for modification
    add_word(&mut words, String::from("programming"));

    // Step 4: Transfer ownership
    let processed = process_words(words);  // words moves into function

    // words is no longer accessible here!
    println!("Processed: {:?}", processed);
}

fn print_words(words: &Vec<String>) {  // Immutable borrow
    for word in words {
        println!("Word: {}", word);
    }
}  // Borrow ends here

fn add_word(words: &mut Vec<String>, word: String) {  // Mutable borrow
    words.push(word);
}  // Borrow ends here

fn process_words(words: Vec<String>) -> Vec<String> {  // Takes ownership
    words.into_iter()
        .map(|word| word.to_uppercase())
        .collect()
}  // Original words is dropped here

Common Mistakes and How to Fix Them

Mistake 1: Using After Move

// WRONG:
let s1 = String::from("hello");
let s2 = s1;
println!("{}", s1); // ERROR!

// RIGHT:
let s1 = String::from("hello");
let s2 = s1.clone(); // Explicitly clone
println!("{} {}", s1, s2); // Both work

Mistake 2: Multiple Mutable Borrows

// WRONG:
let mut vec = vec![1, 2, 3];
let r1 = &mut vec;
let r2 = &mut vec; // ERROR!

// RIGHT:
let mut vec = vec![1, 2, 3];
{
    let r1 = &mut vec;
    r1.push(4);
} // r1 scope ends
let r2 = &mut vec; // Now OK

Mistake 3: Returning References to Local Variables

// WRONG:
fn create_string() -> &str {
    let s = String::from("hello");
    &s // ERROR! s dies when function ends
}

// RIGHT:
fn create_string() -> String {
    String::from("hello") // Return owned value
}

Key Takeaways for Your Talk

Ownership prevents bugs - No more use-after-free or double-free
Borrowing is safe sharing - Read-only or exclusive write access
Lifetimes ensure safety - References can't outlive their data
Data structures work with the system - They respect ownership rules
Compile-time checking - Catch errors before they cause crashes

Building a Service Marketplace with Django: Lessons from Netfix

Quinterabok — Tue, 13 May 2025 01:34:16 +0000

As developers, we're constantly searching for the right tools to bring our ideas to life efficiently. When I decided to build Netfix, a service marketplace connecting companies with customers, I chose Django - and discovered features that make it uniquely powerful for complex applications.
In this article, I'll share deep technical insights from building Netfix, highlighting Django features that aren't commonly covered in tutorials but can dramatically improve your development workflow

Project Overview: Netfix

Netfix is a platform where:

Companies create profiles and list their services
Customers browse and request services
Each entity has personalized dashboards
Analytics track and display trending services
The system handles complex relationships between users, services, and requests

Let's dive into some of the most powerful features I leveraged

1. Custom User Models - The Right Way

Django's default user model works for simple applications, but for Netfix, I needed to support different user types with specific attributes. Here's how I implemented a custom user model:

from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager
from django.db import models

class UserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('Email is required')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password=None, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        return self.create_user(email, password, **extra_fields)

class User(AbstractBaseUser, PermissionsMixin):
    USER_TYPE_CHOICES = (
        ('customer', 'Customer'),
        ('company', 'Company'),
    )

    email = models.EmailField(unique=True)
    name = models.CharField(max_length=255)
    user_type = models.CharField(max_length=10, choices=USER_TYPE_CHOICES)
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)
    date_joined = models.DateTimeField(auto_now_add=True)

    objects = UserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['name', 'user_type']

    def __str__(self):
        return self.email

Then I created separate profile models for each user type:

# accounts/models.py
class CompanyProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='company_profile')
    company_name = models.CharField(max_length=255)
    description = models.TextField()
    logo = models.ImageField(upload_to='company_logos/', null=True, blank=True)
    website = models.URLField(null=True, blank=True)

    def __str__(self):
        return self.company_name

class CustomerProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='customer_profile')
    phone_number = models.CharField(max_length=20, null=True, blank=True)
    address = models.TextField(null=True, blank=True)

    def __str__(self):
        return self.user.name

Pro tip: When creating a custom user model, do it at the beginning of your project. Changing the user model mid-project is extremely challenging.

2. Signals for Automatic Profile Creation

One feature I love about Django is signals. They allow you to trigger actions when certain events occur. I used signals to automatically create appropriate profiles when a user registers:

from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import User, CompanyProfile, CustomerProfile

@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        if instance.user_type == 'company':
            CompanyProfile.objects.create(user=instance)
        elif instance.user_type == 'customer':
            CustomerProfile.objects.create(user=instance)

@receiver(post_save, sender=User)
def save_user_profile(sender, instance, **kwargs):
    if instance.user_type == 'company':
        instance.company_profile.save()
    elif instance.user_type == 'customer':
        instance.customer_profile.save()

3. Advanced QuerySets with Annotations for Service Analytics

For the trending services feature, I needed to count service requests and display them by popularity. Django's ORM provides powerful annotation capabilities:

from django.db.models import Count, F, ExpressionWrapper, fields
from django.db.models.functions import Now, ExtractDay
from datetime import timedelta
from .models import Service, ServiceRequest

def trending_services(request):
    # Calculate trending services based on request count in last 30 days
    thirty_days_ago = timezone.now() - timedelta(days=30)

    trending = Service.objects.annotate(
        request_count=Count('servicerequest', 
                           filter=models.Q(servicerequest__created_at__gte=thirty_days_ago))
    ).order_by('-request_count')[:10]

    return render(request, 'services/trending.html', {'trending_services': trending})

4. Custom Template Tags for Dynamic UI Elements

One lesser-known Django feature is custom template tags. I created a template tag to display service status with appropriate styling:

from django import template
from django.utils.safestring import mark_safe

register = template.Library()

@register.filter
def status_badge(status):
    colors = {
        'pending': 'warning',
        'accepted': 'info',
        'in_progress': 'primary',
        'completed': 'success',
        'declined': 'danger'
    }
    color = colors.get(status, 'secondary')
    return mark_safe(f'<span class="badge bg-{color}">{status.replace("_", " ").title()}</span>')

Then in templates:

{% load service_extras %}

<td>{{ service_request.status|status_badge }}

5. Class-Based Views with Mixins for Controlled Access

from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.views.generic import ListView, DetailView, CreateView, UpdateView

class CompanyRequiredMixin(UserPassesTestMixin):
    def test_func(self):
        return self.request.user.is_authenticated and self.request.user.user_type == 'company'

class ServiceCreateView(LoginRequiredMixin, CompanyRequiredMixin, CreateView):
    model = Service
    fields = ['name', 'description', 'price', 'category']
    template_name = 'services/service_form.html'

    def form_valid(self, form):
        form.instance.company = self.request.user.company_profile
        return super().form_valid(form)

6. Using Select Related and Prefetch Related for Performance

One challenge with relational data is the "N+1 query problem." Django's select_related and prefetch_related provide elegant solutions:

# Without optimization - this causes N+1 queries
def service_requests(request):
    requests = ServiceRequest.objects.filter(service__company__user=request.user)
    # Each time we access requests.service, we make a new query
    return render(request, 'services/requests.html', {'requests': requests})

# With optimization
def service_requests_optimized(request):
    requests = ServiceRequest.objects.filter(
        service__company__user=request.user
    ).select_related(
        'service', 'customer'
    ).prefetch_related(
        'service__category'
    )
    # Now all related data is fetched in just 3 queries
    return render(request, 'services/requests.html', {'requests': requests})

7. REST Framework ViewSets for API Development

To provide a robust API for third-party integrations and future platform extensibility, I built a comprehensive API using Django REST Framework's ViewSets:

from rest_framework import viewsets, permissions
from .serializers import ServiceSerializer, ServiceRequestSerializer
from services.models import Service, ServiceRequest

class IsCompanyOrReadOnly(permissions.BasePermission):
    def has_permission(self, request, view):
        if request.method in permissions.SAFE_METHODS:
            return True
        return request.user.is_authenticated and request.user.user_type == 'company'

class ServiceViewSet(viewsets.ModelViewSet):
    serializer_class = ServiceSerializer
    permission_classes = [IsCompanyOrReadOnly]

    def get_queryset(self):
        queryset = Service.objects.all()
        category = self.request.query_params.get('category', None)
        if category:
            queryset = queryset.filter(category__slug=category)
        return queryset

    def perform_create(self, serializer):
        serializer.save(company=self.request.user.company_profile)

8. Advanced Form Processing with FormSets

For services with multiple attributes, I used Django's formsets:

from django.forms import inlineformset_factory
from .models import Service, ServiceAttribute

def service_create_with_attributes(request):
    AttributeFormSet = inlineformset_factory(
        Service, ServiceAttribute, 
        fields=('name', 'value'), 
        extra=3, can_delete=True
    )

    if request.method == 'POST':
        form = ServiceForm(request.POST)
        if form.is_valid():
            service = form.save(commit=False)
            service.company = request.user.company_profile
            service.save()

            formset = AttributeFormSet(request.POST, instance=service)
            if formset.is_valid():
                formset.save()
                return redirect('service-detail', pk=service.pk)
    else:
        form = ServiceForm()
        formset = AttributeFormSet()

    return render(request, 'services/service_with_attributes.html', {
        'form': form,
        'formset': formset
    })

9. Leveraging Django Admin for Quick Internal Tools

Django's admin site is incredibly powerful. I customized it for internal management:


from django.contrib import admin
from .models import Service, ServiceRequest, Category

@admin.register(Service)
class ServiceAdmin(admin.ModelAdmin):
    list_display = ('name', 'company', 'price', 'category', 'is_active')
    list_filter = ('is_active', 'category', 'company')
    search_fields = ('name', 'description', 'company__company_name')

    def get_queryset(self, request):
        qs = super().get_queryset(request)
        if request.user.is_superuser:
            return qs
        return qs.filter(company__user=request.user)

@admin.register(ServiceRequest)
class ServiceRequestAdmin(admin.ModelAdmin):
    list_display = ('service', 'customer', 'status', 'created_at')
    list_filter = ('status', 'created_at')
    date_hierarchy = 'created_at'

10. Middleware for Request Tracking

from .models import Service, ServiceView
from django.utils import timezone

class ServiceViewMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)

        # Check if this is a service detail page
        path_parts = request.path.strip('/').split('/')
        if len(path_parts) >= 3 and path_parts[0] == 'services' and path_parts[1] == 'detail':
            try:
                service_id = int(path_parts[2])
                service = Service.objects.get(id=service_id)

                # Record anonymous view
                ServiceView.objects.create(
                    service=service,
                    ip_address=self.get_client_ip(request),
                    user=request.user if request.user.is_authenticated else None,
                    viewed_at=timezone.now()
                )
            except (ValueError, Service.DoesNotExist):
                pass

        return response

    def get_client_ip(self, request):
        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
        if x_forwarded_for:
            ip = x_forwarded_for.split(',')[0]
        else:
            ip = request.META.get('REMOTE_ADDR')

Don't forget to add it to your settings:

MIDDLEWARE = [
    # ... other middleware
    'services.middleware.ServiceViewMiddleware',
]

Conclusion

Building Netfix with Django taught me how powerful and flexible the framework truly is. These advanced features - from custom user models to complex queries with annotations - enabled me to create a robust marketplace with clean, maintainable code.
What I appreciate most about Django is how it scales with your knowledge. As you discover more features, you can refactor and improve your application while maintaining backward compatibility

Understanding the Differences Between Maps and Slices in Go

Quinterabok — Wed, 19 Feb 2025 06:21:36 +0000

When working with data structures in Go, The two most commonly used types are slices and maps.They seem similar in some aspects , and behave differently when passed to a function or manipulated. Understanding this difference is crucial for writing efficient and maintainable Go code.

Maps in Go
A map in Go is implemented as pointer to runtime structure.it means that when you pass a map to a function , you are actually passing a pointer , not a copy of the entire map. Any modification made to the map inside a function are reflected in the original variable.

var Test = map[string]int{
    "age":    3,
    "amount": 20,
}
func main() {

    modifyTest(Test)
    //output for this will be modified Test
    fmt.Println(Test) // output map[amount:20]
}

func modifyTest(m   map[string]int) {

    delete(m, "age")
    fmt.Println(m)
}

Key Characteristics of Maps:

Passing a map to a function is equivalent to passing a pointer to the underlying data structure.
Changes made to a map within a function affect the original map.
Maps are inherently mutable and not safe for concurrent access without synchronization.
Unlike structs, maps do not enforce a fixed set of keys, making them harder to document and reason about in public APIs.

When to Use Maps

Maps are useful when you need a flexible data structure that can store key-value pairs dynamically. However, they should be used with caution in APIs where immutability and predictability are important. If you need a well-defined structure, consider using structs instead.

Slices in Go
A slice in Go is lightweight data structure build on top of an array. It consists of the three fields

Length (len): The number of elements in the slice.
Capacity (cap): The number of elements the slice can grow before reallocation.
Pointer: A reference to the underlying array where elements are stored.

When passing a slice to a function , Go copies three fields, the pointer remains the same. So modifying elements in the slice affects the original data, while appending to the slice can behave unexpectedly.

Key Characteristics of Slices:

A slice is passed as a copy of its metadata (length, capacity, and pointer).
Modifying slice elements inside a function affects the original slice.
Appending to a slice may create a new underlying array if the existing capacity is exceeded.
Changes to the length or capacity of a slice inside a function do not affect the original slice.


var nums = []int{2,0}

func main() {

    modifyNums(nums)
    //output for this will still remain value of nums
    fmt.Println(nums) // [2 0]
    fmt.Println("capacity",cap(nums)) // capacity 2
}

func modifyNums(nums []int) {

    nums = append(nums, 4)
    fmt.Println(nums) // [2 0 4]
    fmt.Println("capacity",cap(nums)) // capacity 4
}

Modifying slice elements inside a function affects the original slice.

func modifySlice(s []int) {
    s[0] = 100 // Modifies the original slice
    s = append(s, 200) // Creates a new slice if capacity is exceeded
    fmt.Println("Inside function:", s) // New slice may not be visible outside  [100 2 3 200]
}

func main() {
    nums := []int{1, 2, 3}
    modifySlice(nums)
    fmt.Println("Outside function:", nums) // Only element modification is visible [100 2 3]
}

Best Practices

Use maps when you need key-based lookups with dynamic keys.
Use slices when working with ordered collections of data.
Avoid using maps as a replacement for well-defined structs.
Always document functions that modify slices to prevent unexpected behavior.

Conclusion

Understanding the behavior of maps and slices in Go is essential for writing efficient and bug-free code. While both structures have their use cases, misusing them can lead to unintended side effects. By carefully choosing the right data structure and being mindful of how they behave when passed to functions, you can ensure that your Go programs are both performant and maintainable.

For, Four Ways: Mastering Loops in Go

Quinterabok — Fri, 07 Feb 2025 01:19:43 +0000

Go's elegance lies in its simplicity. While other languages offer multiple looping constructs (while, do-while, for, etc.), Go streamlines everything into a single, versatile keyword: for. Don't let this simplicity fool you—Go's for loop is remarkably flexible and powerful. Let's explore four essential ways to harness its capabilities.

1. The Classic For Loop

The traditional C-style for loop consists of three components: initialization, condition, and post-statement. This is perfect when you need precise control over your iteration:

func main() {
    // Print numbers from 1 to 5
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

Here's what each component does:

i := 1 - Initializes the counter
i <= 5 - Defines the continuing condition
i++ - Executes after each iteration

2. The While-Style Loop

Need a while loop? In Go, it's just a for loop with a condition. Simply omit the initialization and post statements:

func main() {
    for {
        fmt.Println("Forever and ever...")
        time.Sleep(time.Second)
        // Use 'break' to exit when needed
        if someCondition {
            break
        }
    }
}

This pattern is common in server programs, event listeners, and game loops.

3. The Infinite Loop

Sometimes you need a loop that runs indefinitely (until broken). Go makes this remarkably clean:

func main() {
    for {
        fmt.Println("Forever and ever...")
        time.Sleep(time.Second)
        // Use 'break' to exit when needed
        if someCondition {
            break
        }
    }
}

This pattern is common in server programs, event listeners, and game loops.

4. Range-Based Loop

The range keyword is your best friend when working with collections. It provides a clean way to iterate over arrays, slices, maps, strings, and channels:

// Iterating over a slice
numbers := []int{1, 2, 3, 4, 5}
for index, value := range numbers {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}

// Iterating over a map
ages := map[string]int{
    "Alice": 25,
    "Bob":   30,
    "Carol": 35,
}
for name, age := range ages {
    fmt.Printf("%s is %d years old\n", name, age)
}

The range form automatically handles the details of iteration, making your code more readable and less prone to errors.

Best Practices and Tips

1.Choose the Right Form:

Select the loop style that best fits your use case. Don't use a classic for loop when range would be clearer.

2.Break and Continue:

Remember you can use break to exit a loop early and continue to skip to the next iteration:

for i := 1; i <= 10; i++ {
    if i%2 == 0 {
        continue  // Skip even numbers
    }
    if i > 7 {
        break     // Stop after 7
    }
    fmt.Println(i)
}

3. Label Your Loops:

When working with nested loops, labels can help control which loop to break or continue:

outer:
    for i := 0; i < 3; i++ {
        for j := 0; j < 3; j++ {
            if i*j > 4 {
                break outer
            }
            fmt.Printf("i=%d, j=%d\n", i, j)
        }
    }

Conclusion

Go's for loop might seem basic at first glance, but its flexibility makes it a powerful tool in your programming arsenal. By mastering these four patterns, you'll be able to handle any iteration need that comes your way, from simple counting to complex data structure traversal.

How to Fix "No Go Packages Exist" Error in Go

Quinterabok — Fri, 07 Feb 2025 00:33:40 +0000

As a beginner in Go programming, you might encounter the frustrating "no Go packages exist" error when trying to run your code. Don't worry - this is a common issue that occurs when your Go module isn't properly set up. Let's walk through how to fix it.

What is a Go Module?
Go module is more than just source code - it's the foundation of your project that defines and manages all required dependencies. Think of it as a project manifest that tells Go exactly what your code needs to run successfully.

** Step-by-Step Solution
** 1. Create a Project Directory
Open your terminal and create a new directory for your project:


bash

How to Fix "go.mod file not found" Error in Go

Quinterabok — Fri, 31 Jan 2025 10:58:13 +0000

What is a Go Module?

A Go module is more than just source code - it's the foundation of your project that defines and manages all required dependencies. Think of it as a project manifest that tells Go exactly what your code needs to run successfully.

Step-by-Step Solution

1. Create a Project Directory

Open your terminal and create a new directory for your project:

mkdir myproject
cd myproject

2. Initialize the Go Module

Inside your project directory, initialize a Go module:

go mod init myproject

This command creates a go.mod file in your project's root directory. This file is crucial - it's what prevents the "no Go packages exist" error by defining your module and tracking its dependencies.

3. Create Your First Go File

Create a simple Go file to test your setup:

touch main.go

Open main.go in your text editor and add this basic code:

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

4. Run Your Program

Now you can run your Go program:

go run main.go

5. Working with Dependencies

If your project needs external packages:

1. Install dependencies using go get:

go get github.com/gorilla/mux

2. Clean up dependencies with:

go mod tidy

This ensures your go.mod and go.sum files are properly maintained.

Troubleshooting Common Errors

1. "No required module provides package" error

Solution: Run go mod tidy to clean up and validate dependencies

2. "Cannot find package" error

Solution: Verify that you've imported the package correctly and installed it using go get

3. "No Go files in directory" error

Solution: Double-check that you're in the correct directory and your main.go file exists

Best Practices

Always initialize a Go module before writing code
Keep your go.mod file in your project's root directory
Run go mod tidy after adding or removing dependencies
Use meaningful module names that reflect your project

With these steps and best practices, you should be able to avoid the "no Go packages exist" error and focus on writing your Go code.

DEV Community: Quinterabok

try this article

Fly.io

Quinterabok ・ Oct 7

Fly.io

Complete Fly.io Deployment Guide for Rails App

Table of Contents

Prerequisites

Part 1: Install Fly CLI

Step 1: Install Fly.io Command Line Tool

Step 2: Sign Up / Login

Step 3: Verify Installation

Part 2: Set Up Supabase Database

Why Supabase?

Step 1: Create Supabase Account

Step 2: Create Organization (First Time)

Step 3: Create New Project

Step 4: Get Database Connection String

Part 3: Deploy to Fly.io (Testing)

Step 1: Navigate to Your Project

Step 2: Initialize Fly.io App

Question 1: Copy existing fly.toml?

Question 2: App name

Question 3: Organization

Question 4: Region

Question 5: Tweak settings?

Step 3: Configure Settings in Browser

Step 4: Set Environment Secrets

Generate SECRET_KEY_BASE:

Set Database URL (from Supabase):

Set Rails Secret:

Set AWS S3 Credentials (if using S3):

Verify All Secrets:

Step 5: Update fly.toml Configuration

Step 6: Deploy Your App

Step 7: Run Database Migrations

Step 8: Test Your App

Part 4: Create Admin User

Step 1: SSH into Your App

Step 2: Start Rails Console

Step 3: Create Admin

Step 4: Verify Admin Created

Step 5: Exit

Alternative: One-Line Command

Step 6: Test Admin Login

Part 5: Deploy to Production

Step 1: Create Production App

Step 2: Configure Production Settings

Step 3: Create Production Supabase Database

Step 4: Set Production Secrets

Step 5: Update Production fly.toml

Step 6: Deploy Production

Step 7: Run Migrations

Step 8: Create Production Admin

Step 9: Test Production App

Part 6: Buy and Connect Domain

Step 1: Buy Domain from Namecheap

Purchase Process:

Step 2: Get Fly.io IP Addresses

Step 3: Add Domain to Fly.io

Step 4: Configure DNS in Namecheap

Login to Namecheap:

Go to Domain Management:

Open Advanced DNS:

Delete Old Records:

Add New DNS Records:

Save All Changes:

Step 5: Wait for DNS Propagation

Check DNS Status:

Step 6: Verify SSL Certificates

Step 7: Test Your Domain

Part 7: Set Up Email Forwarding

Step 1: Enable Email Forwarding

Step 2: Add Email Forwards

Step 3: Save Email Settings

Step 4: Test Email Forwarding

Step 5: Set Up Gmail "Send As" (Optional)

Part 8: Managing Your App

View App Status

Stop App (When Not in Use)