Game Development Reference
development team. The source code to other frameworks is typically unavailable
to developers who are not explicitly involved in its development, which generally
leads to a number of integration issues between frameworks.
In this chapter, I will address the reasons behind the friction existing between multiple
frameworks, and I offer some pragmatic approaches to building a cohesive design,
even when you do not have access to the source code of other frameworks employed in
your application. Throughout this chapter, I will refer to communication problems
between frameworks in different problem domains as compositional friction .
There are numerous reasons why compositional friction can exist between two or
more frameworks, and even on a solitary level between classes in a single framework.
Although friction can exist between classes in a single framework, these issues can
be solved through an iterative refactoring process with the availability of source
code. This chapter is directed at eliminating friction between multiple frameworks,
where one framework typically only has access to external frameworks through
their public interfaces, and these interfaces cannot be modified or refactored.
Many software development issues can cause compositional friction, but a few of
the most notable ones include domain coverage, design intentions, framework
gap, entity overlap, and source code access.
Cause: Domain Coverage
The general purpose of a framework is to provide an abstract design for applica-
tions in a particular problem domain. It is important to realize that the framework
does not need to cover the entire problem domain, but rather only a subset of rel-
evant entities in the given problem domain. The amount of domain coverage to
target with a framework is fairly subjective, though, because problem domains are
not generally defined in extensive detail. Determining how much coverage to
employ is up to the solution architect, and iterative refactoring helps to improve
When composing two frameworks, there are three levels of domain overlap that
can occur, each with different implications and solutions. If no overlap occurs,
there is no risk of integration issues when composing overlapping entities, but
there may be a gap between frameworks that must be managed. If there is a rela-
tively small amount of domain overlap between frameworks, the best solution is
to evolve a few classes in both frameworks to communicate with each other with