In software development, distinguishing between domain logic and side effects is essential for maintaining clarity, consistency, and composability within a system. When these elements become intertwined, accidental complexity increases, making systems harder to understand, test, and maintain.

This session will explore how to elevate domain models into well-defined Domain-Specific Languages (DSLs) using the tagless-final approach. The tagless-final technique enables the construction of type-safe DSLs, where the safety and correctness of the language are guaranteed by the host language’s type system. By treating domains as languages, this approach creates clearer boundaries between domain logic and side effects, empowering teams to communicate more effectively, align implementation with business intent, and reduce accidental complexity.

The session will cover:

• Introduction to Tagless-Final: Understanding its fundamentals and its role in functional programming.
• Building DSLs for DDD: Designing DSLs that encapsulate domain logic while isolating side effects.
• Constructing Domains as Languages: Exploring how domain languages help achieve clarity and precision in system design.
• Algebraic Construction of Domain Languages: Techniques for creating domain languages that are expressive, consistent, and composable.
• Controlling Complexity: Strategies to manage and minimize accidental complexity, keeping the domain clean and understandable.
• Real-World Examples: Case studies showing the benefits of applying tagless-final in Domain-Driven Design (DDD).
• Integration into DDD: Seamlessly integrating tagless-final DSLs into broader DDD architectures for consistent and reusable domain models.

By the end of this session, attendees will gain practical insights into leveraging the tagless-final approach to construct domains as languages, tackle accidental complexity, and create domain models that are consistent, expressive, and easier to maintain over time.

Target Audience: This session is aimed at Software Architects and Backend Developers who work with Domain-Driven Design (DDD) and are looking to improve the clarity and maintainability of their systems by using functional programming techniques. Functional Programmers and Tech Leads will also benefit from understanding how tagless-final can be applied to domain modeling to create more expressive and maintainable DSLs.