Forem: Bobby

Hacktoberfest Repositories To Contribute To In 2025

Bobby — Mon, 29 Sep 2025 15:10:20 +0000

Hacktoberfest is nearly here again. It's the perfect time to make your first open source contribution or give some love to your favorite projects. Whether you're new to coding or have years of experience, there's always a way to help.

I've put together a short list of repositories that are beginner friendly and fun to work on. I'd also love for you to share your own projects in the comments so others can discover them too.

🐍 Python Projects

If you like Python, here are a few cool projects that welcome contributions:

CV Improver API - Django based API for improving CVs
Terminal Catacomb Crawler - A fun Python terminal game
Tix CLI - A Python based terminal to-do app

These are great for practicing your Python skills and building something useful at the same time.

🧰 Go and Dev Tools

Want to dive into Go or developer tooling? Check these out:

Diffium - A CLI tool that makes git diffs easier to understand. Super helpful if you work with AI coding agents.

JavaScript CLI Tools

pg-wire-mock - A mock PostgreSQL server for learning and hacking.

Both are great projects if you're into CLI tools and developer experience.

🌊 Laravel and SaaS

For PHP and Laravel fans:

Wave - A Laravel SaaS starter kit. You can help improve the docs, add translations, fix issues, or build plugins.

This one has an active community and is great for anyone building web apps with Laravel.

📚 Beginner Friendly Repos

These projects are great if you're just getting started. You can help by fixing typos, improving docs, adding examples, or tackling beginner issues.

All of these have a lot of small contributions that can make a big difference for new learners.

💬 Share Your Project

Hacktoberfest is all about collaboration and discovery. If you maintain a cool repo that people can contribute to, drop a link in the comments below. It doesn't have to be a big project. Even a small one with clear contribution guidelines can attract awesome contributors.

Getting Started with Docker Offload

Bobby — Thu, 10 Jul 2025 10:35:36 +0000

As a Docker Captain, I've tested plenty of features, but this one stands out. Docker Offload makes it possible to run builds and containers in the cloud without leaving your usual workflow.

Docker Offload was just announced at World Congress 2025 and it brings cloud execution to your local development flow

Whether you're building AI models, running compute-heavy workloads, or just tired of your fans going full throttle, this is for you.

💡 Why Docker Offload?

If you're working on large projects with limited local resources, you've probably felt the pain:

Slow build times
Inability to run GPU workloads locally
Inconsistent dev environments across the team

...and nobody wants that.

Docker Offload solves all that. You get access to high-performance cloud infrastructure with the same Docker CLI and Docker Desktop experience you're used to.

🚀 Key Features

Cloud builds and runs with no changes to your setup
GPU support out of the box (NVIDIA L4)
One command to start: docker offload start
Free trial minutes included
Works with Docker Compose and Model Runner

🧪 Getting Started

You'll need Docker Desktop 4.43 or later. You can go over the Docker Offload quickstart as well, but in a nutshell, it is just a matter of:

Sign into Docker Desktop
Start Offload:

docker offload start

Choose your account and enable GPU if needed
Run a container to test:

docker run --rm hello-world

Or for GPU:

docker run --rm --gpus all hello-world

To stop the session:

docker offload stop

🧠 Why This Is a Big Deal

If you're on an underpowered laptop: now you can run LLMs, big builds, and heavy services without blowing up your laptop.

If your team has mixed hardware: with Docker Offload everyone gets a consistent, fast environment.

If you're building agentic apps or running CI jobs: this makes local + cloud hybrid dev actually work.

💡 What You Can Do With Docker Offload

Docker Offload brings the power of the cloud into your local Docker workflow. Here are a few things you can do right away:

Build containers faster by offloading docker build to remote cloud machines with smart caching
Run GPU-heavy apps like machine learning pipelines, video processing, or LLM inference using NVIDIA L4 GPUs
Use Docker Compose to spin up full-stack apps in the cloud just like you do locally
Develop on low-powered machines or virtual desktops without worrying about performance limits
Run AI demos like Jupyter Lab, Hugging Face Transformers, or multi-agent systems without setting up any infra
Share the same cloud environment across your team, no matter what hardware they use
No special setup. No infra to manage. Just faster, smoother development with tools you already know.

🧵 Final Thoughts

Docker Offload makes serious development easier for everyone, whether you're solo or working in a team. You keep your local flow, but your containers run on machines that don't melt under pressure.

You can also check out the pricing details here.

Try it and let me know what you think in the comments!

Building Intelligent Search with AI Embeddings, Neon, and pgvector

Bobby — Fri, 20 Jun 2025 17:21:55 +0000

Traditional text search relies on exact keyword matches, which often misses the semantic meaning behind queries.

When someone searches for "car maintenance," they might also be interested in results about "vehicle servicing" or "auto repair", but keyword-based search won't make these connections.

AI embeddings solve this problem by converting text into high-dimensional vectors that capture semantic meaning. Words and phrases with similar meanings cluster together in this vector space, enabling search systems that understand context and intent rather than just matching exact words.

The pgvector extension brings vector similarity search directly into PostgreSQL, letting you store embeddings alongside your regular data and perform complex semantic searches with simple SQL queries. Combined with Neon's serverless PostgreSQL, you can build intelligent search systems that scale automatically with your application's needs.

In this guide, you'll learn how to build a semantic search system that can power document search and content recommendations using OpenAI embeddings stored in Neon with pgvector.

What you'll build

By the end of this guide, you'll have:

An understanding of AI embeddings and how they improve search
A Neon database configured with the pgvector extension
An embedding generation service powered by OpenAI's API
A document search system that understands semantic similarity

Prerequisites

To follow along with this guide, you'll need:

A Neon account with a project
An OpenAI API key
Node.js 20.x or later installed
Basic familiarity with SQL and REST APIs
Understanding of JavaScript promises and async/await

Understanding AI embeddings and vector search

Before diving into the implementation, let's understand how AI embeddings work and why they're great for search.

What are embeddings?

Embeddings are numerical representations of text that capture semantic meaning in high-dimensional space. When you send text to OpenAI's embedding API, it returns an array of floating-point numbers (typically 1,536 dimensions for the text-embedding-3-small model) that represents the "meaning" of that text.

Here's a simplified example of how embeddings work:

// These texts have similar meanings
const text1 = "The cat jumped over the fence";
const text2 = "A feline leaped across a barrier";

// Their embeddings would be mathematically similar
const embedding1 = [-0.02, 0.15, -0.08, ...]; // 1,536 numbers
const embedding2 = [-0.01, 0.16, -0.09, ...]; // Similar values

The key insight is that semantically similar texts produce similar embedding vectors. This enables search systems that can find relevant content even when it doesn't share exact keywords with the query.

Why pgvector?

pgvector extends PostgreSQL with vector data types and similarity search operations. Instead of moving your data to specialized vector databases, you can store embeddings alongside your existing relational data and perform vector similarity searches with SQL:

-- Find documents most similar to a query embedding
SELECT title, content,
       embedding <-> $1 as distance
FROM documents
ORDER BY embedding <-> $1
LIMIT 5;

The <-> operator calculates the distance between vectors, with smaller distances indicating higher similarity.

Now let's build a system that puts these concepts to work.

Setting up pgvector on Neon

We'll start by enabling pgvector on your Neon database and creating the necessary tables for our search system.

First, create a new Neon project optimized for vector operations:

Navigate to the Neon Console
Click "New Project"
Name your project "semantic-search-system"
Choose a region close to your users
Select at least 1 CU for compute size (vector operations can be CPU-intensive)

Once your project is created, we need to enable the pgvector extension. Connect to your database and run this SQL:

-- Enable the pgvector extension
CREATE EXTENSION IF NOT EXISTS vector;

-- Verify the extension is working
SELECT extversion FROM pg_extension WHERE extname = 'vector';

This command adds vector data types and similarity functions to your PostgreSQL database. You should see confirmation that the vector extension is now available.

Next, we'll create the database schema for our semantic search system. This includes tables for documents and their embeddings, along with indexes for fast vector similarity search.

-- Table for storing documents with their embeddings
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    content TEXT NOT NULL,
    category VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    embedding vector(1536) -- OpenAI's text-embedding-3-small produces 1536-dimensional vectors
);

-- Create indexes for fast vector similarity search
CREATE INDEX documents_embedding_idx ON documents USING ivfflat (embedding vector_cosine_ops);

The vector(1536) data type stores 1,536-dimensional vectors, matching OpenAI's embedding size. The ivfflat indexes enable fast approximate nearest neighbor searches using cosine similarity, this is crucial for performance when searching through thousands of embeddings.

Building an embedding generation service

Now we'll create a Node.js service that handles the complexities of generating embeddings with OpenAI's API. This service will be the bridge between your text content and the vector representations stored in the database.

Let's set up the project structure and install the necessary dependencies:

mkdir semantic-search-service
cd semantic-search-service
npm init -y
npm install openai pg dotenv express cors

Create a .env file to securely store your API credentials:

OPENAI_API_KEY=your_openai_api_key_here
DATABASE_URL=postgresql://user:password@ep-abc123.region.aws.neon.tech/neondb

Now let's create an embedding service that handles OpenAI API interactions. This service will preprocess text, generate embeddings, and handle errors gracefully:

// embedding.js
const OpenAI = require('openai');
require('dotenv').config();

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

class EmbeddingService {
  constructor() {
    this.model = 'text-embedding-3-small'; // Cost-effective and performant
    this.maxTokens = 8191; // Maximum tokens for this model
  }

  async generateEmbedding(text) {
    try {
      // Clean and prepare text for embedding generation
      const cleanText = this.preprocessText(text);

      const response = await openai.embeddings.create({
        model: this.model,
        input: cleanText,
      });

      return response.data[0].embedding;
    } catch (error) {
      console.error('Error generating embedding:', error);
      throw new Error(`Failed to generate embedding: ${error.message}`);
    }
  }

  preprocessText(text) {
    // Remove extra whitespace and normalize the text
    let cleaned = text.trim().replace(/\s+/g, ' ');

    // Truncate if too long (rough estimate: 1 token ≈ 4 characters)
    const maxChars = this.maxTokens * 3; // Conservative estimate
    if (cleaned.length > maxChars) {
      cleaned = cleaned.substring(0, maxChars) + '...';
    }

    return cleaned;
  }

  // Create optimized text for embedding generation
  createDocumentText(title, content, category = '') {
    return `Title: ${title}\nCategory: ${category}\nContent: ${content}`;
  }
}

module.exports = EmbeddingService;

This service handles a few important tasks: it preprocesses text to ensure it fits within OpenAI's token limits, combines document fields into optimized text for better embeddings, and provides error handling for API calls. The createDocumentText method is particularly important because it structures the input text in a way that produces better semantic embeddings.

As of the time of writing, OpenAI's text-embedding-3-small model is the newest and most cost-effective for generating embeddings.

Creating a document management system

Now we'll build a service that manages documents in our database and automatically generates embeddings for each document. This service will handle both individual documents and batch operations.

Let's create the document service that ties together our database and embedding generation:

// document-service.js
const { Pool } = require('pg');
const EmbeddingService = require('./embedding');
require('dotenv').config();

class DocumentService {
  constructor() {
    this.pool = new Pool({
      connectionString: process.env.DATABASE_URL,
      ssl: true,
      max: 20,
    });
    this.embeddingService = new EmbeddingService();
  }

  async addDocument(title, content, category = null) {
    const client = await this.pool.connect();

    try {
      await client.query('BEGIN');

      // Combine document fields into optimized text for embedding
      const fullText = this.embeddingService.createDocumentText(title, content, category || '');

      // Generate embedding using OpenAI API
      console.log(`Generating embedding for document: ${title}`);
      const embedding = await this.embeddingService.generateEmbedding(fullText);
      const formattedEmbedding = `[${embedding.join(',')}]`;

      // Store document with its embedding in the database
      const result = await client.query(
        `
        INSERT INTO documents (title, content, category, embedding)
        VALUES ($1, $2, $3, $4)
        RETURNING id, title, created_at
      `,
        [title, content, category, formattedEmbedding]
      );

      await client.query('COMMIT'); // Complete transaction

      console.log(`Document added successfully: ${result.rows[0].id}`);
      return result.rows[0];
    } catch (error) {
      await client.query('ROLLBACK'); // Undo changes on error
      console.error('Error adding document:', error);
      throw error;
    } finally {
      client.release(); // Return connection to pool
    }
  }

  async searchDocuments(query, limit = 10, category = null) {
    try {
      // First, convert the search query into an embedding
      const fullText = this.embeddingService.createDocumentText(query, '', category || '');
      const queryEmbedding = await this.embeddingService.generateEmbedding(fullText);

      // Format embedding as a pgvector-compatible string
      const formattedEmbedding = `[${queryEmbedding.join(',')}]`;

      // Start building the SQL query
      let sql = `
            SELECT 
                id,
                title,
                content,
                category,
                created_at,
                1 - (embedding <=> $1) as similarity_score
            FROM documents
            WHERE 1 - (embedding <=> $1) > 0.3
            `;

      const params = [formattedEmbedding];

      // Add category filter if needed
      if (category) {
        sql += ` WHERE category = $2`;
        params.push(category);
      }

      // Append ORDER BY and LIMIT clauses
      sql += ` ORDER BY embedding <=> $1 LIMIT $${params.length + 1}`;
      params.push(limit);

      const result = await this.pool.query(sql, params);

      // Format results
      return result.rows.map((row) => ({
        ...row,
        similarity_score: parseFloat(row.similarity_score.toFixed(4)),
        preview: row.content.length > 200 ? row.content.substring(0, 200) + '...' : row.content,
      }));
    } catch (error) {
      console.error('Error searching documents:', error);
      throw error;
    }
  }

  async getDocumentById(id) {
    try {
      const result = await this.pool.query(
        `
        SELECT id, title, content, category, created_at
        FROM documents 
        WHERE id = $1
      `,
        [id]
      );

      return result.rows[0] || null;
    } catch (error) {
      console.error('Error getting document:', error);
      throw error;
    }
  }
}

module.exports = DocumentService;

This service provides the core functionality for our semantic search system. The addDocument method generates embeddings and stores them alongside the document data, while searchDocuments performs the actual semantic search by converting queries to embeddings and finding the most similar documents using pgvector's distance operators.

The key insight here is the <=> operator in the SQL query, this calculates cosine distance between vectors, with smaller values indicating higher similarity. We convert this to a similarity score between 0 and 1 for easier interpretation.

The getDocumentById method retrieves a specific document by its ID, allowing applications to fetch full content when needed.

Building the search API

With our document service in place, let's create an Express API that exposes our document search capabilities to applications.

This API will provide endpoints for adding documents and performing semantic searches.

// server.js
const express = require('express');
const cors = require('cors');
const DocumentService = require('./document-service');
require('dotenv').config();

const app = express();
app.use(express.json());
app.use(cors());

const documentService = new DocumentService();

// Add a single document with automatic embedding generation
app.post('/documents', async (req, res) => {
  try {
    const { title, content, category } = req.body;

    // Validate required fields
    if (!title || !content) {
      return res.status(400).json({
        error: 'Title and content are required',
      });
    }

    // Add document and generate embedding
    const result = await documentService.addDocument(title, content, category);
    res.status(201).json(result);
  } catch (error) {
    console.error('Error adding document:', error);
    res.status(500).json({
      error: 'Failed to add document',
      message: error.message,
    });
  }
});

// Perform semantic search across all documents
app.post('/search', async (req, res) => {
  try {
    const { query, limit = 10, category } = req.body;

    if (!query) {
      return res.status(400).json({
        error: 'Search query is required',
      });
    }

    const startTime = Date.now();

    // Execute semantic search using vector similarity
    const results = await documentService.searchDocuments(query, limit, category);

    const searchTime = Date.now() - startTime;

    res.json({
      query,
      results,
      count: results.length,
      search_time_ms: searchTime,
    });
  } catch (error) {
    console.error('Error searching documents:', error);
    res.status(500).json({
      error: 'Search failed',
      message: error.message,
    });
  }
});

// Get a specific document by ID
app.get('/documents/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const document = await documentService.getDocumentById(parseInt(id));

    if (!document) {
      return res.status(404).json({ error: 'Document not found' });
    }

    res.json(document);
  } catch (error) {
    console.error('Error getting document:', error);
    res.status(500).json({
      error: 'Failed to get document',
      message: error.message,
    });
  }
});

// Health check endpoint
app.get('/health', async (req, res) => {
  try {
    // Test database connection
    await documentService.pool.query('SELECT 1');
    res.json({ status: 'healthy', database: 'connected' });
  } catch (error) {
    res.status(500).json({ status: 'unhealthy', database: 'disconnected' });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Semantic search service running on port ${PORT}`);
});

This API provides clean, RESTful endpoints for our semantic search functionality. The /search endpoint is the heart of the system, it takes natural language queries and returns semantically relevant documents, even when there are no exact keyword matches.

Notice how we measure and return the search time. This helps you monitor performance as your document collection grows.

Testing the semantic search system

With our API in place, now let's test our semantic search system to see how it finds relevant documents based on meaning rather than exact keywords. We'll add sample documents and run various search queries.

Create a test script to populate your database with sample content and test the search functionality:

// test-search.js
const axios = require('axios');

const baseURL = 'http://localhost:3000';

async function testSemanticSearch() {
  try {
    console.log('Adding sample documents to test semantic search...\n');

    // Add diverse sample documents across different topics
    const sampleDocuments = [
      {
        title: 'Getting Started with Machine Learning',
        content:
          'Machine learning is a subset of artificial intelligence that enables computers to learn and make decisions from data without being explicitly programmed. This guide covers the basics of supervised learning, unsupervised learning, and neural networks.',
        category: 'technology',
      },
      {
        title: 'Healthy Cooking Tips',
        content:
          "Eating nutritious meals doesn't have to be complicated. Focus on fresh ingredients, reduce processed foods, and try cooking methods like steaming and grilling. Meal prep can save time and help maintain a balanced diet.",
        category: 'health',
      },
      {
        title: 'Remote Work Best Practices',
        content:
          'Working from home requires discipline and good habits. Set up a dedicated workspace, maintain regular hours, and use collaboration tools effectively. Communication with team members is crucial for remote success.',
        category: 'productivity',
      },
      {
        title: 'Understanding Neural Networks',
        content:
          'Neural networks are computing systems inspired by biological neural networks. They consist of layers of interconnected nodes that process information. Deep learning uses multi-layered neural networks to solve complex problems.',
        category: 'technology',
      },
    ];

    // Add each document to the system
    for (const doc of sampleDocuments) {
      await axios.post(`${baseURL}/documents`, doc);
      console.log(`✓ Added: ${doc.title}`);
    }

    console.log('\nDocuments added successfully! Now testing semantic search...\n');

    // Test semantic searches that don't use exact keywords
    const testQueries = [
      'artificial intelligence and computers', // Should find ML and neural network docs
      'how to stay healthy while eating', // Should find cooking tips
      'working from home effectively', // Should find remote work practices
      'deep learning algorithms', // Should find both AI-related documents
    ];

    // Run each test query and display results
    for (const query of testQueries) {
      console.log(`🔍 Searching for: "${query}"`);

      const response = await axios.post(`${baseURL}/search`, {
        query,
        limit: 3,
      });

      const { results, search_time_ms } = response.data;

      console.log(`   Found ${results.length} results in ${search_time_ms}ms`);

      // Display the most relevant results
      results.forEach((doc, index) => {
        console.log(`   ${index + 1}. ${doc.title} (similarity: ${doc.similarity_score})`);
        console.log(`      Category: ${doc.category}`);
        console.log(`      Preview: ${doc.preview}\n`);
      });

      console.log('---\n');
    }
  } catch (error) {
    console.error('Test failed:', error.response?.data || error.message);
  }
}

// Start the server and run tests
console.log('Make sure your server is running with: node server.js\n');
testSemanticSearch();

Install axios for the test script and run it:

npm install axios

# Start your server in one terminal
node server.js

# Run the test in another terminal
node test-search.js

You should see output showing how the semantic search finds relevant documents even when the search terms don't appear exactly in the document text.

For example, searching for "artificial intelligence and computers" should return documents about machine learning and neural networks, demonstrating the power of semantic understanding.

The similarity scores help you understand how closely each result matches the query - scores closer to 1.0 indicate higher semantic similarity.

Performance optimization

As your document collection grows, you'll want to optimize performance.

First, let's properly configure the pgvector indexes. The default index settings work for small datasets, but you'll need to tune them for larger collections:

-- Drop existing indexes to recreate with optimal settings
DROP INDEX IF EXISTS documents_embedding_idx;

-- Create optimized indexes based on your data size
-- Rule of thumb: lists = rows / 1000, with minimum of 10
CREATE INDEX documents_embedding_idx ON documents
USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);  -- Adjust based on your document count

-- Update table statistics for optimal query planning
ANALYZE documents;

These indexes dramatically improve query speed by creating approximate nearest neighbor searches instead of comparing every vector.

The lists parameter should be adjusted based on your data size, more documents need more lists for optimal performance.

Conclusion

You now should have a solid foundation for a semantic search system that uses AI embeddings alongside pgvector in Neon.

You've built a simple semantic search system that demonstrates the power of AI embeddings with Neon and pgvector.

The foundation you've built can be extended with features like real-time search suggestions or multilingual support. The principles of semantic search and vector similarity will enable you to create intelligent applications that understand user intent and context.

Additional Resources

How to Write Unit Tests for Bash Scripts (The Simple Way)

Bobby — Mon, 14 Apr 2025 13:01:00 +0000

Introduction

If you enjoy writing Bash scripts to automate tasks, then you might ask yourself: "Can I write tests for my Bash scripts?".

The answer is: Yes, you can! And it's not hard at all.

🛠️ What You Need

We will use a tool called bats. It lets you write tests for Bash scripts in a clean and simple way.

To install it:

brew install bats-core  # On macOS
# OR
sudo apt install bats  # On Ubuntu/Debian

🧪 A Simple Bash Script Example

Let’s say you have this function in script.sh:

#!/bin/bash

say_hello() {
  echo "Hello, $1!"
}

✅ How to Test It

Create a file called test_script.bats:

#!/usr/bin/env bats

load './script.sh'

@test "say_hello prints the correct message" {
  run say_hello "Bobby"
  [ "$status" -eq 0 ]
  [ "$output" = "Hello, Bobby!" ]
}

Then run the tests with:

bats test_script.bats

🤖 Run Tests with GitHub Actions

You can also run the tests automatically using GitHub Actions.

Create a .github/workflows/test.yml file:

name: Bash Script Tests

on:
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Install BATS
        run: sudo apt-get update && sudo apt-get install -y bats
      - name: Run tests
        run: bats test_script.bats

Every time you push changes or open a pull request, your tests will run automatically. This helps you catch problems early.

📘 Learn More About Bash

If you are just starting with Bash scripting, I wrote a free and open-source book that explains the basics step by step:

Introduction to Bash Scripting

It covers loops, variables, functions, and more. Perfect for beginners.

If you want to try this on a cloud server, I use and recommend DigitalOcean. You'll get $200 in free credits for 60 days. Great for running your projects, testing scripts, or learning Linux.

If you have questions or want to chat more about Bash or DevOps, feel free to reach out on Twitter/X: @bobbyiliev_

If you are already working as a DevOps engineer, check out this DevOps Scorecard and evaluate your DevOps skills across 8 key areas and discover your strengths and growth opportunities

Thanks for reading and happy scripting!

- Bobby

7 Best SQL Books for Beginners

Bobby — Mon, 31 Mar 2025 16:31:26 +0000

Learning SQL doesn't have to be boring or overwhelming. With the right book, it can actually be fun and super rewarding.

Whether you're trying to level up your backend skills, work with data more efficiently, or build your first app with a real database, t'ese beginner-friendlSQL books will help you get started. I've included both free and paid options, so there's something for every budget.

1. Introduction to SQL (Free)

This free ebook is perfect for anyone starting their SQL journey. It covers the basics of SELECT statements, filtering data, using joins, and more. If you're brand new to SQL and want to get started today, this is a great resource.

👉 Download the ebook here

2. SQL for Data Analysis by Cathy Tanimura (Paid)

If you're into data, this book is for you. It teaches SQL in the context of real-world data analysis tasks. It's beginner-friendly, with practical examples that make it easy to follow along.

👉 Get the book on Amazon

3. Head First SQL by Lynn Beighley (Paid)

This is a super engaging and visual book that breaks down SQL concepts in a fun, approachable way. Perfect for beginners who want to avoid dry technical writing and learn by doing.

👉 Get the book on Amazon

4. Learning SQL by Alan Beaulieu (Paid)

A classic. It starts with the basics and takes you through everything from creating tables to writing complex queries. Clear explanations and practical exercises make it a solid resource for SQL newcomers.

👉 Get the book on Amazon

5. SQLBolt (Free)

Not a book, but a fantastic interactive tutorial that walks you through SQL concepts step by step. You can run queries right in the browser, g'eat for hands-olearners.

👉 Try SQLBolt

6. The Art of SQL by Stéphane Faroult (Paid)

Once you've got the basics down, this book will help you think like a SQL pro. It's less about syntax and more about strategy, h'w to write clean, efficienqueries.

👉 Get the book on Amazon

7. SQL Official Documentation (Free)

Not exactly a book, but if you ever get stuck, the docs are your best friend. Whether you're using PostgreSQL, MySQL, or SQLite, their official docs are gold mines of information.

👉 PostgreSQL Docs
👉 MySQL Docs
👉 SQLite Docs

Bonus: SQL Courses by Aaron Francis (Paid)

If you're ready to take your SQL skills to the next level, Aaron Francis has two phenomenal courses that go beyond the basics:

🚀 High Performance SQLite: Learn how to get the most out of SQLite, especially in production.
🐘 Mastering PostgreSQL: A deep dive into advanced PostgreSQL features like indexing, performance tuning, and query optimization.

Aaron's teaching style is clear, practical, and full of insights you can apply immediately. Follow him on X for even more great tips.

Conclusion

SQL is one of the most valuable skills you can learn as a developer or data enthusiast. With these beginner-friendly books and resources, you'll be writing queries and analyzing data in no time.

And if you want to practice your SQL skills on a real database, you can spin up a server with my DigitalOcean referral link and get $200 in free credit.

Already reading one of these books or have another favorite? Drop it in the comments, I'd love to check it out. Happy querying! 📊

Timeless Developer Skills: Building Solid Foundation for Long-Term Success

Bobby — Fri, 07 Mar 2025 10:57:01 +0000

As a developer who has worked with countless technologies over the years, I've realized something important: while frameworks and libraries come and go, certain fundamental skills remain invaluable throughout your career. Instead of constantly chasing the latest trend, mastering these timeless skills provides a strong foundation that will serve you regardless of industry changes.

1. ⚡ Algorithms and Data Structures

Why It Matters

Every piece of software processes data, and understanding how to efficiently organize and manipulate that data is essential. Mastering algorithms and data structures helps you develop a problem-solving mindset that transcends specific programming languages.

How to Learn

Implement fundamental structures like linked lists, stacks, and trees from scratch.
Solve classic problems on platforms like LeetCode and HackerRank, gradually increasing difficulty.
Analyze algorithms in your daily work - ask, "How would this scale with 10x more data?"
Build a small project that requires thoughtful data structure selection.
- For more in-depth learning, check out the Algorithms book by Robert Sedgewick and Kevin Wayne
- In addition to the above book, check out this GitHub repo: Awesome Algorithms

2. 🏗️ System Design and Scalability

Why It Matters

The ability to design scalable systems separates junior developers from architects. Understanding system design ensures your applications won’t collapse under growing workloads.

How to Learn

Study the architecture of successful open-source projects.
Practice designing systems on paper before implementing them, focusing on bottlenecks.
Explore comprehensive resources like System Design: The Complete Course.
Try scaling a simple app from handling 10 requests per second to 1000 and document what breaks first.

3. 🔄 Version Control and Git

Why It Matters

Version control is more than just tracking changes - it enables collaboration, rollback safety, and a clear project history. Mastering Git can significantly improve your workflow.

How to Learn

Move beyond commit, push, and pull - learn how to use branches effectively.
Master Git’s advanced features like interactive rebasing, cherry-picking, and bisect.
Check out this free ebook: Introduction to Git and GitHub.
Contribute to open-source projects to experience real-world Git collaboration.

4. 🗄️ SQL and Database Design

Why It Matters

Despite the rise of NoSQL databases, SQL remains the backbone of most applications. Understanding how to design efficient databases and optimize queries is an invaluable skill.

How to Learn

Design a schema for a real-world application, like an e-commerce platform.
Write increasingly complex queries, focusing on joins and aggregations.
Learn to read and interpret query execution plans for performance tuning.
Build a small CRUD application that emphasizes efficient database interactions.
Explore this free Introduction to SQL ebook.

5. 🖥️ Linux and Shell Scripting

Why It Matters

Most servers, cloud instances, and containers run Linux. Being proficient with Linux commands and shell scripting improves productivity and troubleshooting abilities.

How to Learn

Set up a Linux environment for daily development.
Perform common operations via the terminal instead of relying on GUIs.
Automate repetitive tasks with simple Bash scripts.
Check out this Introduction to Bash Scripting ebook.
Dive deeper with this Introduction to Linux book.

6. 🌍 Networking

Why It Matters

Understanding how data flows across networks helps with debugging, optimization, and building resilient applications.

How to Learn

Study the OSI model and where HTTP fits in.
Use tools like curl, Wireshark, and browser network debugging tools.
Build a simple REST API and analyze its network traffic.
Experiment with HTTP caching headers to observe their performance effects.
- Check out this Networking Fundamentals book.

7. ✨ Writing Clean Code and Debugging

Why It Matters

Most development time is spent reading code, not writing it. Writing clean, readable code saves hours of maintenance and reduces bugs.

How to Learn

Review and refactor your old code for readability.
Master debugging tools specific to your tech stack.
Study design patterns but focus on when to apply them.
Practice pair programming to get immediate feedback on code clarity.
- Check out the Clean Code book by Robert C. Martin.

8. 🔐 Security Best Practices

Why It Matters

Security must be a priority, not an afterthought. Understanding vulnerabilities and how to prevent them is essential for protecting applications and user data.

How to Learn

Study the OWASP Top 10 vulnerabilities with real-world examples.
Set up a deliberately vulnerable app (like DVWA) and practice exploiting and fixing issues.
Integrate security checks into your development workflow.
Perform regular security reviews of your code and applications.
- Check out Ross Anderson's Security Engineering book. It's free!

9. ☁️ Cloud and Infrastructure as Code

Why It Matters

Infrastructure as Code (IaC) has revolutionized application deployment and scaling. Mastering these skills enables reproducible environments and eliminates configuration drift.

How to Learn

Start a project on AWS, GCP, or Azure using their free tiers.
Learn Docker fundamentals with this Introduction to Docker.
Practice automation with this Introduction to Terraform book.
Build a CI/CD pipeline for automated deployments.

10. 🗣️ Soft Skills and Communication

Why It Matters

Technical expertise alone isn’t enough - strong communication and collaboration skills accelerate career growth and make teamwork more effective.

How to Learn

Practice explaining technical concepts to non-technical people.
Contribute to open-source projects to experience diverse collaboration.
Write technical blog posts to improve written communication skills on platforms like DEV.to and DevDojo
Learn how to give and receive constructive feedback effectively.

📍 Structured Learning Paths

If you prefer structured guidance on skill development, check out roadmap.sh. Their curated roadmaps for different specializations complement the timeless skills in this guide.

🎯 Final Thoughts

Developers who master these foundational skills adapt quickly to new technologies and frameworks. They recognize patterns over syntax, principles over commands, and solutions over isolated code snippets.

The key is to apply these skills through practical projects. Start small, build gradually, and learn from experienced developers. Mastery takes time, so focus on deep understanding and hands-on experience rather than surface-level knowledge.

📩 Want to Connect?

If you have questions or want to share your learning journey, reach out to me on Twitter @bobbyiliev_ or visit my blog at bobbyiliev.com!

Need a server for practice? Get a free $200 credit on DigitalOcean with my referral link: Free $200 Credit for DigitalOcean. Perfect for experimenting with Linux, Docker, and networking!

If you are already working as a DevOps engineer, check out this DevOps Scorecard and evaluate your DevOps skills across 8 key areas and discover your strengths and growth opportunities

How to Build Windows Docker Images with GitHub Actions

Bobby — Tue, 11 Feb 2025 12:25:28 +0000

Have you ever needed to build a Windows Docker image but don't have access to a Windows machine? In this guide, I'll show you how to leverage GitHub Actions to build Windows container images without needing a local Windows environment.

Why Build Windows Docker Images?

While Linux containers are more common, Windows containers are essential for:

.NET Framework applications
Windows-specific applications
Legacy Windows applications that need containerization
Applications that require Windows-specific features

Prerequisites

Before we start, you'll need:

A GitHub account
A Docker Hub account
A repository with your Dockerfile and application code
Docker Hub credentials configured as GitHub secrets

You can take a look at my example repository for reference.

The Dockerfile

Let's look at a sample Dockerfile that sets up a Python environment on Windows:

# Use a more recent Windows Server Core image
FROM mcr.microsoft.com/windows/servercore:ltsc2022

# Set shell to PowerShell
SHELL ["powershell", "-Command", "$ErrorActionPreference = 'Stop'; $ProgressPreference = 'SilentlyContinue';"]

# Download and install Python
RUN [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; \
    Invoke-WebRequest -Uri https://www.python.org/ftp/python/3.9.5/python-3.9.5-amd64.exe -OutFile python-3.9.5-amd64.exe ; \
    Start-Process python-3.9.5-amd64.exe -ArgumentList '/quiet InstallAllUsers=1 PrependPath=1' -Wait ; \
    Remove-Item python-3.9.5-amd64.exe

# Verify Python installation
RUN python --version

# Set the working directory
WORKDIR /app

# Copy application files
COPY . /app

# Set the startup command
CMD ["python", "app.py"]

This Dockerfile:

Uses the mcr.microsoft.com/windows/servercore:ltsc2022 base image
Installs Python 3.9.5
Sets the working directory to /app
Copies the application files to the container
Specifies the startup command as python app.py

Setting Up GitHub Actions

Create a .github/workflows/build.yml file in your repository:

name: Build Windows Docker Image

on:
  push:
    branches: [ main ]
  workflow_dispatch:

jobs:
  build:
    runs-on: windows-latest
    environment: prod
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Build and Push
        shell: powershell
        run: |
          docker build . -t ${{ secrets.DOCKERHUB_USERNAME }}/windows-python:latest
          docker push ${{ secrets.DOCKERHUB_USERNAME }}/windows-python:latest

How It Works

The workflow runs on windows-latest runner provided by GitHub Actions
It checks out your code
Logs into Docker Hub using your credentials
Builds the Windows Docker image
Pushes the image to Docker Hub
Displays the image digest for verification

Note that in this example, for simplicity, we're using the latest tag. In a production environment, you should use versioned tags and instead of hardcoding the image name, you can use environment variables.

Important Considerations

Image Size: Windows containers are typically larger than Linux containers. Plan your registry storage accordingly.
Build Time: Windows container builds usually take longer than Linux builds.
Compatibility: Ensure your base image version matches your deployment environment.

Resources

Want to learn more about Docker? Check out these resources:

Conclusion

GitHub Actions makes it possible to build Windows Docker images without a local Windows environment. This approach is particularly useful for cross-platform teams or developers primarily working on non-Windows systems.

If you're new to Docker and want to learn more, I've written a comprehensive free Docker eBook that covers all the basics and more.

Want to try this out but don't have a server? You can use my DigitalOcean referral link to get a free $200 credit!

Have questions or want to share your experience? Feel free to reach out to me on Twitter @bobbyiliev_.

5 Terraform Best Practices I Wish I Knew When I Started

Bobby — Fri, 31 Jan 2025 12:54:16 +0000

Introduction

Hey! I'm Bobby, a DevOps engineer and the author of the Introduction to Terraform ebook.

In this article, I'll share five Terraform best practices that I wish I knew when I first started using Terraform. These tips will help you write cleaner, more maintainable infrastructure as code and avoid common mistakes that can lead to deployment headaches.

Prerequisites

To follow along, you should have:

Basic knowledge of Terraform
Terraform installed on your system

If you're new to Terraform, I highly recommend checking out my Introduction to Terraform ebook, where I cover everything from the basics to managing infrastructure at scale.

Step 1 — Always Use Remote State Storage

By default, Terraform stores its state file (terraform.tfstate) locally. However, in real-world projects, this is not ideal because:

Local state files can be lost, leading to data inconsistencies.
Teams working together need a shared state to prevent conflicts.
Sensitive data may be exposed if the state file is not secured properly.

A better approach is to store your state remotely using Terraform Cloud. S3, or HashiCorp Consul.

Example: Storing Terraform State in AWS S3

terraform {
  backend "s3" {
    bucket         = "my-terraform-state"
    key            = "state/terraform.tfstate"
    region         = "us-east-1"
    encrypt        = true
    dynamodb_table = "terraform-lock"
  }
}

This setup:

Stores the state file in AWS S3.
Encrypts the state file for security.
Uses DynamoDB for state locking to prevent simultaneous updates.

💡 Tip: If you're using Terraform Cloud, it provides a built-in remote state storage and locking mechanism.

Step 2 — Use Modules to Keep Code DRY

One of the biggest Terraform mistakes is copy-pasting 🍝 infrastructure code across different projects. Instead, you should use Terraform modules to keep your configurations reusable and maintainable.

For example, instead of writing the same code for every EC2 instance, you can create a reusable module:

modules/
  ec2-instance/
    main.tf
    variables.tf
    outputs.tf

Example: A Simple EC2 Module (`main.tf`)

resource "aws_instance" "web" {
  ami           = var.ami_id
  instance_type = var.instance_type
  tags = {
    Name = var.name
  }
}

Then, in your main Terraform configuration, you can call the module:

module "web_server" {
  source        = "./modules/ec2-instance"
  ami_id        = "ami-12345678"
  instance_type = "t2.micro"
  name          = "web-server"
}

Benefits of using modules:

Define infrastructure once and reuse it.
Modify a single module rather than updating multiple files.
Keeps your main configuration files clean.

Step 3 — Implement Terraform Workspaces for Multi-Environment Deployments

When managing multiple environments (e.g., development, staging, production), many people initially copy-paste Terraform files. This leads to configuration drift and inconsistency.

A better approach is to use Terraform workspaces, which allow you to manage multiple environments with the same Terraform code.

Example: Switching Workspaces

terraform workspace new staging
terraform workspace list
terraform workspace select staging

Inside your Terraform configuration, use terraform.workspace:

resource "aws_s3_bucket" "example" {
  bucket = "my-app-${terraform.workspace}"
}

This automatically creates different S3 buckets based on the workspace (my-app-dev, my-app-staging, etc.).

💡 Tip: If you need more complex environment configurations, consider using separate state files rather than workspaces.

Step 4 — Lock Provider Versions to Avoid Unexpected Breakages

Terraform providers are updated frequently, and sometimes these updates introduce breaking changes. If you don’t lock provider versions, your infrastructure might suddenly stop working when running terraform apply.

Example: Locking Provider Versions

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0" # Locks to major version 5
    }
  }

  required_version = ">= 1.5.0"
}

By doing this:

You prevent unexpected changes when running Terraform commands.
Your infrastructure remains stable across deployments.

💡 Tip: Always test updates in a separate branch before upgrading provider versions in production.

Step 5 — Use Terraform Validate and Format Before Applying Changes

Before running terraform apply, it's good practice to validate and format your Terraform configuration to catch issues early.

Example: Checking Syntax with `terraform fmt` and `terraform validate`

terraform fmt  # Automatically formats code
terraform validate  # Checks for syntax errors

You can also automate this in a CI/CD pipeline to ensure code consistency:

name: Terraform CI

on: [push]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
    - name: Setup Terraform
      uses: hashicorp/setup-terraform@v1
    - name: Validate Terraform Code
      run: terraform validate

Using these commands ensures:

Your Terraform code follows best practices.
You catch issues before applying changes.
Your team follows a consistent formatting style.

Bonus Tip: Keep Secrets Secure with Environment Variables

Terraform configurations often require API keys, passwords, and database credentials. Hardcoding secrets in your .tf files is a major security risk.

Instead, use environment variables or a secrets manager.

Example: Using Environment Variables

export TF_VAR_db_password="supersecretpassword"
terraform apply

In Terraform:

variable "db_password" {}

resource "aws_db_instance" "example" {
  password = var.db_password
}

Better yet, use HashiCorp Vault or some other managed secrets managers for managing secrets securely.

Conclusion

These five best practices: using remote state, leveraging modules, implementing workspaces, locking provider versions, and validating Terraform code, will help you manage your infrastructure more efficiently.

If you're looking to dive deeper into Terraform, check out my paid ebook:

👉 Introduction to Terraform

And if you're setting up your Terraform infrastructure on DigitalOcean, you can get $200 in free credits to get started!

If you are already working as a DevOps engineer, check out this DevOps Scorecard and evaluate your DevOps skills across 8 key areas and discover your strengths and growth opportunities

Happy Terraforming! 🚀

7 Best Terraform Books for Beginners

Bobby — Mon, 27 Jan 2025 15:05:16 +0000

Terraform is a great tool for managing infrastructure as code, but getting started can be overwhelming without the right resources. Whether you're a developer, sysadmin, or cloud enthusiast, these beginner-friendly books and guides will help you take your first steps with Terraform.

I've included a mix of free and paid options to suit every learning style. Let's dive in!

1. Terraform Up & Running by Yevgeniy Brikman (Paid)

This is one of the most popular books for learning Terraform. It provides a comprehensive introduction to Terraform and progresses into advanced concepts like managing state, creating reusable modules, and scaling multi-cloud environments. The hands-on examples make it perfect for beginners and intermediate users.

👉 Get the book on Amazon

2. Introduction to Terraform (Paid)

This ebook is an excellent resource for developers, especially those working with DigitalOcean. It's beginner-friendly and focuses on using Terraform to manage infrastructure in a simple and cost-effective way. With clear examples for DigitalOcean users, it's perfect for learning how to automate and scale resources effortlessly.

Key benefits of learning with DigitalOcean:

Ease of use: Terraform and DigitalOcean are a great match for beginners.
Affordability: DigitalOcean's low-cost infrastructure makes it ideal for experimentation.
Practical examples: Includes step-by-step guides to create and manage resources like droplets and Kubernetes clusters.

👉 Get the ebook on Leanpub

3. Terraform in Action by Scott Winkler (Paid)

This hands-on guide covers everything from Terraform basics to advanced topics like testing, CI/CD, and custom providers. It's a great resource for anyone looking to take their Terraform skills to the next level, with real-world examples that make complex concepts easier to grasp.

👉 Get the book on Amazon

4. HashiCorp's Terraform Documentation (Free)

While not a book, the official Terraform documentation is an incredible free resource. It's beginner-friendly and regularly updated, covering everything from basic usage to advanced features like modules, backends, and provider configuration.

👉 Check out the official docs

5. The Terraform Book by James Turnbull (Paid)

This practical guide walks you through setting up your Terraform environment, creating reusable configurations, and managing infrastructure as code. It's straightforward and perfect for beginners who want to build a strong foundation in Terraform.

👉 Get the book on Amazon

6. Automating Multi-Cloud Infrastructure with Terraform by Mikael Krief (Paid)

If you're interested in multi-cloud environments, this book is a must-read. It explains how to use Terraform to manage resources across AWS, Azure, and Google Cloud, while emphasizing best practices for scalability and maintainability.

👉 Get the book on Amazon

7. Terraform Best Practices (Free)

This free online resource is a must-read for anyone looking to adopt best practices when working with Terraform. Whether you're a beginner or an experienced user, this guide provides actionable advice to help you write clean, efficient, and maintainable Terraform code.

👉 Get the book on here

Conclusion

Terraform makes managing infrastructure simple and efficient, and the right resources can make learning it much easier. Whether you start with the comprehensive Terraform Up & Running, dive into Introduction to Terraform for a DigitalOcean-focused approach, the key is to get started and experiment.

If you're looking for a cloud provider to practice with, DigitalOcean is a fantastic option. Use my DigitalOcean referral link to get $200 in free credit, perfect for building and testing your Terraform skills.

What are your favorite Terraform resources? Let me know in the comments below! 🌍✨

9 Best Linux Books for Beginners

Bobby — Thu, 09 Jan 2025 15:24:45 +0000

Learning Linux can feel like a daunting task, especially if you're just starting out. But the right resources can make all the difference.

Whether you’re a developer, system administrator, or simply someone curious about Linux, these beginner-friendly books will guide you through the essentials. I've included a mix of free and paid options, so there’s something for everyone!

1. 101 Linux Commands (Free)

This free ebook is perfect for Linux beginners who want to build a strong foundation. It covers 101 essential Linux commands with practical examples, making it a must-have guide for anyone getting started with the command line.

👉 Download the ebook here

2. Introduction to Linux (Paid)

If you want to dive deeper into Linux basics, this ebook is for you. It covers the fundamentals of Linux, including installation, file systems, and permissions. It's ideal for beginners looking to build a solid understanding of Linux.

👉 Get the book on Leanpub

3. Introduction to Bash Scripting (Free)

Learning Linux often starts with learning Bash scripting. This free ebook covers the basics of Bash scripting, from writing your first script to automating tasks. It’s beginner-friendly and great for anyone looking to become more efficient with Linux.

👉 Download the ebook here

4. The Linux Command Line by William Shotts (Free)

This classic guide is free to download and covers the Linux command line in detail. It starts with the basics and progresses to more advanced topics like scripting. Perfect for anyone who wants to become proficient in using the Linux terminal.

👉 Download it here

5. How Linux Works by Brian Ward (Paid)

This highly recommended book explains the inner workings of Linux. It covers everything from boot processes to file systems and is an excellent resource for those who want to understand how Linux operates behind the scenes.

👉 Get the book on Amazon

6. Linux for Beginners by Jason Cannon (Paid)

Aimed at beginners, this book breaks down complex Linux concepts into easy-to-understand lessons. It covers basic commands, file management, and shell scripting, making it a great resource for those just starting out.

👉 Get the book on Amazon

7. Linux Bible by Christopher Negus (Paid)

The Linux Bible is a comprehensive guide that’s great for beginners and intermediate users alike. It covers everything from basic commands to advanced system administration tasks. This book is a trusted resource for mastering Linux.

👉 Get the book on Amazon

8. GNU/Linux Advanced Administration by Remo Suppi Boldrito (Free)

This comprehensive guide is ideal for those who already have some Linux knowledge and want to level up their skills. It’s packed with practical tips and is freely available online.

👉 Download it here

9. Linux Official Documentation (Free)

Not exactly a book, but the Linux Documentation Project (LDP) offers free, high-quality guides for every skill level. From beginner tutorials to advanced topics, the LDP is a go-to resource for Linux learners.

👉 Check out the documentation

Conclusion

Linux is an incredibly powerful operating system, and with the right resources, anyone can learn to use it effectively. Whether you’re starting with free guides like 101 Linux Commands and The Linux Command Line or diving into paid guides like Linux Bible or How Linux Works, there’s something here for every skill level.

Remember, the best way to learn Linux is by experimenting. If you need a server to test on, you can use my DigitalOcean referral link to get $200 in free credit, perfect for setting up a Linux environment.

If you're into DevOps, you'll love DevOps Daily: it has free bite-sized exercises, tools, and guides to level up fast.

Have you read any of these books or know of other great Linux resources? Let me know in the comments. Happy learning! 🐧

5 Best Docker Books for Beginners

Bobby — Sun, 22 Dec 2024 13:42:40 +0000

Getting started with Docker can feel overwhelming, but having the right resources makes all the difference.

Whether you're a developer, sysadmin, or just curious about containerization, these beginner-friendly books and guides will help you take your first steps with Docker.

I’ve included a mix of free and paid options to fit different budgets, so there’s something for everyone!

1. Introduction to Docker (Free)

This free ebook is written specifically for beginners and covers Docker from the ground up. It starts with the basics—like what containers are—and walks you through creating and managing your first Docker containers. Since it’s available as a free download on GitHub, it’s a great starting point for anyone exploring Docker.

👉 Download the ebook here

2. The Docker Handbook by Farhan Hasin Chowdhury (Free)

Published by FreeCodeCamp, this is one of the best free resources for beginners. It’s straightforward and filled with practical examples. The book explains core Docker concepts and takes you through building and running containers, creating images, and even touches on Docker Compose.

👉 Read it on FreeCodeCamp

3. Docker Deep Dive by Nigel Poulton (Paid)

If you’re serious about learning Docker, this is one of the most comprehensive books available. Nigel Poulton explains Docker concepts in plain language and includes hands-on exercises to help you practice. Whether you’re learning about containers, volumes, or Docker Swarm, this book has you covered.

👉 Get the book on Amazon

4. The Docker Book by James Turnbull (Paid)

James Turnbull’s The Docker Book is a classic for Docker beginners. It offers a deep dive into the Docker ecosystem, from setting up your environment to deploying applications in containers. The book also introduces advanced concepts like networking and scaling containers.

👉 Get the book on Amazon

5. Docker in Action by Jeff Nickoloff and Stephen Kuenzli (Paid)

If you’re looking to go beyond the basics, Docker in Action is an excellent resource. The book combines beginner-friendly explanations with more advanced examples, like building CI/CD pipelines with Docker. It’s perfect for those who want to build practical Docker skills.

👉 Get the book on Amazon

6. Docker Official Documentation (Free)

Not exactly a book, but the Docker Docs are one of the best free resources available. They’re beginner-friendly, regularly updated, and include tutorials on everything from installation to advanced use cases. If you’re ever stuck, the official docs are a reliable place to look for answers.

👉 Check out the Docker Docs

Conclusion

Docker is a game-changer for developers and sysadmins, and learning it is easier than ever with the right resources. Whether you prefer free guides like Introduction to Docker and The Docker Handbook or want a deeper dive with books like Docker Deep Dive, the key is to just start!

The best way to learn Docker is by doing. If you don't have a server to experiment with, you can use my DigitalOcean referral link to get $200 in free credit. This is perfect for spinning up a droplet and trying out Docker in a real-world environment.

If you're into DevOps, you’ll love DevOps Daily: it has free bite-sized exercises, tools, and guides to level up fast.

If you've read any of these or have other Docker books to recommend, let me know in the comments. Happy containerizing! 🚀

Introducing Wave V3 – The Ultimate Laravel SaaS Starter Kit!

Bobby — Mon, 28 Oct 2024 11:27:55 +0000

Hey DEV community! 👋

I'm super excited to share that Wave V3 is officially here! 🎉 Wave is an open-source SaaS boilerplate built with Laravel and Livewire, designed to help you launch your SaaS product faster than ever. And yes – it’s completely free to get started!

What’s New in Wave V3?

After a year in the making, we’ve crafted Wave V3 to include everything you'd need to start a SaaS platform, with some fantastic new features:

🔐 Authentication – Secure login out of the box!
🪪 User Profiles – Customize profiles to keep users engaged.
🙋‍♂️ User Impersonations – Perfect for testing or admin support.
💳 Billing – Integrated with popular payment processors.
🛍️ Subscription Plans – Set up tiered plans easily.
🛡️ Roles and Permissions – Fine-tune access for different user roles.
📣 User Notifications – Keep your users informed in real time.
📘 Changelog – Document updates and release notes.
📰 Blog – Built-in blog to engage users with content.
📄 Pages – Add custom pages without hassle.
👨‍💻 API – Ready-to-go API to power integrations.
👑 Admin – Manage your app like a pro.
🎨 Themes and 🔌 Plug-ins – Customize your SaaS with easy-to-use themes and plugins.

We’ve also brought in Laravel Folio and Volt to make building even quicker. Whether you’re a seasoned Laravel dev or just getting started, Wave is designed to help you bring your next big idea to life, effortlessly.

Check it out on Product Hunt 🚀

Wave V3 is now live on Product Hunt, and we’d love your support! If you find Wave helpful or think it could be useful for others, please consider giving it an upvote. Your feedback and support are invaluable to us in making Wave even better!

And, of course, if you're curious about the code behind it, feel free to check out the repo on GitHub: Wave GitHub Repo.

Documentation 📚

For full details and setup instructions, dive into the Wave Docs and get started building your SaaS today!

Can't wait to see what you all create with Wave V3! 💪