DEV Community: Sergio Marcial

Unveiling gRPC: Empowering Microservices Beyond REST 🚀

Sergio Marcial — Thu, 05 Oct 2023 15:32:32 +0000

Introduction:

In the realm of microservices and distributed systems, choosing the right communication protocol is paramount. Enter gRPC, a high-performance, language-agnostic, and versatile framework that's rapidly gaining traction. In this article, we'll embark on a journey to explore gRPC, understand its role in microservices architecture, dissect the differences between gRPC and REST, and unravel when it's advantageous to opt for gRPC over REST. Buckle up; it's going to be an exciting ride!

What is gRPC?

gRPC, which stands for Google Remote Procedure Call, is an open-source framework for remote procedure calls (RPC) that enables communication between distributed systems. It uses Protocol Buffers (Protobuf) as its interface definition language (IDL), providing a flexible and efficient way to define service contracts.

Benefits of gRPC:

High Performance: gRPC is known for its speed and efficiency. It uses HTTP/2, which offers multiplexing, header compression, and more, resulting in lower latency and improved throughput.
Language-Agnostic: You can generate client and server code in various programming languages, making gRPC suitable for polyglot microservices environments.
Strong Typing: Protobuf enforces a strong type system for messages, reducing errors and ensuring robust communication.

gRPC in Microservices:

gRPC seamlessly integrates into microservices architectures, enhancing the communication between services. Its features align well with the requirements of microservices:

Efficiency: gRPC's binary serialization (Protobuf) and multiplexing are well-suited for microservices' resource-constrained environments.
Streaming: gRPC supports both unary (single request, single response) and bidirectional streaming, accommodating various microservices communication patterns.
Service Discovery: It pairs well with service discovery tools like Kubernetes, Consul, or etcd, facilitating dynamic service registration and resolution.

gRPC vs. REST:

Now, let's delve into the distinctions between gRPC and REST.

gRPC:

Protocol: HTTP/2, binary-based, using Protobuf for message serialization.
Communication: Bidirectional streaming is possible, enabling real-time updates.
Code Generation: Language-specific client and server code generation.
Efficiency: Lower payload size, multiplexing, and binary format contribute to higher efficiency.
Error Handling: gRPC uses status codes and details for precise error handling.
Use Cases: Real-time applications, IoT, inter-service communication in microservices.

REST:

Protocol: HTTP/1.1 or HTTP/2, text-based (typically JSON).
Communication: Stateless and follows the request-response model.
Code Generation: No built-in code generation.
Efficiency: JSON can be less efficient for large payloads compared to Protobuf.
Error Handling: Uses HTTP status codes, but often relies on additional context in response payloads.
Use Cases: Public APIs, web services, mobile apps.

When to Choose gRPC:

Now, the million-dollar question: When should you opt for gRPC over REST?

Real-Time Updates: If your microservices require real-time communication or bidirectional streaming (e.g., chat applications), gRPC is a compelling choice.
Efficiency Matters: For resource-constrained environments or when bandwidth is a concern, gRPC's binary format and multiplexing offer a clear advantage.
Strong Typing: When strong typing and code generation are essential for maintaining robust communication contracts across different services.

Code Examples:

Let's take a glimpse at gRPC in action with code examples in various languages:

Go: Creating a gRPC server and client.

Find the detailed code example with instructions here

// Import the necessary packages.
package main

import (
    "context"
    "log"
    "net"

    pb "github.com/sergiommarcial/gen" // Import your generated proto package

    "google.golang.org/grpc"
)

type server struct{}

func (s *server) GetData(ctx context.Context, req *pb.DataRequest) (*pb.DataResponse, error) {
    return &pb.DataResponse{Reply: "Hello, " + req.Message}, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    server := grpc.NewServer()

    // Create a gRPC client.
    pb.RegisterMyServiceServer(server, pb.UnimplementedMyServiceServer{})
    // Set up a connection to the gRPC server.
    log.Println("Server started on :50051...")
    if err := server.Serve(lis); err != nil {
        log.Fatalf("Failed to serve: %v", err)
    }
}

Explanation:

Import the necessary packages, including the gRPC package and your gRPC protocol buffer package (pb), which contains the service definition and message types.

In the main function, establish a connection to the gRPC server running on localhost:50051. The grpc.Dial function is used to create a connection, and we specify grpc.WithInsecure() for simplicity. In production, you should use a secure connection.

Create a gRPC client for your service using the generated client code from your .proto definition file. Replace NewYourServiceClient with the actual client constructor generated by protoc.

Define your request message. Populate this message with the data you want to send to the server.

Call the gRPC method on the server using the client you created. Replace YourGrpcMethod with the actual method name from your .proto file.

Handle any errors that occur during the RPC call.

Python: Defining a service using Protobuf and Python.

Find the detailed code example with instructions here

import grpc
from concurrent import futures
import example_pb2 as ProtoService
import example_pb2_grpc as ProtoServiceGrcp

class MyService():
    def GetData(self, request, context):
        return ProtoService.DataResponse(reply=f"Hello, {request.message}!")


def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    ProtoServiceGrcp.add_MyServiceServicer_to_server(MyService(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()


if __name__ == '__main__':
    serve()

Node.js: Implementing a gRPC server and client in Node.js.

Find the detailed code example with instructions here

const grpc = require("grpc");
const protoLoader = require("@grpc/proto-loader");
const packageDefinition = protoLoader.loadSync("./example.proto", {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true,
});

const myservice = grpc.loadPackageDefinition(packageDefinition).myservice;

const server = new grpc.Server();

server.addService(myservice.MyService.service, {
  getData: (dataRequest, callback) => {
    const response = { reply: `Hello, ${dataRequest.request.message}!` };
    callback(null, response);
  },
});

server.bind("0.0.0.0:50051", grpc.ServerCredentials.createInsecure());
console.log("Starting server");
server.start();
console.log("Server started");

✨ Mermaid Markdown: Adding Life and Creativity to your GitHub Markdown Files 👩‍💻🌈📄

Sergio Marcial — Tue, 19 Sep 2023 05:21:24 +0000

Introduction 🚀

As engineers, we often find ourselves documenting our code, ideas, and processes using Markdown files, whether it's READMEs, project documentation, or collaborative notes. Markdown is a simple and widely adopted markup language for creating easy-to-read and aesthetically pleasing files. However, it lacks the ability to visualize complex data structures or create dynamic diagrams. This is where Mermaid Markdown comes to the rescue!

What is Mermaid Markdown? 🧜‍♀️

Mermaid Markdown is an innovative extension to standard Markdown that allows you to include visually appealing diagrams, flowcharts, and sequence diagrams in your Markdown files. By integrating Mermaid Markdown into your workflow, you can bring life and interactivity to your documentation, making it easier for readers to understand complex ideas and visualize data flows.

What problem does Mermaid Markdown aim to solve? 🎯

Traditional Markdown feels limiting when it comes to expressing complex concepts and relationships. When we want to demonstrate the interaction between different components in a system or visualize a sequence of events, we often resort to external tools or screenshots. This can be time-consuming and doesn't provide the same ease of collaboration as Markdown itself.

With Mermaid Markdown, you can create diagrams directly within your Markdown files using a simple, human-readable syntax. This allows you to document processes, architectures, and data flows seamlessly, without leaving your Markdown file.

Enriching your Markdown in GitHub with Mermaid Markdown 🌟

Adding Mermaid Markdown support to your GitHub repositories is a breeze! Follow these steps to get started:

Install a Markdown editor with Mermaid support 📝

VSCode: Install the "Markdown Preview Mermaid Support" extension.
IntelliJ: Install the "Mermaid" plugin.
Other editors: Look for similar extensions or packages specific to your editor.

Include Mermaid Markdown in your Markdown file 🖊️

Use the following code snippet to add a Mermaid diagram to your Markdown file:

Examples:

Flowchart:

graph TD;
    A-->B;
    A-->C;
    B-->D;
    C-->D;

Gantt Chart:

gantt
    dateFormat  YYYY-MM-DD
    title Adding Mermaid Diagrams
    section A section
    task Task 1: 2023-09-01, 7d
    task Task 2: 2023-09-08, 5d
    task Task 3: 2023-09-15, 6d
    section Another section
    task Task 4: 2023-09-01, 8d
    task Task 5: 2023-09-11, 5d
    task Task 6: 2023-09-20, 6d

Class Diagram:

classDiagram
    Animal <|-- Duck
    Animal <|-- Fish
    Animal <|-- Zebra
    Animal : +int age
    Animal : +String gender
    Animal: +isMammal()
    Animal: +mate()
    class Duck{
        +String beakColor
        +swim()
        +quack()
    }
    class Fish{
        -int sizeInFeet
        -canEat()
    }
    class Zebra{
        +bool isWild
        +run()
    }

You can replace this example with your own diagram using Mermaid's extensive syntax.

Preview your Markdown locally ✨

Enable the Mermaid Markdown preview in your editor and visualize how the diagram renders alongside your Markdown content. This allows you to make any necessary adjustments before committing the changes to your repository.

Commit and push your changes to GitHub 🚀

Once you're happy with your Mermaid Markdown diagram, commit your changes and push them to GitHub. Your diagrams will be rendered on your repository's GitHub page, dynamically enhancing your documentation and making it more engaging for readers.

Conclusion 📝

Mermaid Markdown empowers engineers at all levels to add interactivity and visual creativity to their Markdown files, elevating the quality and comprehensibility of technical documentation. By integrating Mermaid Markdown into your GitHub repositories, you can effectively showcase system architectures, visualize data flows, and create captivating diagrams.

Don't let the simplicity of Markdown restrict your documentation's potential. Embrace Mermaid Markdown today and give your diagrams the spotlight they deserve! 🎉

🔗 Additional reading:

Mermaid Markdown Project: https://mermaid-js.github.io/mermaid/#/mermaidAPI
Mermaid Documentation: https://mermaid-js.github.io/mermaid

Happy Markdown diagramming! 🚀🎨📄

Kafka Simplified with kcat (kafka cat) 🚀

Sergio Marcial — Tue, 12 Sep 2023 04:37:32 +0000

During the continuos travels to demystify Kafka there are multiple tools that can help us better understand the powerful event streaming platform;

Say hello to kcat, your trusty companion in the world of Apache Kafka! Whether you're just starting your journey or you're a seasoned pro looking to level up your Kafka skills, this guide might be able to provide you with a new tool for your toolbox starting with the installation of kcat on Unix, macOS, and Windows, some basic examples. Plus, we'll explore advanced examples, including custom authentication with SASL and keystore, to help you become a Kafka wizard. Buckle up, and let's dive into the world of Kafka with kcat! 🌟

Introducing kcat

Before we delve into the installation and usage, let's get to know kcat. It's a command-line utility that's part of the Confluent ecosystem, designed to simplify Kafka interactions. With kcat, you can consume, produce, and interact with Kafka topics seamlessly, making it an essential tool for software engineers working with real-time data streams.

Installation

Unix and macOS

Option 1: Package Manager (Recommended)

Unix-based systems, including macOS, offer the convenience of package managers for kcat installation. If you're on a system with APT (e.g., Debian/Ubuntu), run:

sudo apt-get install kcat

For systems using YUM (e.g., CentOS/Red Hat), use:

sudo yum install kcat

If you're using macOS with Homebrew, installation is as simple as:

brew install kcat

Option 2: Manual Installation

For those who prefer manual installation, visit the official Confluent Hub (https://docs.confluent.io/current/clients/confluent-kafka-python/html/index.html) to download the appropriate binary for your system. After downloading, follow these steps:

Make the binary executable:

chmod +x kcat # Replace with the actual filename for your system

Move it to a directory in your PATH (e.g., /usr/local/bin/):

sudo mv kcat /usr/local/bin/ # Replace with the actual filename for your system

Windows

Windows users can also enjoy the power of kcat by downloading the Windows binary from the official Confluent Hub (https://docs.confluent.io/current/clients/confluent-kafka-python/html/index.html) and following these steps:

Download the Windows binary.
Rename the binary to kcat.exe.
Add the directory containing kcat.exe to your system's PATH.

Now that you have kcat installed, let's explore its features with practical examples! 🛠️

Basic Usage

Kafka Message Consumption

Let's start with the basics by consuming messages from a Kafka topic. Suppose you have a Kafka topic named my_topic, and your Kafka broker is running at kafka_broker_address. You can use kcat to consume and display messages in real-time:

kcat -b kafka_broker_address -t my_topic

Replace kafka_broker_address with the address of your Kafka broker. kcat will continuously display messages from my_topic as they arrive.

Producing Kafka Messages

Producing messages to Kafka is just as straightforward. To send a message to a Kafka topic, you can use kcat like this:

echo "Hello, Kafka!" | kcat -P -b kafka_broker_address -t my_topic

This command sends the message "Hello, Kafka!" to my_topic. The -P flag indicates that we're producing a message.

Advanced Usage

Custom Consumer Groups

Kafka supports consumer groups for parallel message consumption. You can specify a custom consumer group with kcat:

kcat -b kafka_broker_address -t my_topic -g my_consumer_group

Replace my_consumer_group with the name of your custom consumer group. kcat handles group coordination for you.

Consuming and Writing to a File

Often, you may want to consume messages from a Kafka topic and save them to a file for later analysis. You can achieve this with kcat:

kcat -b kafka_broker_address -t my_topic > output.txt

This command continuously consumes messages from my_topic and appends them to output.txt.

Filtering and Transforming Messages

kcat allows you to apply filtering and transformations to consumed messages using a simple pipe (|) syntax. For instance, you can filter messages containing the word "error" like this:

kcat -b kafka_broker_address -t my_topic | grep "error"

This command displays only the messages containing "error," making it easier to focus on specific events.

Kafka Header Support

Kafka message headers provide additional metadata. kcat supports header manipulation. To send a message with a custom header, you can use the -H option:

echo "Important message" | kcat -P -b kafka_broker_address -t my_topic -H "header_key=header_value"

This sends a message with a custom header to my_topic.

Custom Authentication

Kafka often requires custom authentication mechanisms for secure communication. If your Kafka cluster uses SASL (Simple Authentication and Security Layer) and truststore/keystore certs, you can use kcat with the following options:

SASL

kcat -b kafka_broker_address -t my_topic \
  -X security.protocol=SASL_SSL \
  -X sasl.mechanisms=PLAIN

Truststore/Keystore

kcat -b kafka_broker_address -t my_topic \
  -X ssl.ca.location=/path/to/ca.crt \
  -X ssl.truststore.location=/path/to/client.truststore \
  -X ssl.truststore.password=my_truststore_password
  -X ssl.keystore.location=/path/to/client.keystore \
  -X ssl.keystore.password=my_keystore_password

Replace the placeholders with your specific configurations and paths. kcat will handle the secure communication with SASL and SSL.

Supercharge Kafka with kcat and jq

Now, let's take it up a notch! Combine kcat with jq, a powerful JSON processor, to work with Kafka messages efficiently. Suppose you have JSON messages in your Kafka topic. You can consume, process, and display them using jq like this:

kcat -b kafka_broker_address -t my_json_topic -q | jq .

The -q flag makes kcat output only the message payloads. We pipe this output to jq to pretty-print JSON messages.

Conclusion

With kcat in your arsenal, you're well-equipped to conquer Kafka's intricacies. Whether you're debugging, monitoring, or building real-time data processing pipelines, kcat is your Swiss Army knife for Kafka tasks. Start exploring its capabilities, install kcat on your system, and embark on your Kafka journey with confidence. Happy streaming! 🌊🪄✨

Mastering jq: A Quick Guide to get you started

Sergio Marcial — Tue, 12 Sep 2023 04:11:19 +0000

Are you tired of wrestling with messy JSON data in your daily work as a software engineer? Do you find yourself spending too much time parsing, filtering, and transforming JSON data to fit your needs? Look no further! In this article, we will explore jq, a versatile command-line tool designed to make working with JSON data a breeze. 🌪️

Let's dive in! 💪

What is jq?

Before we jump into installation and usage, let's briefly introduce jq. In a nutshell, jq is a lightweight and powerful command-line tool that allows you to manipulate and transform JSON data effortlessly. It provides a range of functions for querying, filtering, formatting, and modifying JSON documents.

Installation

Unix and macOS

Option 1: Package Manager (Recommended)

If you're using a Unix-based system like Linux or macOS, the easiest way to install jq is through a package manager. For example, on systems with APT (Debian/Ubuntu), you can use:

sudo apt-get install jq

On systems with YUM (CentOS/Red Hat), you can use:

sudo yum install jq

For macOS users with Homebrew, it's as simple as:

brew install jq

Option 2: Manual Installation

If you prefer to install jq manually, visit the official website (https://stedolan.github.io/jq/download/) and download the appropriate binary for your system. Then, follow these steps:

Download the binary.
Make it executable:

chmod +x jq

Move it to a directory in your PATH (e.g., /usr/local/bin/):

sudo mv jq /usr/local/bin/

Windows

Windows users can also enjoy the benefits of jq by downloading the executable from the official website (https://stedolan.github.io/jq/download/) and following these steps:

Download the Windows binary.
Rename the binary to jq.exe.
Add the directory containing jq.exe to your system's PATH.

Now that you've successfully installed jq, let's explore its capabilities with some practical examples! 🚀

Basic Usage

Querying JSON Data

Let's start with a simple JSON document as an example:

{
  "name": "John Doe",
  "age": 30,
  "city": "New York"
}

Suppose you want to extract the "name" field. You can use jq like this:

echo '{"name": "John Doe", "age": 30, "city": "New York"}' | jq '.name'

This command will output:

"John Doe"

Filtering JSON Arrays

jq is also great for working with JSON arrays. Suppose you have an array of products:

[
  {
    "name": "Laptop",
    "price": 999
  },
  {
    "name": "Smartphone",
    "price": 599
  },
  {
    "name": "Tablet",
    "price": 349
  }
]

To filter this array to only include products with a price less than $500, you can use the following command:

echo '[{"name": "Laptop", "price": 999}, {"name": "Smartphone", "price": 599}, {"name": "Tablet", "price": 349}]' | jq '.[] | select(.price < 500)'

The output will be:

{
  "name": "Tablet",
  "price": 349
}

Formatting JSON Output

jq can also help you format JSON output for better readability. To pretty-print JSON, simply use the -r flag:

echo '{"name": "John Doe", "age": 30, "city": "New York"}' | jq -r

The output will be nicely formatted:

{
  "name": "John Doe",
  "age": 30,
  "city": "New York"
}

Advanced Usage with curl

As software engineers, we often need to interact with APIs that return JSON data. jq is an invaluable tool in these scenarios, allowing us to filter and process API responses seamlessly. Let's explore some examples using the curl command.

Example 1: Retrieve and Filter GitHub Repositories

Suppose you want to fetch a list of your GitHub repositories and extract only their names and star counts. You can achieve this with jq and curl like this:

curl -s https://api.github.com/users/your_username/repos | jq '.[] | {name: .name, stars: .stargazers_count}'

This command sends a GET request to the GitHub API, pipes the JSON response through jq, and extracts the desired fields. The result will be a list of objects containing repository names and star counts.

Example 2: Fetch Weather Data

Let's say you want to retrieve weather data from an API and display only the temperature. Here's how you can do it:

curl -s https://api.openweathermap.org/data/2.5/weather?q=your_city&appid=your_api_key | jq '.main.temp'

Replace your_city with the desired location and your_api_key with your API key. This command fetches weather data, extracts the temperature, and presents it neatly.

Conclusion

jq is a powerful tool that every software engineer should have in their toolkit. With its simple yet expressive syntax, you can effortlessly manipulate JSON data, whether it's in a file, a command output, or an API response. By mastering jq, you'll boost your productivity and make JSON wrangling a breeze. 🌐

So go ahead, install jq on your system, and start unleashing its potential today. Happy coding! 🎉

🚀🧪Unlocking the Power of Approval Testing 🔥💻

Sergio Marcial — Mon, 11 Sep 2023 13:05:31 +0000

Testing is the backbone of software development, ensuring the reliability and quality of our code. But when it comes to testing complex and ever-evolving software, traditional methods often fall short. That's where Approval Testing steps in—a revolutionary (but not new) approach that simplifies complex scenarios, embraces change, and helps you write more robust software. In this guide, we'll dive into the world of Approval Testing, understanding its fundamentals, its niche in software engineering, and how it differs from other testing methodologies. With code examples in some languages.

Approval Testing is a testing methodology that focuses on capturing the current output of a piece of code and then comparing it to a previously approved version. Instead of requiring developers to predict the exact output, Approval Testing encourages them to approve the current output as correct and uses it as a reference for future testing.

2. The Core Principles

To grasp the essence of Approval Testing, it's essential to understand its core principles:

No Predictions: Unlike traditional unit tests that require developers to predict the exact output, Approval Testing captures and approves the current output. This makes it suitable for scenarios where predictions are challenging.

Change Embrace: In agile development environments where change is constant, Approval Testing shines. It accommodates evolving codebases and minimizes the need for frequent test updates.

Versatility: Approval Testing isn't limited to a specific type of output. It can be applied to databases, APIs, GUIs, and any scenario involving textual or binary output.

3. Practical Application

Let's delve into a practical example to see how Approval Testing works in action. Suppose we have a function calculate_total_price that calculates the total price of items in a shopping cart:

def calculate_total_price(cart):
    total_price = sum(item.price for item in cart)
    return f'Total Price: ${total_price:.2f}'

With Approval Testing, we capture the current output:

from approvaltests.approvals import verify

cart = [Item("Item A", 10.99), Item("Item B", 7.50)]
result = calculate_total_price(cart)
verify(result)

4. The Niche Approval Testing Addresses

Approval Testing is designed to tackle specific challenges encountered by software engineers:

Complex Output: In scenarios where the output is complex or includes non-deterministic elements (e.g., timestamps), predicting exact values for unit tests can be daunting. Approval Testing eliminates the need for such predictions.
Evolving Codebases: Agile development environments thrive on change. Frequent code updates can cause traditional unit tests to break. Approval Testing embraces evolving codebases and adapts seamlessly.
Non-Visual Output: Unlike some testing methods that are primarily visual, Approval Testing is versatile. It can be employed for databases, APIs, and any scenario where textual or binary output is involved.

5. Key Benefits

Approval Testing offers several key benefits:

Simplified Testing: Approval Testing simplifies complex testing scenarios, especially when predicting exact outputs is challenging.

Adaptability: It adapts seamlessly to evolving codebases, reducing the need for frequent test updates.

Accurate Documentation: The approved output serves as documentation, allowing developers to understand the expected behavior easily.

6. Key Differences Between Approval Testing and Other Testing Methods

To appreciate Approval Testing fully, let's draw comparisons with other popular testing methods:

Unit Testing: Unit tests require developers to specify expected outcomes. Approval Testing, on the other hand, captures actual outcomes and uses them as references. This makes it especially effective for scenarios where predicting outcomes is challenging.
Integration Testing: Integration tests focus on interactions between components. While Approval Testing is not a replacement for integration tests, it can complement them by validating non-deterministic behavior within the integration.
Property-Based Testing: Property-based testing generates a large number of inputs to test code. Approval Testing doesn't generate inputs; instead, it captures and verifies outputs. This makes it suitable for scenarios where you're concerned with the correctness of outputs rather than input generation.

7. Code Examples in Different Languages

Let's explore Approval Testing through practical code examples in three popular programming languages: Python, Java, and JavaScript.

Python Example:

import unittest
from approvaltests.approvals import verify

def add_numbers(a, b):
    return a + b

class TestAddition(unittest.TestCase):
    def test_addition(self):
        result = add_numbers(2, 3)
        verify(result)

Java Example:

import org.junit.jupiter.api.Test;
import org.approvaltests.combinations.CombinationApprovals;

class CombinationTest {
    @Test
    void testCombination() {
        CombinationApprovals.verifyAllCombinations(
            (a, b) -> calculate(a, b),
            new int[]{1, 2, 3},
            new int[]{10, 20, 30}
        );
    }

    int calculate(int a, int b) {
        return a + b;
    }
}

JavaScript Example:

const { verify } = require('approvaltests');

function multiplyNumbers(a, b) {
    return a * b;
}

test('Multiplication Test', () => {
    const result = multiplyNumbers(5, 4);
    verify(result);
});

8. Real-World Use Cases

Approval Testing finds its application in a wide array of real-world scenarios. Some examples include:

Validating database migrations and ensuring schema compatibility.
Testing APIs and confirming the correctness of responses.
Verifying output in financial systems, where precision matters.
Ensuring consistent behavior in game development, where randomness is a factor.

9. Real-World Examples

Approval Testing finds application in a wide range of real-world scenarios:

Database Schema Validation: It ensures that database migrations maintain schema compatibility.

API Testing: Approval Testing validates the correctness of API responses.

Financial Systems: In financial systems where precision is crucial, Approval Testing guarantees accurate results.

Game Development: It's used to ensure consistent behavior in games, especially when randomness is involved.

10. Choosing the Right Tool

Selecting the right tool for Approval Testing is essential. Popular tools include ApprovalTests (for various languages), TextTest (for text-based approval), and others tailored to specific scenarios.

11. Conclusion 💪

Approval Testing is not just a testing methodology; it's a mindset shift. By embracing the power of Approval Testing, you can simplify testing scenarios, adapt to evolving codebases, and ensure the correctness of your software outputs. It's a versatile tool that can make your testing efforts more robust and resilient.

As you embark on your testing journey, consider integrating Approval Testing into your testing suite. It's a valuable addition that can help you write better code, reduce bugs, and improve the overall quality of your software.

Happy testing! 🚀🧪

🚀 Mastering Integration Testing in Rust with Testcontainers 🧪

Sergio Marcial — Wed, 06 Sep 2023 04:11:35 +0000

In the vast world of software engineering, testing plays an indispensable role in ensuring the reliability, stability, and performance of our applications. Among various testing types, integration testing stands out as a critical phase, verifying that different components of your system interact seamlessly. However, integration testing, especially when dealing with external dependencies like databases and message brokers, can be complex.

In this article, we will embark on a journey to master integration testing in Rust using a powerful tool known as Testcontainers. This tool simplifies the process of spinning up Docker containers for your integration tests, allowing you to test against real external systems in a clean and isolated environment.

🚀 Getting Started: Installing Rust

Before diving into integration testing with Testcontainers, let's ensure that your Rust development environment is set up correctly. Rust, known as "the language of systems," provides a robust foundation for building fast and reliable software.

Installing Rust on Windows

Visit the official Rust website here.
Download the Windows installer and run it.
Follow the on-screen instructions to complete the installation.
Open Command Prompt or PowerShell and run the following command to verify the installation:

   rustc --version

This command should display the Rust version, confirming a successful installation.

Installing Rust on macOS

Open Terminal, which comes pre-installed on macOS.
Install Rust using Homebrew, a popular package manager for macOS, with this command:

   brew install rust

After the installation completes, verify Rust's installation by running:

   rustc --version

You should see the Rust version displayed in the terminal, confirming that Rust is now installed on your macOS system.

🏗️ Setting Up the Integration Testing Project

Assuming you have a typical Rust project structure, which includes src/main.rs for your application code and tests/integration_test.rs for integration tests, we can proceed to set up our integration testing project.

To get started, add the Testcontainers dependency to your Cargo.toml file:

❯ cargo add testcontainers     
    Updating crates.io index
      Adding testcontainers v0.14.0 to dependencies.
             Features:
             - async-trait
             - bollard
             - conquer-once
             - experimental
             - signal-hook
             - tokio
             - watchdog
    Updating crates.io index

[dependencies]
testcontainers = "0.14.0"

Now, we're ready to dive into the specifics of integration testing with Testcontainers, using PostgreSQL as example.

🌐 Setting Up the Integration Testing Project

Assuming you have a typical Rust project structure, which looks like this:

my_rust_project/
|-- src/
|   |-- main.rs
|-- tests/
|   |-- integration_test.rs

src/main.rs contains your application code.
tests/integration_test.rs is where we'll write our integration tests.

🐳 Leveraging Testcontainers for Rust

Testcontainers provides an intuitive way to manage Docker containers for your integration tests. Let's explore how to use it effectively in Rust.

Testing PostgreSQL Integration

In your integration_test.rs file, you can set up and test a PostgreSQL container with the following code:


...

#[test]
async fn it_works() {
    let docker = clients::Cli::default();

    // Define a PostgreSQL container image
    let postgres_image = Postgres::default();

    let pg_container = docker.run(postgres_image);

    pg_container.start();

    WaitFor::seconds(60);

    // Get the PostgreSQL port
    let pg_port = pg_container.get_host_port_ipv4(5432);

    // Define the connection to the Postgress client
    let (client, connection) = tokio_postgres::Config::new()
        .user("postgres")
        .password("postgres")
        .host("localhost")
        .port(pg_port)
        .dbname("postgres")
        .connect(tokio_postgres::NoTls)
        .await
        .unwrap();

    // Spawn connection
    tokio::spawn(async move {
        if let Err(error) = connection.await {
            eprintln!("Connection error: {}", error);
        }
    });

    let _ = client
        .batch_execute(
            "
        CREATE TABLE IF NOT EXISTS app_user (
            id              SERIAL PRIMARY KEY,
            username        VARCHAR UNIQUE NOT NULL,
            password        VARCHAR NOT NULL,
            email           VARCHAR UNIQUE NOT NULL
            )
    ",
        )
        .await;

    let _ = client
        .execute(
            "INSERT INTO app_user (username, password, email) VALUES ($1, $2, $3)",
            &[&"user1", &"mypass", &"user@test.com"],
        )
        .await;

    let result = client
        .query("SELECT id, username, password, email FROM app_user", &[])
        .await
        .unwrap();

    let users: Vec<User> = result.into_iter().map(|row| User::from(row)).collect();

    let user = users.first().unwrap();

    assert_eq!(1, user.id);
    assert_eq!("user1", user.username);
    assert_eq!("mypass", user.password);
    assert_eq!("user@test.com", user.email);
}

In this test, we:

Create a Docker client.
Define a PostgreSQL container image.
Run the PostgreSQL container, expose its ports, and set the user and password.
Retrieve the PostgreSQL port and add it to the connection URL.
Connect to the PostgresSQL DB using tokio_postgres
We need to spawn a new connection
Write your database integration test code using the client.

🏃 Running the Integration Tests

To run your integration tests, use the following command:

❯ cargo test --test integration_test
   Compiling testcontainer_example v0.1.0 (/Users/sergiomarcial/Documents/Confidential/repositories/github/testcontainers-rust)
    Finished test [unoptimized + debuginfo] target(s) in 1.76s
     Running tests/integration_test.rs (target/debug/deps/integration_test-ff1cb10ac2b24a1b)

running 1 test
test it_works ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 2.11s

This command will execute all the tests in your integration_test.rs file.

Code example

For a complete example using Rust and Postgres testcontainers, check out my GitHub repository.

🔄 Exploring Alternatives and Considerations

While Testcontainers simplifies integration testing, it's crucial to explore alternative approaches like mocking or using Docker Compose for more complex setups. Choose the approach that best aligns with your project's requirements.

🎉 Conclusion

Integration testing in Rust can be made effortless and efficient with Testcontainers. You've learned how to set up your project, install dependencies, and write integration tests for PostgreSQL. This newfound knowledge empowers you to ensure that your Rust applications seamlessly interact with external dependencies, bolstering the robustness and reliability of your software. Happy testing!

📚 Further Reading

Integration testing has never been this enjoyable! 🐳🦀

🚀 Effortless Integration Tests with Testcontainers in Golang 🧪

Sergio Marcial — Mon, 04 Sep 2023 16:56:09 +0000

Testing is a vital part of software development, ensuring that your applications run as expected in real-world scenarios. However, writing effective integration and functional tests can be challenging, especially when dealing with databases, message brokers, and external services. In this article, we'll explore how to harness the power of Testcontainers to simplify testing in Golang. Whether you're a beginner or an experienced developer, you'll gain valuable insights into writing robust integration and functional tests using Testcontainers.

🏁 Setting Up Your Development Environment

Before we dive into code examples, let's ensure your development environment is ready. We'll cover installing Golang on both Windows and macOS.

Installing Golang on Windows

Download the Windows installer from the official Golang website.
Run the installer and follow the on-screen instructions.
Open Command Prompt and run go version to verify the installation.

Installing Golang on macOS

There are 2 options to install Golang on macOs

Follow wthe official documentation:

Download the macOS installer from the official Golang website.
Open the downloaded package and follow the installation instructions.
Open Terminal and run go version to verify the installation.

Or use homebrew

brew install go

📦 Installing Testcontainers Go Package

Now, let's install the Testcontainers Go package. Open your terminal/command prompt and run:

go get github.com/testcontainers/testcontainers-go

🌐 Setting Up the Project

Let's assume we're working on a Golang application that interacts with a PostgreSQL database and Kafka message broker. We want to write integration and functional tests for these components.

Project Structure

Here's a typical project structure:

myapp/
|-- main.go
|-- database/
|   |-- database.go
|   |-- database_test.go
|-- messaging/
|   |-- kafka.go
|   |-- kafka_test.go
|-- test/
|   |-- integration_test.go

In this structure:

main.go contains your application code.
database/database.go handles database interactions.
database/database_test.go handles database unit testing (We are not interested there, for this article).
messaging/kafka.go manages Kafka communication, creating kafka consumers and/or producer.
messaging/kafka_test.go handles kafka unit testing (We are not interested there, for this article).
test/ is where we'll write our integration tests.

📋 Writing the Test

Let's create an integration test for the PostgreSQL database. In integration_test.go, add the following code:

package test

import (
    "context"
    "database/sql"
    "testing"

    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/wait"
    _ "github.com/lib/pq" // Import the PostgreSQL driver
)

func TestPostgreSQLIntegration(t *testing.T) {
    ctx := context.Background()

    // Define a PostgreSQL container
    req := testcontainers.ContainerRequest{
        Image:        "postgres:latest",
        ExposedPorts: []string{"5432/tcp"},
        WaitingFor:   wait.ForLog("database system is ready to accept connections"),
    }

    // Create the container
    container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: req,
        Started:          true,
    })
    if err != nil {
        t.Fatal(err)
    }
    defer container.Terminate(ctx)

    // Get the PostgreSQL port
    host, port, _ := container.Host(ctx)
    dsn := "user=postgres password=postgres dbname=postgres sslmode=disable host=" + host + " port=" + port

    // Connect to the database
    db, err := sql.Open("postgres", dsn)
    if err != nil {
        t.Fatal(err)
    }
    defer db.Close()

    // Your database test code here

    // Clean up
    if err := container.Terminate(ctx); err != nil {
        t.Fatal(err)
    }
}

In this test:

We define a PostgreSQL container using Testcontainers.
We start the container and retrieve the host and port for database connection.
We connect to the database and perform our test operations.
Finally, we clean up by terminating the container.

This ensures that each test runs in an isolated PostgreSQL container.

🚀 Testing Kafka

Similarly, you can create integration tests for Kafka. In integration_test.go, add the following code:

package test

import (
    "context"
    "testing"

    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/wait"
)

func TestKafkaIntegration(t *testing.T) {
    ctx := context.Background()

    // Define a Kafka container
    req := testcontainers.ContainerRequest{
        Image:        "confluentinc/cp-kafka:latest",
        ExposedPorts: []string{"9092/tcp"},
        WaitingFor:   wait.ForLog("listeners started on advertised listener"),
    }

    // Create the container
    container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: req,
        Started:          true,
    })
    if err != nil {
        t.Fatal(err)
    }
    defer container.Terminate(ctx)

    // Your Kafka test code here

    // Clean up
    if err := container.Terminate(ctx); err != nil {
        t.Fatal(err)
    }
}

🔄 Running the Tests

You can run your tests using the go test command:

go test ./test/

For a complete example using Golang and Postgres testcontainers, check out this GitHub repository.

🔄 Alternatives and Comparisons

While Testcontainers is a powerful tool, it's essential to know about alternatives and when to use them:

Mocking: For unit tests, you might opt for mocking libraries like github.com/stretchr/testify/mock to simulate database and Kafka interactions. This approach is suitable for unit tests but lacks the realism of actual containers.
Docker Compose: If you prefer using Docker Compose for your tests, it provides more flexibility but requires additional setup and maintenance.

💡 Conclusion

Testcontainers in Golang opens the door to efficient integration and functional testing. It allows you to create and manage containers effortlessly, ensuring that your tests reflect real-world scenarios. With Testcontainers, you can write robust, reliable tests for your Golang applications.

Happy testing! 🚀🐳

📚 Further Reading

Testcontainers Go Documentation

🚀 Level up Your Testing Game: Harness the Power of Testcontainers with Java and Spring Boot 🧪

Sergio Marcial — Mon, 04 Sep 2023 05:27:21 +0000

Introduction

Testing is an integral part of software development. It ensures that our applications work as expected and guards against unexpected regressions. As engineers, it becomes crucial for us to explore reliable and efficient testing practices early in our careers. In this article, we will dive into integration and functional testing by implementing Testcontainers with Java and Spring Boot, unleashing the power of containerization in our testing workflow. Let's get started! 🎉

What are Integration and Functional Testing?

Integration testing involves validating the interaction between different components of an application, ensuring they work cohesively. On the other hand, functional testing verifies the functionality of individual units within the application. Both types of tests complement each other, providing comprehensive coverage to prevent potential bugs or issues in our software.

Introducing Testcontainers 🐳

Testcontainers is an open-source Java library that enables developers to seamlessly create, manage, and orchestrate Docker containers for isolated testing environments. By integrating Testcontainers with our testing framework, we can easily provision containers, such as databases or message brokers, while writing tests, ensuring accurate and efficient integration and functional testing.

Setting Up Testcontainers with Maven and Gradle 📦

To leverage the power of Testcontainers, we need to add the necessary dependencies in our build tool setups.

Maven Example 🧩

In your pom.xml file, include the following dependencies:

<dependency>
  <groupId>org.testcontainers</groupId>
  <artifactId>testcontainers</artifactId>
  <version>1.19.0</version>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.testcontainers</groupId>
  <artifactId>junit-jupiter</artifactId>
  <version>1.19.0</version>
  <scope>test</scope>
</dependency>

Gradle Example 🧪

In your build.gradle file, add the dependencies:

testImplementation 'org.testcontainers:testcontainers:1.19.0'
testImplementation 'org.testcontainers:junit-jupiter:1.19.0'

In your build.gradle.kts file, add the dependencies:

testImplementation("org.testcontainers:testcontainers:1.19.0")
testImplementation("org.testcontainers:junit-jupiter:1.19.0")

With these dependencies in place, we are ready to explore the magic of Testcontainers! ✨

Using Testcontainers with Spring Boot Example 💻

Let's dive into a practical example of how to leverage Testcontainers with Spring Boot framework for integration testing:

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@SpringBootTest
@TestPropertySource(locations="classpath:application-test.yaml")
public class MyIntegrationTests {

  @Container
  private static final PostgreSQLContainer<?> postgresContainer = new PostgreSQLContainer<>("postgres:latest");

  // Your tests go here
}

In this example, we have annotated our test class with @Testcontainers, defining it as a test container-aware class. We also added @SpringBootTest to enable Spring Boot-specific configuration and @TestPropertySource to load specific test properties.

Using the @Container annotation, we declare an instance of the PostgreSQL container. Testcontainers automatically starts and stops the container for each test execution. You can easily configure other containers such as MySQL or Redis, depending on your requirements.

You can also include the spring boot dependency

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-testcontainers</artifactId>
  <version>3.1.3</version>
  <scope>test</scope>
</dependency>

Gradle Example 🧪

In your build.gradle file, add the dependencies:

testImplementation 'org.springframework.boot:spring-boot-testcontainers:3.1.3'

In your build.gradle.kts file, add the dependencies:

testImplementation("org.springframework.boot:spring-boot-testcontainers:3.1.3")

Using Testcontainers with Spring Boot Example containers as beans 💻

import org.springframework.boot.test.context.TestConfiguration
import org.springframework.boot.testcontainers.service.connection.ServiceConnection
import org.springframework.context.annotation.Bean
import org.testcontainers.containers.PostgreSQLContainer
import org.testcontainers.containers.wait.strategy.Wait
import org.testcontainers.utility.DockerImageName
import java.time.Duration

@TestConfiguration(proxyBeanMethods = false)
class TestConfig {

    @Bean
    @ServiceConnection
    fun postgresSqlContainer(): PostgreSQLContainer<*> =
        PostgreSQLContainer(
            DockerImageName.parse("postgres:latest"),
        ).also {
            it.setWaitStrategy(
                Wait.defaultWaitStrategy()
                    .withStartupTimeout(Duration.ofSeconds(30)),
            )
        }.run {
            this.start()
            this
        }
}

This will allows to re use the container across multiple tests without the need to restart.

For a complete example using Kotlin, check out this GitHub repository.

Advantages and Alternatives 😎

Testcontainers provide numerous benefits for integration and functional testing:

✅ Isolation: Testcontainers create isolated environments for testing, avoiding interference with external dependencies or shared environments.

✅ Reproducibility: Each test run starts with a clean environment, eliminating any issues caused by conflicting or stale state.

✅ Ease of Use: Testcontainers seamlessly integrates with popular testing frameworks and reduces the complexity of setting up separate testing environments.

While Testcontainers is an excellent choice for testing, there are alternative tools available too. Some significant alternatives include Docker Compose, Mountebank, and WireMock. Each has its unique advantages, so you should choose based on your specific needs.

Conclusion 🔍

By incorporating Testcontainers in your testing repertoire, you can achieve efficient and robust integration and functional testing with ease. Its seamless integration with Java and Spring Boot makes it a perfect choice for leveraging containerization in your test suites. Start your journey with Testcontainers today, and level up your testing game! 🚀

Remember, investing time in learning reliable testing practices early in your career will pay dividends in the long run. Happy testing! 🧪

Breaking Up with @Autowired: Why Dependency Injection with Spring Boot Needs a Makeover! 💔

Sergio Marcial — Sun, 03 Sep 2023 23:10:28 +0000

Introduction:
🎶 Love hurts, but sometimes love smokes your codebase! 🎶 let's talk about why the beloved @Autowired annotation in Spring Boot might not be the best match for your dependency injection needs. In this article, we'll explore the downsides of using @Autowired, discuss its impact on your codebase, and present alternative strategies to keep your codebase clean and healthy. Let's dive in! 🏊

😕 What's Wrong with @Autowired?
First things first! The @Autowired annotation might initially seem like a match made in heaven, promising effortless dependency injection in your Spring Boot projects. However, relying excessively on @Autowired can lead to several issues, turning it into a coding smell. Let's break them down:
⛈️ Tight Coupling Alert!
One major drawback of @Autowired is that it tightly couples your components, creating a web of dependencies that are difficult to trace and maintain (not that other forms of dependency injection not, they are just easier to identify). As your codebase grows, determining where exactly a dependency is injected becomes a daunting task. Take the following example:

@Component
public class ServiceA {
    @Autowired
    private ServiceB serviceB;

    // ...
}

Here, the ServiceA is directly dependent on the ServiceB, severely limiting the flexibility of your code. Changes to the ServiceB or adding alternative implementations can potentially lead to cascading changes throughout your codebase. 😱

🙊 Hidden Dependencies When utilizing @Autowired, you might encounter instances where dependencies remain unclear or hidden. This creates a veil of uncertainty, making it harder for developers to understand the internal workings and requirements of components they are interacting with. Consider this example:

@Component
public class ShoppingCartService {
    @Autowired
    private PaymentService paymentService;

    // ...
}

Without explicitly declaring the requirement for a PaymentService in the constructor or through method parameters, new developers ramping up in your code might struggle to grasp the essential dependencies of the ShoppingCartService or miss them completely. 👀

🔒 Testing becomes a Nightmare Writing test cases becomes increasingly complex when using @Autowired extensively. In order to effectively test a single component, you often end up dragging in multiple dependencies and configuring an elaborate setup. This makes test cases fragile and difficult to maintain. Take a look at this example:

@SpringBootTest
class CustomerServiceTest {
    @Autowired
    private CustomerService customerService;

    @Autowired
    private OrderService orderService;

    @Autowired
    private PaymentService paymentService;

    // ...
}

In this scenario, testing the CustomerService becomes tedious due to the cascading dependencies mocking required for the successful execution of tests. 😓

🛠️ A Clean & Healthy Alternative:

Constructor Injection

So, how can we overcome these challenges? 👉 Constructor Injection to the rescue! Constructor Injection promotes explicit declaration of dependencies and allows for clearer code comprehension. Let's see how the refactored examples look:

@Component
public class ServiceA {
    private final ServiceB serviceB;

    public ServiceA(ServiceB serviceB) {
        this.serviceB = serviceB;
    }
    // ...
}

@Component
public class ShoppingCartService {
    private final PaymentService paymentService;

    public ShoppingCartService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
    // ...
}

By using constructor injection, we eliminate surprises and make dependencies explicit, leading to cleaner and more maintainable code. 🧹

Conclusion:
In this article, we mentioned some of the downsides of relying excessively on Spring Boot's @Autowired annotation for dependency injection. We explored the challenges it poses, such as tight coupling, hidden dependencies, and testing complexities. Fortunately, we present an elegant solution - constructor injection. Embrace constructor injection, and you'll foster codebases that are clean, comprehensible, and hassle-free to test! 🎉

Remember, while it's okay to have a fling with @Autowired early on in your coding adventures, it's crucial to break up after the honeymoon phase ends to ensure a long-lasting, healthy relationship with your codebase. Happy coding! 💻🚀

Comparing Ktor and Micronaut: Kotlin-Powered Application Servers 🔥💻

Sergio Marcial — Mon, 28 Aug 2023 05:05:09 +0000

👋 Hey there! Are you ready to explore the exciting world of Kotlin-powered application servers? Well, you're in for a treat today, as we dive into a head-to-head comparison between two popular frameworks - Ktor and Micronaut. 🚀

📌 Introduction:
Kotlin has become the go-to language for modern Android app development, thanks to its conciseness, expressiveness, and safety features. But did you know that Kotlin is also a top choice for creating server-side applications? Both Ktor and Micronaut leverage the power of Kotlin to provide developers with efficient and feature-rich application servers. 🌐

So, let's embark on this comparison journey and discover which framework suits your project requirements the best! Let's begin with a brief overview of both frameworks.

🔍 Ktor:
Ktor is a lightweight web framework built by JetBrains specifically for Kotlin developers. It harnesses Kotlin's DSL capabilities to offer flexibility, simplicity, and extensibility for creating robust and scalable server-side applications. 😎

Here's a code snippet that showcases the simplicity and elegance of Ktor:

import io.ktor.application.*
import io.ktor.routing.*
import io.ktor.server.engine.embeddedServer
import io.ktor.server.netty.Netty

fun Application.module() {
    routing {
        get("/") {
            call.respondText("Hello, Ktor!")
        }
    }
}

fun main() {
    embeddedServer(Netty, port = 8080, module = Application::module).start(wait = true)
}

🔍 Micronaut:
Micronaut, on the other hand, is a modern and lightweight framework designed for building microservices and serverless applications. It provides dependency injection, AOP, and other advanced features out of the box to boost developer productivity. 🤩

Behold a simple Micronaut example filled with Micronaut's magic ✨:

import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.client.annotation.Client
import io.micronaut.http.client.annotation.Client
import io.micronaut.runtime.Micronaut

@Controller("/hello")
class HelloController {

    @Get("/")
    fun hello(): String {
        return "Hello, Micronaut!"
    }
}

fun main() {
    Micronaut.run(HelloController::class.java)
}

📊 Comparison:
Now that we've seen the opening acts from both Ktor and Micronaut let's dive into the various aspects that may influence your decision:

💨 Performance:
When it comes to raw performance, both frameworks shine. However, Ktor gains an edge due to its lightweight nature and minimal overhead.

📐 Architecture:
Micronaut embraces a more opinionated approach with convention-over-configuration, making it an excellent choice for rapid development. Ktor, on the other hand, allows developers to have full control over their application's architecture and design.

🔌 Integration:
Micronaut's extensive dependency injection capabilities make it seamless to integrate with existing frameworks and libraries. While Ktor offers decent integration possibilities, it is more suitable for small to mid-sized projects.

🔧 Tooling & Community Support:
Both frameworks have an active and growing community with reliable documentation and excellent tooling support.

🏁 Conclusion:
Ultimately, selecting between Ktor and Micronaut depends on the specific needs of your project. If you prioritize simplicity and control, Ktor may be ideal for you. On the other hand, if you aim for rapid development and seamless integrations, Micronaut should be your go-to. 💡

Whichever framework you choose, you can unleash the power of Kotlin to build high-performance and scalable server-side applications. 🚀

And that's a wrap! We hope this comparison provided clarity for your next venture into Kotlin-powered application servers. Happy coding, and may the Kotlin force be with you! 🌟✨

Got any questions or experiences to share? Drop a comment below and let's discuss! 👇

Until next time, happy coding! 😄

📢 Strong Consistency: The Backbone of Reliable Data 💪

Sergio Marcial — Mon, 28 Aug 2023 05:00:38 +0000

Do you ever wonder how applications handle data updates and ensure they remain consistent across various systems? As a beginner engineer, understanding strong consistency is essential for building reliable and robust software. Let's dive into what strong consistency is, why it's crucial, real-world applications, and when it's discouraged. 😎

🔍 What is Strong Consistency?
Strong consistency is a property of distributed systems, ensuring that each read operation receives the most recent write operation's result. In simpler terms, it guarantees that every client or node accessing data sees the same view of the data at any given time. This approach provides clarity, predictability, and maintains data integrity across the system.

🏆 Why is Strong Consistency Important?
Imagine a banking application that allows simultaneous transfers from the same account to multiple destinations. Without strong consistency, different nodes could read different values, leading to discrepancies or even financial losses. Strong consistency solves this problem by making sure that all transactions reflect the most recent updates, preventing conflicts and preserving data integrity. It brings order to the chaos of concurrent modifications! 🎉

🌎 Real-World Applications:
Strong consistency finds application in numerous real-world scenarios. Let's explore a couple of them with examples and code snippets.

1️⃣ Shopping Cart Checkout:
Consider an e-commerce platform with thousands of users simultaneously adding items to their shopping carts. By employing strong consistency, each user will always see the latest added items, ensuring an accurate and consistent shopping experience. Here's a simplified code snippet showcasing strong consistency while updating the cart:

function addItemToCart(userId, itemId) {
  const user = getUser(userId);  // Retrieves the user's current cart
  user.cart.addItem(itemId);     // Adds the selected item to the cart
  saveUser(user);                // Persists the updated cart
}

2️⃣ Collaborative Document Editing:
In collaborative editing tools like Google Docs, multiple users can edit the same document simultaneously. Strong consistency guarantees that all collaborators see the same document, avoiding contradictory changes. Here's a brief code example:

def editDocument(userId, docId, newText):
  doc = getDocument(docId)       # Retrieves the document
  doc.addText(newText)           # Adds the new text to the document
  saveDocument(doc)              # Persists the updated document

🚫 When is Strong Consistency Discouraged?
While strong consistency is powerful, it may not be suitable for every use case due to performance limitations or network latency. For example, social media platforms prioritize low latency and availability over strong consistency. In these cases, eventual consistency or weaker consistency models may be preferred. Let's explore a scenario where strong consistency could lead to undesired results:

3️⃣ Ticket Booking System:
Imagine a ticket booking system where multiple users can reserve seats for the same event. If strong consistency is enforced, it might lead to overselling or inconsistent seat availability. In this situation, a loosely consistent model allows better performance and avoids conflicts. Here's an illustration:

def bookTicket(userId, eventId, seatNumber):
  if isSeatAvailable(eventId, seatNumber):
    reserveSeat(eventId, seatNumber)    # Reserve the seat for the user
    chargeUser(userId)                  # Charge the user for the ticket

📚 Conclusion:
Understanding strong consistency is vital for building robust distributed systems. Its ability to maintain data integrity, predictable behavior, and consistent user experiences make it a valuable tool for engineers. Remember, strong consistency is not always the go-to solution due to performance trade-offs, making it crucial to evaluate the specific needs of your application before implementation. 🌟

Thanks for joining me in this journey exploring strong consistency! I hope you found this article helpful! Feel free to leave any comments or questions below! 👇

🔖 Tags: #beginner #distributedsystems #strongconsistency #reliability

🔥 Decoding Eventual Consistency 🔥

Sergio Marcial — Mon, 28 Aug 2023 04:59:16 +0000

🏆 Hey there, fellow engineers! 👋 Are you curious about the term "eventual consistency"? 🤔 Well, you've come to the right place. In this article, we'll demystify what eventual consistency is, why it's important, how it applies in real-world scenarios (especially within event-driven architectures), and even when it's discouraged. So, brace yourselves for an enlightening journey through the realms of eventual consistency! 🚀

🤔 What is Eventual Consistency? 🌟

Eventual consistency is a concept that plays a key role in distributed systems. It describes the state where, after a period of a distributed system returning various responses during concurrent updates, all replicas will eventually converge to a consistent state. In simpler terms, it means that even if different instances of a system have temporary inconsistencies, they will eventually synchronize to the same outcome. 🌈

⚡️ Why is Eventual Consistency Important? ⚡️

Since distributed systems often span across numerous servers, each having its own copy of data, ensuring immediate consistency across all replicas can be challenging. Eventual consistency allows systems to make progress even when certain replicas are unreachable or experiencing network issues. This resilience is crucial for systems with high scalability, availability, and performance requirements. By choosing eventual consistency over immediate consistency, engineers can design systems that remain operational even during failures or periods of high demand. 😎

💡 Applying Eventual Consistency in the Real World 💼

Let's dive into the world of event-driven architectures where eventual consistency shines 🌟 Check out two common use cases for eventual consistency:

1️⃣ Social Media platforms: Imagine posting a tweet on a popular social media platform. Immediately after hitting that tweet button 💥, you expect your followers to see your message. Behind the scenes, though, the platform leverages eventual consistency to handle the vast number of followers in an efficient, scalable manner. Instead of waiting for each follower's timeline to be updated simultaneously, the platform initially updates only a subset of timelines, ensuring better performance and responsiveness. Over time, remaining timelines catch up, delivering a consistent experience to all users. 🦜

2️⃣ Online Shopping: Picture yourself in the realm of e-commerce. When you place an order, the system needs to ensure inventory is available. In this case, eventual consistency allows the system to temporarily show an item as "in stock" even if it might be running low. This ensures a smooth shopping experience while avoiding out-of-stock errors. The system periodically updates stock levels and adjusts the status accordingly, ensuring consistency in the long run. By using eventual consistency in this scenario, the system can handle surges in traffic without negatively impacting the user experience. 🛒

✨ Examples & Code Snippets 📝

Let's deep-dive into some code snippets in a simplified event-driven architecture to bring clarity to how eventual consistency looks in practice:

from event_bus import EventBus

def send_order_confirmation(order):
  # Process order confirmation logic
  print(f"Order #{order.id} confirmed!")

event_bus = EventBus()
event_bus.subscribe("order_placed", send_order_confirmation)

def place_order(order):
  # Place order logic
  event_bus.publish("order_placed", order)
  print(f"Order #{order.id} placed!")

In this example, when an order is placed, a message is published on the event bus with the event name "order_placed" and the corresponding order as a payload. The function send_order_confirmation is subscribed to the "order_placed" event and executes the necessary confirmations asynchronously. This event-driven architecture harnesses eventual consistency by processing events as they arrive, allowing for asynchronous and parallel processing. 🎉

🚫 When to Avoid Eventual Consistency 🚫

While eventual consistency offers numerous benefits, there are scenarios where it should be used with caution:

1️⃣ Banking Transactions: In cases where immediate consistency is crucial, like financial systems, eventual consistency might not provide the desired level of confidence. Ensuring that each transaction is committed consistently across all replicas minimizes risks and guarantees integrity.

2️⃣ Real-Time Collaborative Editors: In collaborative editing tools like Google Docs, immediate consistency is essential to ensure that all participants see the same content concurrently. Waiting for eventual consistency to update changes could lead to significant conflicts and inconsistencies.

📚 Further Reading 📚

If you're eager to dive deeper into eventual consistency, here are some resources to feed your curiosity:

"Designing Data-Intensive Applications" by Martin Kleppmann
"Eventuate" by Chris Richardson
"Eventual Consistency" - Wikipedia
"Understanding and Using Eventual Consistency" - Microsoft Research

💡 Wrapping Up 💡

Congratulations, my fellow engineers! 🎉 You've successfully unraveled the mystery of eventual consistency, understanding its significance in distributed systems, real-world applications, code snippets, and even scenarios where it's discouraged. Remember, eventual consistency is an invaluable tool for designing scalable and resilient systems. So, dive into this event-driven world, embrace eventual consistency, and architect systems that can conquer any challenge! 🌟 Happy coding! 💻

DEV Community: Sergio Marcial

Unveiling gRPC: Empowering Microservices Beyond REST 🚀

Introduction:

What is gRPC?

Benefits of gRPC:

gRPC in Microservices:

gRPC vs. REST:

gRPC:

REST:

When to Choose gRPC:

Code Examples:

Go: Creating a gRPC server and client.

Python: Defining a service using Protobuf and Python.

Node.js: Implementing a gRPC server and client in Node.js.

Further Reading:

✨ Mermaid Markdown: Adding Life and Creativity to your GitHub Markdown Files 👩‍💻🌈📄

Introduction 🚀

What is Mermaid Markdown? 🧜‍♀️

What problem does Mermaid Markdown aim to solve? 🎯

Enriching your Markdown in GitHub with Mermaid Markdown 🌟

Install a Markdown editor with Mermaid support 📝

Include Mermaid Markdown in your Markdown file 🖊️

Examples:

Preview your Markdown locally ✨

Commit and push your changes to GitHub 🚀

Kafka Simplified with kcat (kafka cat) 🚀

Introducing kcat

Installation

Unix and macOS

Option 1: Package Manager (Recommended)

Option 2: Manual Installation

Windows

Basic Usage

Kafka Message Consumption

Producing Kafka Messages

Advanced Usage

Custom Consumer Groups

Consuming and Writing to a File

Filtering and Transforming Messages

Kafka Header Support

Custom Authentication

Supercharge Kafka with kcat and jq

Conclusion

Mastering jq: A Quick Guide to get you started

What is jq?

Installation

Unix and macOS

Option 1: Package Manager (Recommended)

Option 2: Manual Installation

Windows

Basic Usage

Querying JSON Data

Filtering JSON Arrays

Formatting JSON Output

Advanced Usage with curl

Example 1: Retrieve and Filter GitHub Repositories

Example 2: Fetch Weather Data

Conclusion

🚀🧪Unlocking the Power of Approval Testing 🔥💻

Table of Contents:

1. What is Approval Testing?

2. The Core Principles

3. Practical Application

4. The Niche Approval Testing Addresses

5. Key Benefits

6. Key Differences Between Approval Testing and Other Testing Methods

7. Code Examples in Different Languages

Python Example:

Java Example:

JavaScript Example:

8. Real-World Use Cases

9. Real-World Examples

10. Choosing the Right Tool

11. Conclusion 💪

🚀 Mastering Integration Testing in Rust with Testcontainers 🧪

🚀 Getting Started: Installing Rust

Installing Rust on Windows

Installing Rust on macOS

🏗️ Setting Up the Integration Testing Project

🌐 Setting Up the Integration Testing Project