DEV Community: Tramposo

Database Interactions in Go: From SQL to NoSQL

Tramposo — Tue, 01 Oct 2024 12:34:09 +0000

Introduction

Go (Golang) has become a popular choice for building robust, high-performance backend services. One of the key strengths of Go is its excellent support for database operations, whether you're working with traditional SQL databases or modern NoSQL solutions. In this guide, we'll explore how to interact with databases in Go, covering both SQL and NoSQL approaches.

SQL Database Interactions
- Using the database/sql Package
- Working with an ORM: GORM
NoSQL Database Interactions
- MongoDB with the Official Go Driver
Best Practices and Common Pitfalls
Conclusion

SQL Database Interactions

Using the database/sql Package

Go's standard library provides the database/sql package, which offers a generic interface around SQL (or SQL-like) databases. This package is designed to be used in conjunction with database-specific drivers.

Let's start with a simple example using SQLite:

package main

import (
    "database/sql"
    "fmt"
    "log"
)

func main() {
    // Open the database
    db, err := sql.Open("sqlite3", "./test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Create table
    _, err = db.Exec(`CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT,
        age INTEGER
    )`)
    if err != nil {
        log.Fatal(err)
    }

    // Insert a user
    result, err := db.Exec("INSERT INTO users (name, age) VALUES (?, ?)", "Alice", 30)
    if err != nil {
        log.Fatal(err)
    }

    // Get the ID of the inserted user
    id, err := result.LastInsertId()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Inserted user with ID: %d\n", id)

    // Query for the user
    var name string
    var age int
    err = db.QueryRow("SELECT name, age FROM users WHERE id = ?", id).Scan(&name, &age)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("User: %s, Age: %d\n", name, age)
}

This example demonstrates the basics of working with SQL databases in Go:

Opening a database connection
Creating a table
Inserting data
Querying data

The database/sql package provides a low-level interface to the database, giving you fine control over your queries and operations.

Working with an ORM: GORM

While the database/sql package is powerful, many developers prefer using an Object-Relational Mapping (ORM) tool for more convenient database operations. GORM is one of the most popular ORMs for Go.

Here's an example of using GORM with SQLite:

package main

import (
    "fmt"
    "log"

    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

type User struct {
    ID   uint
    Name string
    Age  int
}

func main() {
    // Open the database
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        log.Fatal(err)
    }

    // Auto Migrate the schema
    db.AutoMigrate(&User{})

    // Create a user
    user := User{Name: "Bob", Age: 25}
    result := db.Create(&user)
    if result.Error != nil {
        log.Fatal(result.Error)
    }
    fmt.Printf("Inserted user with ID: %d\n", user.ID)

    // Query for the user
    var fetchedUser User
    db.First(&fetchedUser, user.ID)
    fmt.Printf("User: %s, Age: %d\n", fetchedUser.Name, fetchedUser.Age)

    // Update the user
    db.Model(&fetchedUser).Update("Age", 26)

    // Delete the user
    db.Delete(&fetchedUser)
}

GORM provides a higher-level abstraction over database operations, allowing you to work with Go structs directly instead of writing raw SQL queries. It also offers features like automatic migrations, hooks, and associations.

NoSQL Database Interactions

MongoDB with the Official Go Driver

For NoSQL databases, let's look at how to interact with MongoDB using the official Go driver:

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "go.mongodb.org/mongo-driver/bson"
    "go.mongodb.org/mongo-driver/mongo"
    "go.mongodb.org/mongo-driver/mongo/options"
)

type User struct {
    Name string `bson:"name"`
    Age  int    `bson:"age"`
}

func main() {
    // Set client options
    clientOptions := options.Client().ApplyURI("mongodb://localhost:27017")

    // Connect to MongoDB
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    client, err := mongo.Connect(ctx, clientOptions)
    if err != nil {
        log.Fatal(err)
    }

    // Check the connection
    err = client.Ping(context.TODO(), nil)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Connected to MongoDB!")

    // Get a handle for your collection
    collection := client.Database("test").Collection("users")

    // Insert a user
    user := User{Name: "Charlie", Age: 35}
    insertResult, err := collection.InsertOne(context.TODO(), user)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Inserted user with ID: %v\n", insertResult.InsertedID)

    // Find a user
    var result User
    filter := bson.M{"name": "Charlie"}
    err = collection.FindOne(context.TODO(), filter).Decode(&result)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Found user: %+v\n", result)

    // Update a user
    update := bson.M{
        "$set": bson.M{
            "age": 36,
        },
    }
    updateResult, err := collection.UpdateOne(context.TODO(), filter, update)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Updated %v user(s)\n", updateResult.ModifiedCount)

    // Delete a user
    deleteResult, err := collection.DeleteOne(context.TODO(), filter)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Deleted %v user(s)\n", deleteResult.DeletedCount)

    // Disconnect
    err = client.Disconnect(context.TODO())
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Connection to MongoDB closed.")
}

This example demonstrates the basic CRUD (Create, Read, Update, Delete) operations with MongoDB using the official Go driver.

Best Practices and Common Pitfalls

When working with databases in Go, keep these best practices in mind:

Use connection pooling: Both database/sql and most NoSQL drivers implement connection pooling. Make sure to reuse database connections instead of opening new ones for each operation.
Handle errors properly: Always check for errors returned by database operations and handle them appropriately.
Use prepared statements: For SQL databases, use prepared statements to improve performance and prevent SQL injection attacks.
Close resources: Always close result sets, statements, and database connections when you're done with them. The defer keyword is useful for this.
Use transactions when necessary: For operations that require multiple steps, use transactions to ensure data consistency.
Be mindful of N+1 query problems: When using ORMs, be aware of the N+1 query problem and use eager loading when appropriate.
Use context for timeouts: Use context to set timeouts on database operations, especially for long-running queries.

Common pitfalls to avoid:

Ignoring SQL injection vulnerabilities: Always use parameterized queries or prepared statements.
Not handling connection errors: Check for and handle connection errors, implementing retry logic if necessary.
Overusing GORM hooks: While convenient, overusing GORM hooks can lead to hard-to-debug issues.
Not indexing properly: Ensure your database schema is properly indexed for your query patterns.
Storing sensitive data in plaintext: Always encrypt sensitive data before storing it in the database.

Conclusion

Go provides robust support for both SQL and NoSQL database interactions. Whether you prefer the low-level control of database/sql, the convenience of an ORM like GORM, or working with NoSQL databases like MongoDB, Go got it for you.

Supercharge Your Go Web Service: Building a Custom Profiler

Tramposo — Fri, 27 Sep 2024 22:42:49 +0000

Introduction

As Go developers, we often reach for built-in profiling tools when optimizing our applications. But what if we could create a profiler that speaks our application's language? In this guide, we'll construct a custom profiler for a Go web service, focusing on request handling, database operations, and memory usage.

The Case for Custom Profiling

While Go's standard profiler is powerful, it might not capture everything specific to your web service:

Patterns in web request handling across different endpoints
Database query performance for various operations
Memory usage fluctuations during peak loads

Let's build a profiler that addresses these exact needs.

Our Sample Web Service

First, let's set up a basic web service to profile:

package main

import (
    "database/sql"
    "encoding/json"
    "log"
    "net/http"

    _ "github.com/lib/pq"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

var db *sql.DB

func main() {
    // Initialize database connection
    var err error
    db, err = sql.Open("postgres", "postgres://username:password@localhost/database?sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Set up routes
    http.HandleFunc("/user", handleUser)

    // Start the server
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleUser(w http.ResponseWriter, r *http.Request) {
    // Handle GET and POST requests for users
    // Implementation omitted for brevity
}

Now, let's build our custom profiler to gain deep insights into this service.

Custom Profiler Implementation

1. Request Duration Tracking

We'll start by measuring how long each request takes:

import (
    "time"
    "sync"
)

var (
    requestDurations = make(map[string]time.Duration)
    requestMutex     sync.RWMutex
)

func trackRequestDuration(handler http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        handler(w, r)
        duration := time.Since(start)

        requestMutex.Lock()
        requestDurations[r.URL.Path] += duration
        requestMutex.Unlock()
    }
}

// In main(), wrap your handlers:
http.HandleFunc("/user", trackRequestDuration(handleUser))

2. Database Query Profiling

Next, let's keep tabs on our database performance:

type QueryStats struct {
    Count    int
    Duration time.Duration
}

var (
    queryStats = make(map[string]QueryStats)
    queryMutex sync.RWMutex
)

func trackQuery(query string, duration time.Duration) {
    queryMutex.Lock()
    defer queryMutex.Unlock()

    stats := queryStats[query]
    stats.Count++
    stats.Duration += duration
    queryStats[query] = stats
}

// Use this function to wrap your database queries:
func profiledQuery(query string, args ...interface{}) (*sql.Rows, error) {
    start := time.Now()
    rows, err := db.Query(query, args...)
    duration := time.Since(start)
    trackQuery(query, duration)
    return rows, err
}

3. Memory Usage Tracking

Let's add memory usage tracking to complete our profiler:

import "runtime"

func getMemStats() runtime.MemStats {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    return m
}

func logMemStats() {
    stats := getMemStats()
    log.Printf("Alloc = %v MiB", bToMb(stats.Alloc))
    log.Printf("TotalAlloc = %v MiB", bToMb(stats.TotalAlloc))
    log.Printf("Sys = %v MiB", bToMb(stats.Sys))
    log.Printf("NumGC = %v", stats.NumGC)
}

func bToMb(b uint64) uint64 {
    return b / 1024 / 1024
}

// Call this periodically in a goroutine:
go func() {
    ticker := time.NewTicker(1 * time.Minute)
    for range ticker.C {
        logMemStats()
    }
}()

4. Profiler API Endpoint

Finally, let's create an endpoint to expose our profiling data:

func handleProfile(w http.ResponseWriter, r *http.Request) {
    requestMutex.RLock()
    queryMutex.RLock()
    defer requestMutex.RUnlock()
    defer queryMutex.RUnlock()

    profile := map[string]interface{}{
        "requestDurations": requestDurations,
        "queryStats":       queryStats,
        "memStats":         getMemStats(),
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(profile)
}

// In main():
http.HandleFunc("/debug/profile", handleProfile)

Putting It All Together

Now that we have our profiler components, let's integrate them into our main application:

func main() {
    // ... (previous database initialization code) ...

    // Set up profiled routes
    http.HandleFunc("/user", trackRequestDuration(handleUser))
    http.HandleFunc("/debug/profile", handleProfile)

    // Start memory stats logging
    go func() {
        ticker := time.NewTicker(1 * time.Minute)
        for range ticker.C {
            logMemStats()
        }
    }()

    // Start the server
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Using Our Custom Profiler

To gain insights into your web service:

Run your web service as usual.
Generate some traffic to your /user endpoint.
Visit http://localhost:8080/debug/profile to view the profiling data.

Analyzing the Results

With this custom profiler, you can now:

Identify your slowest endpoints (check requestDurations).
Pinpoint problematic database queries (examine queryStats).
Monitor memory usage trends over time (review memStats).

Pro Tips

Sampling: For high-traffic services, consider sampling your requests to reduce overhead.
Alerting: Set up alerts based on your profiling data to catch performance issues early.
Visualization: Use tools like Grafana to create dashboards from your profiling data.
Continuous Profiling: Implement a system to continuously collect and analyze profiling data in production.

Conclusion

We've built a custom profiler tailored to our Go web service needs, allowing us to gather specific insights that generic profilers might miss. This targeted approach empowers you to make informed optimizations and deliver a faster, more efficient application.

Remember, while custom profiling is powerful, it does add some overhead. Use it judiciously, especially in production environments. Start with development and staging environments, and gradually roll out to production as you refine your profiling strategy.

By understanding the unique performance characteristics of your Go web service, you're now equipped to take your optimization game to the next level. Happy profiling!

How did you like this deep dive into custom Go profiling? Let me know in the comments, and don't forget to share your own profiling tips and tricks!

Unlocking PHP's Hidden Gems: 7 SPL Data Structures You Need to Know

Tramposo — Fri, 27 Sep 2024 15:06:31 +0000

Are you ready to take your PHP skills to the next level? Let's dive into the world of SPL (Standard PHP Library) and discover seven powerful data structures that can make your code more efficient and elegant.

1. SplFixedArray: The Memory-Efficient Powerhouse

Ever worked with large datasets in PHP? Then you know how memory-hungry regular arrays can be. Enter SplFixedArray – your new best friend for handling big data.

$size = 1000000;
$regularArray = range(1, $size);
$fixedArray = new SplFixedArray($size);

for ($i = 0; $i < $size; $i++) {
    $fixedArray[$i] = $i + 1;
}

echo "Regular Array Memory: " . memory_get_usage(true) / 1024 / 1024 . " MB\n";
unset($regularArray);

echo "Fixed Array Memory: " . memory_get_usage(true) / 1024 / 1024 . " MB\n";

Run this, and you'll see a significant memory saving with SplFixedArray. It's perfect for situations where you know the size of your array upfront and don't need the flexibility of regular arrays.

2. SplObjectStorage: The Object Wrangler

Need to efficiently store and retrieve objects? SplObjectStorage is your go-to solution. It's like the Swiss Army knife for object management.

class User {
    public function __construct(public string $name) {}
}

$storage = new SplObjectStorage();

$alice = new User("Alice");
$bob = new User("Bob");

$storage[$alice] = "Admin";
$storage[$bob] = "User";

foreach ($storage as $user) {
    echo $user->name . " is a " . $storage[$user] . "\n";
}

echo "Is Charlie in storage? " . ($storage->contains(new User("Charlie")) ? "Yes" : "No") . "\n";

This snippet shows how easy it is to associate metadata with objects and quickly check for object existence. Perfect for implementing caches or complex data relationships!

3. SplPriorityQueue: Your Personal Task Manager

SplPriorityQueue is your secret weapon for building task schedulers or any system where items need to be processed in a specific order.

$queue = new class extends SplPriorityQueue {
    #[\ReturnTypeWillChange]
    public function compare($priority1, $priority2): int {
        return $priority1 <=> $priority2; // Higher number = higher priority
    }
};

$queue->insert("Feed the cat", 3);
$queue->insert("Write code", 2);
$queue->insert("Take a nap", 1);
$queue->insert("Urgent bug fix", 4);

while (!$queue->isEmpty()) {
    echo "Task: " . $queue->extract() . "\n";
}

This code creates a simple task list where tasks with higher priority numbers are executed first.

4. SplDoublyLinkedList: The Flexible List

When you need fast insertions and deletions at both ends of a list, use SplDoublyLinkedList.

$list = new SplDoublyLinkedList();

$list->push("First");
$list->push("Second");
$list->unshift("New First");

$list->add(1, "Between First and Second");

foreach ($list as $item) {
    echo $item . "\n";
}

echo "Reversed:\n";
$list->setIteratorMode(SplDoublyLinkedList::IT_MODE_LIFO);
foreach ($list as $item) {
    echo $item . "\n";
}

This structure is great for implementing undo/redo functionality or managing a playlist.

5. SplHeap: The Sorting Master

SplHeap is perfect for maintaining a sorted collection of elements. Let's implement a min-heap:

class MinHeap extends SplHeap {
    protected function compare($value1, $value2): int {
        return $value2 - $value1; // Smaller values have higher priority
    }
}

$heap = new MinHeap();
$heap->insert(5);
$heap->insert(3);
$heap->insert(7);
$heap->insert(1);

while (!$heap->isEmpty()) {
    echo $heap->extract() . "\n";
}

This is excellent for algorithms like Dijkstra's shortest path or maintaining a top-K list.

6. SplStack: The LIFO Champion

When you need a Last-In-First-Out (LIFO) structure, SplStack has got you covered:

$stack = new SplStack();

$stack->push("Layer 1");
$stack->push("Layer 2");
$stack->push("Layer 3");

echo "Top of the stack: " . $stack->top() . "\n";

while (!$stack->isEmpty()) {
    echo "Popped: " . $stack->pop() . "\n";
}

Great for parsing expressions, managing undo operations, or depth-first traversals.

7. SplFileObject: The File Handler

SplFileObject provides an object-oriented interface for handling files:

$file = new SplFileObject("example.txt", "w");
$file->fwrite("Hello, SPL!\n");
$file->fwrite("File handling made easy.");

$file = new SplFileObject("example.txt", "r");
foreach ($file as $line_num => $line) {
    echo "Line {$line_num}: {$line}";
}

It simplifies file operations and integrates well with other SPL features.

Wrapping Up

These seven SPL data structures – SplFixedArray, SplObjectStorage, SplPriorityQueue, SplDoublyLinkedList, SplHeap, SplStack, and SplFileObject – are just the tip of the iceberg. They can significantly improve your code's performance and readability when used in the right contexts.

Next time you're tackling a complex PHP project, remember these hidden gems. They might just be the solution you've been looking for!

Happy coding! 🚀💻

Have you used any of these SPL data structures before? Share your experiences in the comments below!

Netflix Clone to Level Up Your Frontend Skills

Tramposo — Mon, 23 Sep 2024 22:28:56 +0000

As a developer primarily focused on backend, I've always felt that my frontend skills could use some polishing. To test this, I decided to challenge myself by building a Netflix clone using Vue.js 3 and Vite. In this article, I'll break down the project structure, key components, and share my learning experience.

Project Overview

The goal was to create a responsive web application that mimics the core features of Netflix's user interface. Here's what I initially set out to build:

A homepage with multiple rows of movies, categorized by genre
Smooth horizontal scrolling for movie rows
Lazy loading of images for better performance
A search functionality to find movies

More to be added in the future.

Tech Stack

For this project, I chose the following tools:

Vue.js 3: For its reactivity system and component-based architecture
Vite: As a fast build tool and development server
Vue Router: For handling navigation
Pinia: For state management
Axios: For making API requests to TMDB
@vueuse/motion: For adding smooth animations

Project Structure

Here's an overview of the project structure:

netflix-clone/
├── src/
│   ├── components/
│   │   ├── MovieCard.vue
│   │   ├── MovieList.vue
│   │   ├── MovieRow.vue
│   │   └── NavBar.vue
│   ├── views/
│   │   ├── HomeView.vue
│   │   ├── MovieDetailView.vue
│   │   └── SearchView.vue
│   ├── router/
│   │   └── index.js
│   ├── services/
│   │   └── tmdb.js
│   ├── stores/
│   │   └── movies.js
│   ├── App.vue
│   └── main.js
├── .env.example
├── vite.config.js
└── package.json

Key Components Breakdown

MovieCard.vue

This component represents an individual movie. It displays the movie poster and, on hover, shows additional information like the title, rating, and release year.

<template>
  <div class="movie-card" @mouseenter="startHoverTimer" @mouseleave="resetHover">
    <img :src="posterUrl" :alt="movie.title" @load="imageLoaded = true" :class="{ 'loaded': imageLoaded }">
    <div v-if="isHovered" class="movie-info">
      <h3>{{ movie.title }}</h3>
      <p>Rating: {{ movie.vote_average }}/10</p>
      <p>{{ releaseYear }}</p>
    </div>
  </div>
</template>

<script setup>
import { ref, computed } from 'vue';

const props = defineProps(['movie']);
const imageLoaded = ref(false);
const isHovered = ref(false);

const posterUrl = computed(() => `https://image.tmdb.org/t/p/w500${props.movie.poster_path}`);
const releaseYear = computed(() => new Date(props.movie.release_date).getFullYear());

// ... hover logic
</script>

Key learnings:

Using computed properties for derived data
Implementing hover effects with CSS transitions
Lazy loading images for better performance

MovieRow.vue

This component creates a horizontally scrollable row of movies, typically grouped by genre.

<template>
  <div class="movie-row">
    <h2>{{ title }}</h2>
    <div class="movie-list" ref="movieList">
      <MovieCard v-for="movie in movies" :key="movie.id" :movie="movie" />
    </div>
    <button @click="scroll('left')" class="scroll-btn left">&lt;</button>
    <button @click="scroll('right')" class="scroll-btn right">&gt;</button>
  </div>
</template>

<script setup>
import { ref } from 'vue';
import MovieCard from './MovieCard.vue';

const props = defineProps(['title', 'movies']);
const movieList = ref(null);

const scroll = (direction) => {
  const scrollAmount = direction === 'left' ? -300 : 300;
  movieList.value.scrollBy({ left: scrollAmount, behavior: 'smooth' });
};
</script>

### tmdb.js (API Service)

This service handles all API calls to The Movie Database (TMDB) using Axios.

import axios from 'axios';

const API_KEY = import.meta.env.VITE_TMDB_API_KEY;
const BASE_URL = 'https://api.themoviedb.org/3';

const tmdbApi = axios.create({
  baseURL: BASE_URL,
  params: { api_key: API_KEY },
});

export const getTrending = () => tmdbApi.get('/trending/all/week');
export const getMoviesByGenre = (genreId) => tmdbApi.get('/discover/movie', { params: { with_genres: genreId } });
export const searchMovies = (query) => tmdbApi.get('/search/movie', { params: { query } });

NavBar.vue

The NavBar component provides navigation for the application and includes a search input for finding movies.

<template>
  <nav class="navbar">
    <router-link to="/" class="navbar-brand">NetflixClone</router-link>
    <div class="navbar-links">
      <router-link to="/">Home</router-link>
      <div class="search-container">
        <input v-model="searchQuery" @input="debounceSearch" placeholder="Search movies...">
      </div>
    </div>
  </nav>
</template>

<script setup>
import { ref } from 'vue';
import { useRouter } from 'vue-router';
import debounce from 'lodash/debounce';

const router = useRouter();
const searchQuery = ref('');

const debounceSearch = debounce(() => {
  if (searchQuery.value) {
    router.push({ name: 'search', query: { q: searchQuery.value } });
  }
}, 300);
</script>

HomeView.vue

The HomeView component serves as the main page of the application, displaying multiple MovieRow components with different genres.

<template>
  <div class="home-view">
    <MovieRow title="Trending" :movies="trendingMovies" />
    <MovieRow v-for="genre in genres" :key="genre.id" :title="genre.name" :movies="moviesByGenre[genre.id]" />
  </div>
</template>

<script setup>
import { ref, onMounted } from 'vue';
import MovieRow from '@/components/MovieRow.vue';
import { getTrending, getGenres, getMoviesByGenre } from '@/services/tmdb';

const trendingMovies = ref([]);
const genres = ref([]);
const moviesByGenre = ref({});

onMounted(async () => {
  const [trendingResponse, genresResponse] = await Promise.all([
    getTrending(),
    getGenres()
  ]);

  trendingMovies.value = trendingResponse.data.results;
  genres.value = genresResponse.data.genres.slice(0, 5); // Limit to 5 genres for this example

  for (const genre of genres.value) {
    const response = await getMoviesByGenre(genre.id);
    moviesByGenre.value[genre.id] = response.data.results;
  }
});
</script>

SearchView.vue

The SearchView component displays search results based on the user's query.

<template>
  <div class="search-view">
    <h2>Search Results for "{{ searchQuery }}"</h2>
    <div class="search-results">
      <MovieCard v-for="movie in searchResults" :key="movie.id" :movie="movie" />
    </div>
  </div>
</template>

<script setup>
import { ref, watch } from 'vue';
import { useRoute } from 'vue-router';
import MovieCard from '@/components/MovieCard.vue';
import { searchMovies } from '@/services/tmdb';

const route = useRoute();
const searchQuery = ref('');
const searchResults = ref([]);

const performSearch = async () => {
  const response = await searchMovies(searchQuery.value);
  searchResults.value = response.data.results;
};

watch(() => route.query.q, (newQuery) => {
  searchQuery.value = newQuery;
  performSearch();
}, { immediate: true });
</script>

You can find the full source code for this project on GitHub.

Building a Pawn to Python Compiler in PHP

Tramposo — Mon, 23 Sep 2024 21:12:57 +0000

When we think of PHP, we often associate it with web development. But what happens when we push PHP beyond its usual boundaries? In this article, we'll explore an unconventional use of PHP: building a compiler that translates Pawn code to Python. This project not only demonstrates PHP's versatility but also provides insights into the basics of compiler design.

Pawn to Python

Our goal was to create a compiler that could take Pawn code (a scripting language similar to C) and convert it into equivalent Python code. This task involves several key steps: tokenization, parsing, and code generation - all implemented in PHP.

Key Components of Our Compiler

1. Tokenization

The first step in our compiler is breaking down the input Pawn code into tokens. Here's how we approached it:

private function tokenize($input)
{
    $pattern = '/("[^"]*"|\s+|[{}();=]|\b\w+\b|.)/';
    preg_match_all($pattern, $input, $matches);
    $tokens = array_values(array_filter($matches[0], function ($token) {
        return $token !== '' && !ctype_space($token);
    }));
    return $tokens;
}

This function uses a regular expression to identify different elements of the Pawn code, including string literals, whitespace, brackets, and keywords.

2. Parsing and Compilation

The heart of our compiler lies in the compile method and its supporting functions. Here's a simplified version of the main compilation loop:

public function compile()
{
    while (($token = $this->peekNextToken()) !== null) {
        if ($token === 'main') {
            $this->compileMainFunction();
        } else {
            $this->addError("Unexpected token outside of main function: '$token'");
        }
    }
    return $this->outputBuffer;
}

This method iterates through the tokens, identifying key structures like the main function, and delegates to specialized methods for compiling different parts of the code.

3. Type Handling

One of the interesting challenges was dealing with Pawn's type system. We implemented basic type checking and default value assignment:

private function compileVariableDeclaration($indentation)
{
    $type = $this->getNextToken();
    $name = $this->getNextToken();
    $this->variables[$name] = $type;

    if ($this->peekNextToken() === '=') {
        // Handle initialization
    } else {
        $defaultValue = $this->getDefaultValueForType($type);
        $pythonDeclaration = str_repeat('    ', $indentation) . "$name = $defaultValue\n";
    }
    $this->outputBuffer .= $pythonDeclaration;
}

This function handles variable declarations, assigning default values based on the variable type when no initial value is provided.

Challenges and Learnings

Regular Expressions in PHP: Crafting the right regex for tokenization was crucial. PHP's preg_match_all proved suitable for this task.
State Management: Keeping track of the current compilation state (like indentation level and declared variables) was essential. It was manageable given PHP's object-oriented features.
Error Handling: Implementing robust error checking and reporting was vital for creating a usable compiler. We used a simple array to collect and report errors.
Type Conversion: Bridging the gap between Pawn's static typing and Python's dynamic typing required careful consideration.

Preview: From Pawn to Python

To give you a concrete idea of what our compiler does, let's look at a simple "Hello, World!" program in Pawn and its equivalent Python output after compilation.

Pawn Input:

main()
{
    print("Hello, World!");
    return 0;
}

Python Output:

# Compiled from Pawn to Python

def main():
    print("Hello, World!")

if __name__ == "__main__":
    main()

This simple example demonstrates several key aspects of our compiler:

Print Statement: The print statement is carried over almost identically, as both languages use similar syntax for this basic operation.
Return Statement Handling: The return 0; statement from Pawn is omitted in the Python output, as it's not necessary in Python's main() function.
Python Idiom Addition: The compiler adds the if __name__ == "__main__": idiom, which is a common Python pattern for making scripts both importable and executable.

While this is just a basic example, it showcases the fundamental operation of our compiler: taking Pawn code and producing equivalent, executable Python code.

Conclusion

Building a Pawn to Python compiler in PHP was an exciting exploration of the language's capabilities. It showcases PHP's versatility and proves that with creativity, PHP can be pushed far beyond its typical use cases.

Whether you're a PHP enthusiast looking to expand your capabilities or a programmer interested in compiler design, experiments like these open up new perspectives on what's possible with the tools we use every day.

Understanding Rust Macros: A Comprehensive Guide for Developers

Tramposo — Sat, 21 Sep 2024 11:28:35 +0000

Rust's macro system is a powerful feature that allows developers to extend the language's syntax and create reusable code templates. In this article, we'll dive deep into Rust macros, exploring their types, use cases, and best practices. Whether you're new to Rust or looking to level up your macro skills, this guide has something for you.

Introduction to Rust Macros
Declarative Macros
Procedural Macros
- Function-like Procedural Macros
- Derive Macros
- Attribute Macros
Advanced Procedural Macro Example
Using Externally Defined Macros
Macro Hygiene
Common Macro Use Cases
Best Practices and Pitfalls
Debugging Macros
Conclusion

Introduction to Rust Macros

Macros in Rust are a way to write code that writes other code, which is known as metaprogramming. They allow you to abstract away common patterns, reduce code duplication, and even create domain-specific languages within Rust.

There are two main types of macros in Rust:

Declarative Macros
Procedural Macros

Let's explore each type in detail.

Declarative Macros

Declarative macros, also known as "macros by example" or simply "macro_rules! macros", are the most common type of macros in Rust. They allow you to write something similar to a match expression that operates on Rust syntax trees at compile time.

Here's a simple example of a declarative macro:

macro_rules! say_hello {
    () => {
        println!("Hello!");
    };
    ($name:expr) => {
        println!("Hello, {}!", $name);
    };
}

fn main() {
    say_hello!(); // Prints: Hello!
    say_hello!("Alice"); // Prints: Hello, Alice!
}

In this example, say_hello! is a macro that can be called with or without an argument. The macro expands to different code depending on how it's called.

Declarative macros are powerful for creating variadic functions, implementing simple DSLs, and reducing boilerplate code. However, they have limitations when it comes to more complex metaprogramming tasks.

Procedural Macros

Procedural macros are more powerful than declarative macros. They allow you to operate on the input token stream directly, giving you more flexibility and control. There are three types of procedural macros:

Function-like Procedural Macros

These macros look like function calls but are processed at compile time. They take a TokenStream as input and produce a TokenStream as output.

Here's a simple example:

use proc_macro::TokenStream;

#[proc_macro]
pub fn make_answer(_item: TokenStream) -> TokenStream {
    "fn answer() -> u32 { 42 }".parse().unwrap()
}

This macro generates a function that returns 42. You would use it like this:

make_answer!();
fn main() {
    println!("The answer is: {}", answer());
}

Derive Macros

Derive macros allow you to automatically implement traits for structs or enums. They're defined using the #[proc_macro_derive] attribute.

Here's a simple example that implements a Greet trait:

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(Greet)]
pub fn greet_macro_derive(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;
    let gen = quote! {
        impl Greet for #name {
            fn greet(&self) {
                println!("Hello, I'm {}!", stringify!(#name));
            }
        }
    };
    gen.into()
}

You would use this macro like this:

#[derive(Greet)]
struct Person;

fn main() {
    let p = Person;
    p.greet(); // Prints: Hello, I'm Person!
}

Attribute Macros

Attribute macros define new outer attributes in Rust. They're defined using the #[proc_macro_attribute] attribute.

Here's a simple example that logs the function name:

use proc_macro::TokenStream;
use quote::{quote, format_ident};
use syn::{parse_macro_input, ItemFn};

#[proc_macro_attribute]
pub fn log_function_name(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input_fn = parse_macro_input!(item as ItemFn);
    let fn_name = &input_fn.sig.ident;
    let fn_body = &input_fn.block;

    let output = quote! {
        fn #fn_name() {
            println!("Entering function: {}", stringify!(#fn_name));
            #fn_body
        }
    };

    output.into()
}

You would use this macro like this:

#[log_function_name]
fn greet() {
    println!("Hello, world!");
}

fn main() {
    greet(); // Prints: Entering function: greet
             //         Hello, world!
}

Advanced Procedural Macro Example

Let's create a more complex procedural macro that generates a builder pattern for a struct. This example demonstrates working with struct fields and generating methods.

use proc_macro::TokenStream;
use quote::{quote, format_ident};
use syn::{parse_macro_input, DeriveInput, Data, Fields};

#[proc_macro_derive(Builder)]
pub fn derive_builder(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;
    let builder_name = format_ident!("{}Builder", name);

    let fields = match &input.data {
        Data::Struct(data_struct) => match &data_struct.fields {
            Fields::Named(fields_named) => &fields_named.named,
            _ => panic!("This macro only works on structs with named fields"),
        },
        _ => panic!("This macro only works on structs"),
    };

    let field_names = fields.iter().map(|field| &field.ident);
    let field_types = fields.iter().map(|field| &field.ty);

    let builder_fields = fields.iter().map(|field| {
        let name = &field.ident;
        let ty = &field.ty;
        quote! { #name: Option<#ty> }
    });

    let builder_setters = fields.iter().map(|field| {
        let name = &field.ident;
        let ty = &field.ty;
        quote! {
            pub fn #name(&mut self, #name: #ty) -> &mut Self {
                self.#name = Some(#name);
                self
            }
        }
    });

    let builder_build = field_names.clone().zip(field_names.clone()).map(|(name, name2)| {
        quote! {
            #name: self.#name2.take().ok_or(concat!(stringify!(#name), " is not set"))?
        }
    });

    let expanded = quote! {
        impl #name {
            pub fn builder() -> #builder_name {
                #builder_name {
                    #(#field_names: None,)*
                }
            }
        }

        pub struct #builder_name {
            #(#builder_fields,)*
        }

        impl #builder_name {
            #(#builder_setters)*

            pub fn build(&mut self) -> Result<#name, Box<dyn std::error::Error>> {
                Ok(#name {
                    #(#builder_build,)*
                })
            }
        }
    };

    TokenStream::from(expanded)
}

This macro generates a builder pattern for any struct it's applied to. Here's how you would use it:

#[derive(Builder)]
struct Person {
    name: String,
    age: u32,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let person = Person::builder()
        .name("Alice".to_string())
        .age(30)
        .build()?;

    println!("Created person: {} ({})", person.name, person.age);
    Ok(())
}

Using Externally Defined Macros

When working with procedural macros, it's common to define them in a separate crate and then use them in your main project. Here's a brief overview of how to use externally defined macros:

Macro Crate: Create a separate crate for your procedural macros. This crate should have a special configuration in its Cargo.toml:

   [lib]
   proc-macro = true

Main Project: In your main project's Cargo.toml, add the macro crate as a dependency:

   [dependencies]
   my_proc_macro = { path = "./my_proc_macro" }

Using the Macro: In your main project's code, import and use the macro:

   use my_proc_macro::MyDerive;

   #[derive(MyDerive)]
   struct MyStruct;

   fn main() {
       // Use MyStruct...
   }

This separation allows you to define reusable procedural macros that can be used across multiple projects while keeping your main project code clean and focused.

Remember, when using procedural macros, you're working with compile-time code generation. The macros are expanded during compilation, generating additional code based on the macro's rules.

Macro Hygiene

Macro hygiene refers to how macros handle variable names to prevent unintended name clashes. Rust's macro system is partially hygienic, meaning it provides some protection against accidental name conflicts.

In declarative macros, Rust uses a technique called "syntax hygiene." This means that variables defined within a macro don't clash with variables in the scope where the macro is used.

macro_rules! using_a {
    ($e:expr) => {
        {
            let a = 42;
            $e
        }
    }
}

fn main() {
    let a = 10;
    println!("{}", using_a!(a)); // Prints 10, not 42
}

In this example, the a defined inside the macro doesn't override the a in the main function.

For procedural macros, you need to be more careful. The quote! macro provides the quote_spanned! variant that allows you to attach span information to the generated tokens, helping maintain hygiene.

use proc_macro::TokenStream;
use quote::quote_spanned;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(MyTrait)]
pub fn my_trait(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;
    let span = name.span();

    let expanded = quote_spanned! {span=>
        impl MyTrait for #name {
            fn my_method(&self) {
                let helper = "I'm hygienic!";
                println!("{}", helper);
            }
        }
    };

    TokenStream::from(expanded)
}

By using quote_spanned!, we ensure that any identifiers we introduce (like helper) are hygienic and won't clash with user-defined names.

Common Macro Use Cases

Macros in Rust are commonly used for:

Generating repetitive code
Creating domain-specific languages (DSLs)
Extending the syntax of Rust
Implementing compile-time features
Automatic trait implementations

Best Practices and Pitfalls

When working with macros, keep these best practices in mind:

Use macros sparingly. If a regular function can do the job, prefer that.
Document your macros thoroughly, especially their syntax and expansion.
Be careful with hygiene in procedural macros. Use format_ident! or similar techniques to avoid name collisions.
Test your macros extensively, including edge cases.
Be mindful of compile times. Complex macros can significantly increase compilation time.

Common pitfalls to avoid:

Overusing macros where simple functions would suffice
Creating overly complex macros that are hard to maintain
Not considering all possible inputs to your macro
Forgetting about macro hygiene, leading to unexpected name conflicts

Debugging Macros

Debugging macros can be challenging because they operate at compile-time. Here are some techniques to help:

Print the generated code: For procedural macros, you can print the TokenStream to see what code is being generated:

   #[proc_macro_derive(MyDerive)]
   pub fn my_derive(input: TokenStream) -> TokenStream {
       let output = /* your macro logic */;
       println!("Generated code: {}", output);
       output
   }

Use the trace_macros! feature: This is a compiler feature that shows how macros are expanded. Enable it in your code:

   #![feature(trace_macros)]

   trace_macros!(true);
   // Your macro invocations here
   trace_macros!(false);

Use the log crate: For procedural macros, you can use the log crate to output debug information:

   use log::debug;

   #[proc_macro_derive(MyDerive)]
   pub fn my_derive(input: TokenStream) -> TokenStream {
       debug!("Input: {:?}", input);
       // Your macro logic here
   }

Remember to configure a logger and set the appropriate log level.

Expand macros without compiling: Use cargo expand (from the cargo-expand crate) to see macro expansions without compiling the code:

   cargo install cargo-expand
   cargo expand

Remember, when debugging macros, you're often dealing with compile-time behavior. This means you need to recompile to see the effects of any changes, which can make the debugging process slower than usual runtime debugging.

Conclusion

Rust macros are a powerful tool in a developer's kit. They allow for impressive metaprogramming capabilities, from simple syntax extensions to complex code generation. While they should be used judiciously, understanding macros can greatly enhance your Rust programming skills and allow you to write more expressive and maintainable code.

Remember, the key to mastering macros is practice. Start with simple declarative macros and gradually work your way up to more complex procedural macros. Happy coding!

If you have any questions or need clarification on any part of the article, feel free to ask in the comments below.

Testing in Rust: A Quick Guide to Unit Tests, Integration Tests, and Benchmarks

Tramposo — Thu, 19 Sep 2024 19:05:56 +0000

Rust's built-in testing framework makes it easy to ensure your code works as expected. Let's explore the three main types of tests in Rust: unit tests, integration tests, and benchmarks.

Unit Tests

Unit tests in Rust are typically small, focused tests that verify the behavior of a single function or module. They're written in the same file as the code they're testing.

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

Key points:

Use the #[cfg(test)] attribute to compile test code only when running tests.
Each test function is annotated with #[test].
Use assertion macros like assert_eq! to verify results.

Integration Tests

Integration tests verify that different parts of your library work together correctly. They're located in the tests directory at the root of your project.

// In tests/integration_test.rs
use yourcrate_name;

#[test]
fn test_complex_operation() {
    let result = yourcrate_name::complex_operation();
    assert!(result.is_ok());
}

Key points:

Each file in the tests directory is compiled as a separate crate.
They can only test the public API of your library.
Run with cargo test.

Benchmarks

Benchmarks help you measure the performance of your code. They're unstable in Rust and require the nightly toolchain.

#![feature(test)]

extern crate test;

#[cfg(test)]
mod bench {
    use test::Bencher;
    use super::*;

    #[bench]
    fn bench_add(b: &mut Bencher) {
        b.iter(|| add(2, 2));
    }
}

Key points:

Use #![feature(test)] to enable benchmarking.
Annotate benchmark functions with #[bench].
Run with cargo bench.

Remember that writing tests is crucial for maintaining code quality and catching bugs early. Rust's testing framework makes it straightforward to create comprehensive test suites for your projects.

Building a Terminal-Based Morse Code Translator

Tramposo — Thu, 19 Sep 2024 17:55:09 +0000

Project Overview

This Morse code translator is a terminal application that allows real-time translation between text and Morse code. It features a color-coded, interactive interface and supports letters, numbers, and common punctuation marks.

Let's break down some key parts of the code to see these concepts in action.

Code Breakdown

The MorseTranslator Struct

pub struct MorseTranslator {
    to_morse: HashMap<char, String>,
    from_morse: HashMap<String, char>,
}

impl MorseTranslator {
    pub fn new() -> Self {
        let mut to_morse = HashMap::new();
        let mut from_morse = HashMap::new();

        // Populate with hashmaps...

        MorseTranslator { to_morse, from_morse }
    }

    pub fn to_morse(&self, text: &str) -> String {
        text.to_uppercase()
            .chars()
            .map(|c| {
                if c.is_whitespace() {
                    "  ".to_string()
                } else {
                    self.to_morse.get(&c).cloned().unwrap_or_else(|| c.to_string())
                }
            })
            .collect::<Vec<String>>()
            .join(" ")
    }

    // from_morse method...
}

This struct allows:

Use of HashMap for efficient lookup
Implementation of methods
Rust's iterator methods like map and collect

Terminal UI Handling

pub fn run_terminal_ui() -> crossterm::Result<()> {
    let mut text = String::new();
    let mut morse = String::new();
    let translator = MorseTranslator::new();
    let mut active_field = 0; // 0 for text, 1 for morse

    execute!(stdout(), Hide)?;

    loop {
        // Clear screen and set colors...

        match read()? {
            Event::Key(event) => match event.code {
                KeyCode::Esc => break,
                KeyCode::Tab => {
                    active_field = 1 - active_field;
                    // Update translations...
                },
                KeyCode::Char(c) => {
                    // Handle character input...
                },
                _ => {}
            },
            _ => {}
        }
    }

    execute!(stdout(), Show)?;
    Ok(())
}

This function showcases:

Error handling with the ? operator
Pattern matching with match
Mutable state management in a loop

Conclusion and Next Steps

Building this Morse code translator is an engaging way to learn Rust's fundamentals while creating something useful. As you become more comfortable with these concepts, you can extend the project in various ways:

Add sound output for Morse code
Implement file I/O for saving and loading translations

The full code for this project is available on GitHub. Feel free to fork, experiment, and learn.

Building a Terminal TODO App in Rust

Tramposo — Thu, 19 Sep 2024 00:58:48 +0000

Project Overview

The Terminal TODO App is a command-line task manager built with Rust. It utilizes the tui and crossterm crates to create an interactive terminal user interface.

Key Features

Dual list management (TODO and DONE lists)
Interactive navigation
Task editing and deletion
Data persistence
Vim-inspired keybindings

Technical Breakdown

1. State Management

The app's state is managed through a central App struct:

struct App {
    todos: Vec<String>,
    done: Vec<String>,
    input: String,
    input_mode: InputMode,
    todo_list_state: ListState,
    done_list_state: ListState,
    editing_index: Option<usize>,
}

This structure captures all the necessary data for the application, including the task lists, current input, and UI state.

2. User Input Handling

User input is processed in the main event loop:

fn run_app<B: tui::backend::Backend>(terminal: &mut Terminal<B>, app: &mut App) -> io::Result<()> {
    loop {
        terminal.draw(|f| ui(f, app))?;

        if let Event::Key(key) = event::read()? {
            match app.input_mode {
                InputMode::Normal => match key.code {
                    // Handle normal mode inputs
                },
                InputMode::Editing => match key.code {
                    // Handle editing mode inputs
                },
                InputMode::EditingExisting => match key.code {
                    // Handle existing item editing inputs
                },
            }
        }
    }
}

This pattern allows for different behaviors based on the current input mode.

3. Rendering the UI

The terminal UI is rendered using the tui crate:

fn ui<B: tui::backend::Backend>(f: &mut Frame<B>, app: &App) {
    let chunks = Layout::default()
        .direction(Direction::Vertical)
        .margin(2)
        .constraints([
            Constraint::Length(3),
            Constraint::Min(0),
            Constraint::Length(3),
        ])
        .split(f.size());

    // Render TODO and DONE lists
    let lists = Layout::default()
        .direction(Direction::Horizontal)
        .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
        .split(chunks[1]);

    let todo_items: Vec<ListItem> = app.todos.iter().map(|i| ListItem::new(i.as_ref())).collect();
    let todo_list = List::new(todo_items)
        .block(Block::default().borders(Borders::ALL).title("Todo"));

    f.render_stateful_widget(todo_list, lists[0], &mut app.todo_list_state);

    // Similar rendering for DONE list...
}

This function demonstrates how to create a layout and render widgets like lists and input fields.

4. Data Persistence

Task persistence is implemented using simple file I/O:

impl App {
    pub fn save_to_file(&self, filename: &str) -> io::Result<()> {
        let mut file = OpenOptions::new()
            .write(true)
            .create(true)
            .truncate(true)
            .open(filename)?;

        writeln!(file, "[TODO]")?;
        for item in &self.todos {
            writeln!(file, "{}", item)?;
        }

        writeln!(file, "[DONE]")?;
        for item in &self.done {
            writeln!(file, "{}", item)?;
        }

        Ok(())
    }

    pub fn load_from_file(filename: &str) -> io::Result<Self> {
        // Implementation of file loading...
    }
}

This approach is straightforward to save and load the application state between sessions.

DEV Community: Tramposo

Database Interactions in Go: From SQL to NoSQL

Introduction

Table of Contents

SQL Database Interactions

Using the database/sql Package

Working with an ORM: GORM

NoSQL Database Interactions

MongoDB with the Official Go Driver

Best Practices and Common Pitfalls

Conclusion

Supercharge Your Go Web Service: Building a Custom Profiler

Introduction

The Case for Custom Profiling

Our Sample Web Service

Custom Profiler Implementation

1. Request Duration Tracking

2. Database Query Profiling

3. Memory Usage Tracking

4. Profiler API Endpoint

Putting It All Together

Using Our Custom Profiler

Analyzing the Results

Pro Tips

Conclusion

Unlocking PHP's Hidden Gems: 7 SPL Data Structures You Need to Know

1. SplFixedArray: The Memory-Efficient Powerhouse

2. SplObjectStorage: The Object Wrangler

3. SplPriorityQueue: Your Personal Task Manager

4. SplDoublyLinkedList: The Flexible List

5. SplHeap: The Sorting Master

6. SplStack: The LIFO Champion

7. SplFileObject: The File Handler

Wrapping Up

Netflix Clone to Level Up Your Frontend Skills

Project Overview

Tech Stack

Project Structure

Key Components Breakdown

MovieCard.vue

MovieRow.vue

NavBar.vue

HomeView.vue

SearchView.vue

Building a Pawn to Python Compiler in PHP

Pawn to Python

Key Components of Our Compiler

1. Tokenization

2. Parsing and Compilation

3. Type Handling

Challenges and Learnings

Preview: From Pawn to Python

Pawn Input:

Python Output:

Conclusion

Understanding Rust Macros: A Comprehensive Guide for Developers

Table of Contents

Introduction to Rust Macros

Declarative Macros

Procedural Macros

Function-like Procedural Macros

Derive Macros

Attribute Macros

Advanced Procedural Macro Example

Using Externally Defined Macros

Macro Hygiene

Common Macro Use Cases

Best Practices and Pitfalls

Debugging Macros

Conclusion

Testing in Rust: A Quick Guide to Unit Tests, Integration Tests, and Benchmarks

Unit Tests

Integration Tests

Benchmarks

Building a Terminal-Based Morse Code Translator

Project Overview

Code Breakdown

The MorseTranslator Struct

Terminal UI Handling

Conclusion and Next Steps