DEV Community: Jasseem Allybokus

Simplifying Event Sourcing in Golang

Jasseem Allybokus — Fri, 24 Jan 2025 09:47:03 +0000

Event sourcing and CQRS (Command Query Responsibility Segregation) are powerful architectural patterns for building scalable and maintainable systems. However, implementing them can be complex, especially when you’re striving to follow best practices like Domain-Driven Design (DDD). That’s where thefabric-io/eventsourcing comes in.

In this post, I’ll walk you through how this open-source library simplifies event sourcing in Go, its core features, and how you can get started.

Why Event Sourcing?

Event sourcing is more than just a storage pattern. Instead of persisting the current state of an object, it captures all state changes as a sequence of events. This approach provides several advantages:

Scalability: Events are immutable, making them easier to scale.
Auditability: The full history of changes is stored.
Flexibility: Replay events to reconstruct the state or debug issues.

Combined with CQRS, you can separate the responsibility of writing (commands) and reading (queries), leading to clean and focused code.

Introducing thefabric-io/eventsourcing

This library is designed to make event sourcing easier to implement in Go while staying true to DDD principles. It provides the building blocks for defining aggregates, managing events, and maintaining projections.

Key Features

Aggregate Management: Simplifies handling aggregate lifecycles.
Event Storage: Built-in logic for persisting and replaying events.
CQRS Integration: Supports separating reads and writes.
Extensibility: Adaptable to various domains and storage backends.

Getting Started

To see the library in action, you can explore the example repository:
thefabric-io/eventsourcing.example. It includes a detailed implementation showcasing the library's capabilities.

Installation

First, install the library using:

go get github.com/thefabric-io/eventsourcing

Example Overview

The example repository provides a comprehensive guide to using the library. You’ll find a setup for managing aggregates, emitting events, and processing them. It demonstrates practices for structuring your project, handling events, and building projections.

You can clone and run the example with the following commands:

git clone https://github.com/thefabric-io/eventsourcing.example.git
cd eventsourcing.example
go run main.go

This example illustrates how to:

Define aggregates and their behaviors.
Persist and replay events.
Query projections for read-side operations.

Refer to the thefabric-io/eventsourcing.example repository for detailed explanations and context.

Real-World Use Cases

Imagine a CRM system where users can create and update customer inquiries. Each change is captured as an event, allowing:

Reconstruction of the inquiry's history for debugging.
Seamless integration of projections for analytics dashboards.
Event-driven triggers for sending notifications.

With thefabric-io/eventsourcing, these workflows become intuitive and maintainable.

Get Involved

Check out the GitHub repositories:

Library: thefabric-io/eventsourcing
Example: thefabric-io/eventsourcing.example

Feel free to:

Star the repos if you find them useful.
Report issues or request features.
Contribute by submitting pull requests.

Conclusion

Event sourcing doesn’t have to be complicated. With thefabric-io/eventsourcing, you can focus on building robust, scalable applications without getting bogged down in boilerplate.

I hope this library helps you on your journey to mastering event sourcing in Go. If you have any questions or feedback, feel free to reach out or open an issue on GitHub. Let’s build better software together!

AI is the New Order

Jasseem Allybokus — Thu, 23 Jan 2025 05:18:31 +0000

Original post

AI has transformed system design by bringing order to chaos, enabling us to shift from rigid structures to dynamic, human-like understanding.

For decades, developers have built software systems rooted in a paradigm of structure. Data was clean, predictable, and organized into tables, schemas, and hierarchies that machines could easily interpret. This was not a matter of preference but a necessity—machines were only capable of processing data that adhered to rigid formats. Any nuance, ambiguity, or semantic richness that humans took for granted had to be stripped away and translated into strict logic, rows, and columns. The result? A world of applications that thrived on order but were blind to the messiness of reality.

Then came Large Language Models (LLMs), and with them, a seismic shift in how we think about data, systems, and intelligence. AI didn’t just change the tools we use; it redefined the rules of the game. Welcome to the new paradigm: AI is the new order.

The Old Paradigm: Structure Above All

In the pre-AI era, application development revolved around structured data. Databases were the cornerstone of every system, meticulously designed to capture information in fixed formats. Whether you were building an e-commerce site, a social network, or a logistics platform, success hinged on predictability and precision. Data flowed neatly through pipelines, and any ambiguity was resolved before it reached the machine.

But this approach had limitations. Real-world data is inherently messy. Language, images, and human interactions are full of nuance, context, and variability. The structured paradigm forced developers to ignore or oversimplify this complexity. Machines could not understand context or semantics, so developers had to design around this gap, creating systems that were powerful but ultimately brittle in the face of real-world ambiguity.

This rigidity extended beyond just databases. It shaped the very way we thought about building applications. Developers spent enormous effort defining schemas, designing data validation pipelines, and writing strict rules to ensure consistency. While this was effective for certain types of problems, it left little room for innovation in domains where the human experience, language, and perception mattered most. The gap between machine logic and human understanding was vast and unbridgeable with the tools of the time.

The New Paradigm: Semantic Understanding

The rise of LLMs, like OpenAI’s GPT models, marked the end of this constraint. For the first time, machines could understand and generate human-like language, unlocking the ability to process unstructured, chaotic, and context-rich data. These models don’t require every piece of data to be pre-labeled or categorized. Instead, they thrive on ambiguity, extracting meaning and insights from even the most disorganized inputs.

This capability has profound implications:

From Data Rules to Data Chaos: In the past, systems failed when data broke the rules. Today, AI finds patterns and meaning in chaotic, unstructured environments, allowing developers to work with data as it exists, not as it’s forced to be.
From Query to Conversation: Traditional systems relied on rigid queries and predefined inputs. With AI, interactions become dynamic and conversational, bridging the gap between machine logic and human communication.
From Builders to Orchestrators: Developers are no longer constrained to rigid workflows. Instead, they orchestrate systems that let AI navigate complexity, interpreting inputs and outputs in ways that mimic human understanding.

This transition has also redefined the relationship between developers and the systems they create. Instead of micromanaging every rule and edge case, developers can now focus on higher-order design principles—crafting systems that leverage AI’s ability to handle complexity, adapt to new contexts, and continuously learn from data.

Implications for System Design

With this new paradigm, the very act of conceiving systems must evolve. Here’s how:

1. Data as a Living Entity

In the AI-driven world, data is no longer static or pre-processed. It is dynamic, context-rich, and continuously changing. Systems must be designed to embrace this fluidity, allowing AI to interpret meaning on the fly. This means abandoning the idea of data as a finite resource and instead treating it as a living, breathing component of the system.

2. Emergence Over Rules

The old paradigm relied on deterministic logic: If X, then Y. The new order embraces emergent behavior, where AI discovers connections and solutions that are not explicitly programmed. Developers must learn to design for exploration, not just execution. This approach encourages innovation and adaptability, allowing systems to evolve in ways that were previously impossible.

3. Human-Inspired Interfaces

The semantic power of AI allows systems to interact in human-like ways. Applications can now understand intent, adapt to context, and provide insights with nuance. This shifts the focus from building rigid UI flows to creating adaptive, intelligent experiences. By designing systems that prioritize understanding and empathy, developers can create tools that resonate more deeply with users.

4. Integration of Multimodal Data

AI’s ability to process diverse forms of data—text, images, audio, and video—opens up entirely new possibilities for system design. Developers must think beyond single-modality systems and consider how different types of data can work together to provide richer, more meaningful insights.

Challenges in the New Order

While this shift is transformative, it is not without its challenges:

Trust in AI Decisions: With emergent behavior comes unpredictability. Developers and users must trust systems that don’t always explain their logic in traditional terms. Building this trust requires transparency and robust evaluation mechanisms to ensure AI behaves reliably and ethically.
Ethics and Bias: The chaotic nature of unstructured data means that biases within the data can be amplified. Ensuring fairness and transparency becomes a critical part of system design. Developers must proactively address these issues by designing systems that prioritize inclusivity and mitigate bias.
Developer Mindset Shift: Embracing the new order requires a fundamental change in how developers think about problems. The focus moves from defining every rule to designing frameworks where AI can discover the rules on its own. This shift can be challenging but is essential for leveraging AI’s full potential.
Scalability and Resource Management: AI systems often require significant computational resources. Designing systems that balance performance, cost, and scalability will be a key challenge as AI becomes more integral to application development.

The New Order in Action

The impact of this shift is already visible across industries:

Customer Support: Chatbots powered by LLMs can understand and resolve issues using natural language, replacing scripted flows with dynamic conversations. These systems not only enhance efficiency but also provide more personalized and empathetic interactions.
Content Creation: Tools like Jasper and DALL-E allow creators to work with AI as a collaborative partner, generating ideas and assets from vague prompts. This democratizes creativity, enabling people with limited technical skills to produce high-quality content.
Healthcare: AI systems analyze unstructured patient data, from doctor’s notes to imaging, identifying patterns and insights that structured systems would miss. This has the potential to revolutionize diagnostics and personalized medicine.
Education: AI-driven platforms personalize learning experiences, adapting to individual students’ needs and pacing. This approach ensures that education is more inclusive and effective, catering to diverse learning styles and capabilities.

Embracing the New Order

The transition to AI as the new order is not just a technological change; it’s a philosophical one. It challenges us to rethink how we build, interact with, and trust systems. It demands flexibility, creativity, and a willingness to let go of old certainties. But for those who embrace it, the rewards are immense: systems that are not only more powerful but also more human.

This is a moment of transformation. As developers, innovators, and users, we stand at the threshold of a new era. The systems we build today will shape the future—a future where chaos is not the enemy of progress but its greatest ally. And AI, the architect of this new order, will guide us in turning complexity into opportunity and ambiguity into understanding.