{"id":3321,"date":"2023-08-15T18:26:25","date_gmt":"2023-08-15T22:26:25","guid":{"rendered":"https:\/\/blog.wholetomato.com\/?p=3321"},"modified":"2026-06-07T12:37:39","modified_gmt":"2026-06-07T16:37:39","slug":"summer-codefest-what-the-hex-ports-and-adapters-architecture-with-c-recap","status":"publish","type":"post","link":"https:\/\/www.wholetomato.com\/blog\/summer-codefest-what-the-hex-ports-and-adapters-architecture-with-c-recap\/","title":{"rendered":"Summer CodeFest: What the Hex? Ports and Adapters Architecture with C++ [Recap]"},"content":{"rendered":"

TL;DR\u00a0<\/b><\/p>\n

As applications grow in size, poor design decisions can lead to increasing complexity, maintenance problems and bottlenecks in testing. In this Summer CodeFest session, we will learn how Hexagonal (Ports and Adapters) Architecture can help developers to build more scalable, maintainable and testable C++ applications by separating the business logic from the implementation details. Attendees will learn through practical examples how this architectural approach provides greater flexibility, makes future expansion easier, and reduces the long term cost of software development.<\/span><\/p>\n

This session has concluded watch the replay<\/a> or download the slides below.<\/strong><\/p>\n

Common pitfalls when scaling applications<\/span><\/h2>\n

When scaling applications, two common pitfalls often arise: spaghetti code and a lack of proper testing. This can occur for various reasons, but one of the most common reasons is the lack of a coding style guide or an overarching design structure.<\/span><\/p>\n

For instance, when starting a project, it\u2019s fairly simple. An input and one or two outputs. However, as the project grows or the requirements expand, programmers can resort to an experimental approach each time a new component is added. They can also resort to using manual testing\u2014which works for simple unit tests<\/a> for small projects but overtime becomes too cumbersome.\u00a0<\/span><\/p>\n

The lack of a design structure makes projects prone to gradually growing complexity. As a result, the experimental app ends up in production as an inefficient system that demands continuous maintenance. To avoid breaking essential business logic and harming the overall business, developers allocate unnecessary development time to making one-off solutions.\u00a0 The time and effort is compounded due the previous iteration\u2019s shortcomings.<\/span><\/p>\n

\"\"<\/a>

Using hex architecture can help address scaling issues.<\/p><\/div>\n

Hex structure vs traditional three-layer architecture<\/span><\/h2>\n

There is nothing wrong with the traditional 3-layered structure composed of the presentation tier, the application tier, and the data tier. And for most applications this will usually be enough. However, theoretically, as you add more business logic and more functions, the complexity ramps up exponentially. In that case, a traditional approach may no longer be the most efficient. You can always scale and automate by expending more resources, or you can take a step back and reorganize your resources.<\/span><\/p>\n

A hex structure, contrary to what the name suggests, is not a 6-tiered structure. Instead, it\u2019s an analogy for the freedom of a developer to add ports and adapters\u2014sort of like a honeycomb structure where you can keep adding more hexagons and there would still be no gaps. In the traditional approach, the presentation, business, and data side flow directly to each other; in hexagonal architecture, you add interfaces (or buffers) in between fully functioning components making them semi-autonomous. You would only have to think about how what data passes from one to another and how communication is processed.<\/span><\/p>\n

\"\"<\/a><\/p>\n

Fortifying your app with hexagonal architecture<\/span><\/h2>\n

The Hexagonal architecture provides a solution to this problem by utilizing dependency inversion control, which separates business logic from implementation details like databases and REST clients. It also fosters a clear separation of concerns between components, ensuring a more organized and manageable application as it grows.<\/span><\/p>\n

Ports and Adapters<\/b><\/p>\n

As the name suggests, hexagonal architecture utilizes standalone components with a functional core in the middle of the design structure. This means that expansion, maintenance, and designing is easier because the program\u2019s components and roles are clearly defined. Buffers between these components allow easy addition and removal as well as facilitate efficient communication among the program\u2019s functions.\u00a0<\/span><\/p>\n

So how do you initiate a program with a hexagonal design structure? Watch our short presentation hosted by Nuno Castro to get a brief introduction and some great examples. <\/span>This session has concluded. Browse the presentation slides and replay below.<\/b><\/p>\n

Presentation Slide Deck<\/h2>\n