My journey
Throughout my IT career, a relentless pursuit of software quality has been my guiding principle. Early in my career design patterns, those reusable solutions to common programming challenges, became my initial toolkit for building robust and well-structured code.
As my skills matured, I expanded my focus to architectural patterns – the bigger picture of software design.
This shift allowed me to consider the overall structure and organization of an application, ensuring its scalability and maintainability.
Throughout my journey, code reviews played a crucial role in sharpening my skills.
These collaborative sessions offered insights into diverse approaches, best practices, and sometimes, not-so-great practices. It was a constant feedback loop, improving my own coding abilities.
This naturally led me to pay it forward. When I write code, I strive to share the knowledge I’ve gained. Clean, well-designed code became not just a personal preference, but a commitment to quality. And code review became the channel to spread it through the collaborators.
For a while, I felt alone in my meticulous approach. But then I discovered the software craftsmanship. A whole community dedicated to the same principles I held dear: a focus on quality, continuous learning, and a deep respect for the craft of coding.
Software craftsmanship isn’t just about writing clean code; it’s about a mindset. It’s about taking pride in your work, constantly seeking improvement, and sharing your knowledge to elevate the entire profession. It’s about being not just a coder, but a true craftsman.
My favorite toy 🧸
While going deeper into software craftsmanship concepts is a worthy pursuit, I prefer to share my favorite tool within my arsenal: the hexagonal architecture.
A good way to visualize this architecture is to imagine a hexagon. Inside it sits your application’s core, focused purely on business logic. Outside the hexagon are all the external things your app interacts with, like databases, other services and UIs. The core doesn’t talk directly to these. Instead, it communicates through defined ports, like an interface contract. Specific adapters implement these ports, handling the details of talking to the specific technology. This keeps the core clean and adaptable, as you can swap out adapters for different technologies without changing the core itself.
The beauty of the hexagonal architecture lies in its simplicity. It promotes a clear separation of concerns within the codebase, reflected in a well-organized folder structure. This immediately creates an environment of readability and maintainability.
Furthermore, by isolating the core domain logic from external dependencies (represented by ports and adapters), the hexagonal architecture naturally introduces key concepts of Domain-Driven Design (DDD). This focus on the domain encourages collaboration – forcing product owners, analysts, and developers to have a shared understanding of the core business functionalities. This establishes a unified language, fostering smoother collaboration across teams.
The defined ports and adapters also serve as excellent entry points for writing clean and testable code. Coupled with dependency injection (a highly recommended practice), hexagonal architecture makes testing effortless.
Finally, the modular nature of adapters empowers you to adapt to future changes. Technological advancements or evolving business needs won’t be postponed by legacy code. Legacy code, in this context, doesn’t mean bad choices, but rather decisions made within that specific previous context. The hexagonal architecture allows you to gracefully evolve the application without being shackled by the past since the core of the application will not be impacted by new implementations of a port.
Fun fact: Even before discovering this formal pattern, I found myself instinctively trying to achieve a similar separation. I’d naturally isolate my domain logic from input concerns like API validation and output concerns like database access. While my homebrew approach wasn’t as elegant as the official hexagonal architecture, it demonstrates the power of prioritizing quality. Having the right tools is important in this changing world.
Sharing our craft for the apprentices
The world of software craftsmanship extends far beyond just writing clean code. It’s about fostering a vibrant community, a modern-day guild where experienced developers take on the role of mentors, passing their knowledge on to the next generation. Throughout my career, I’ve amassed a wealth of experience that not only benefits our clients but also holds immense value for my fellow developers.
In today’s customer-centric world, it’s easy to solely focus on the end product. However, I believe creating software that we can all be proud of, offers a significant short-term benefit for developers themselves. When we prioritize craftsmanship, we elevate the overall quality of the codebase, making it more maintainable, readable, and ultimately more enjoyable to work with. This translates directly into increased developer motivation and happiness – a win for both the individual and the long-term success of the product.
Sharing knowledge and fostering a culture of craftsmanship is what truly excites me. In my next post, I’ll delve into the various collaborative sessions I’ve found effective. If you’re interested in learning how to spread knowledge within your team, stay tuned!
Author: Simon OLBREGTS, Software Craftsmanship Practice Leader at AKABI
