Introducing Torpedo: A Golang Framework Born Out of Frustration with Messy Codebases

As a developer, I've spent countless hours wrestling with tangled codebases, trying to untangle business logic from the clutter of external dependencies like databases, APIs, and frontends. The deeper I went into complex projects, the more I realized how hard it was to keep things organized and maintainable over time. That’s when I started exploring architectural patterns that could help me build applications with a cleaner, more sustainable structure.

After discovering Hexagonal Architecture (aka Ports and Adapters), everything clicked. This architecture allowed me to separate my core business logic from the outside world, making my projects far more modular, testable, and adaptable. But even with this newfound clarity, implementing the architecture in Golang wasn’t as straightforward as I had hoped. I wanted a framework that embraced this pattern from the ground up—something that would not only speed up my development process but also ensure I was sticking to the principles of clean architecture without reinventing the wheel every time.

That’s how Torpedo was born.

Torpedo is a Golang framework designed to take the headaches out of building well-structured applications. It streamlines the implementation of Hexagonal Architecture, making it easier to write clean, decoupled code that scales. In this post, I’ll share my journey of building Torpedo, explain its core features, and show how it can help you ship faster without sacrificing code quality.

One of the standout features of Torpedo is its ability to generate entity code and CRUD operations from a simple YAML file. This file allows developers to define their domain entities in a clear, concise manner, specifying attributes and relationships without getting bogged down in boilerplate code. Once the entity schema is defined, Torpedo takes over, automatically generating the corresponding Go structs, repositories, and CRUD operations (Create, Read, Update, Delete) for each entity. This eliminates the need to manually write repetitive code, speeds up development, and ensures that the generated code is aligned with the Hexagonal Architecture principles—keeping your business logic clean and independent from infrastructure concerns.

Torpedo also simplifies the creation of application logic by automatically generating use case code based on a YAML definition file. In this file, developers can define the core actions or workflows that represent their application's business logic, such as processing payments, managing user accounts, or handling orders. Once the YAML file is set up, Torpedo generates the complete use case layer, including input and output handling, request validation, and interaction with repositories or external services. By automating the generation of this essential code, Torpedo helps developers stay focused on the unique business rules of their application, while ensuring that their use cases are neatly structured and adhere to the principles of Hexagonal Architecture.

In Torpedo, the relationship between entities and use cases is foundational to maintaining a clean separation of concerns, as per the Hexagonal Architecture. Entities represent the core business objects, encapsulating business rules and attributes, while use cases define how these entities are interacted with and manipulated based on specific workflows or actions. This clear division ensures that business logic remains isolated and independent from external systems, which makes the codebase more adaptable to change. The use case layer interacts with entities to enforce business rules, while repositories (or adapters) handle data persistence without violating the entity's internal logic.

Here’s a diagram to illustrate the flow between entities and use cases within Torpedo's Hexagonal Architecture:

This approach not only keeps the code modular and scalable but also allows for easier testing by decoupling external dependencies from core business logic.

We’re just getting started with Torpedo, and there’s so much more to come! This framework was built with the aim of making Golang development faster, cleaner, and more aligned with modern architectural principles. Whether you're working on a new project or refactoring an existing one, Torpedo can help you streamline your workflow, reduce boilerplate, and keep your business logic decoupled from external concerns.

We invite you to give it a try, explore its features, and see how it fits into your development process. We’d love to hear your feedback—your insights will help shape the future of Torpedo as we continue to evolve and add more features to make it even better. Stay tuned more is coming soon, let’s build something great together!

The above is the detailed content of Introducing Torpedo: A Golang Framework Born Out of Frustration with Messy Codebases. For more information, please follow other related articles on the PHP Chinese website!