The document discusses various code smells related to abstraction, encapsulation, and modularization in software design. It identifies specific issues such as missing or unnecessary abstractions, insufficient encapsulation, and problematic inheritance hierarchies that can complicate the design and implementation of software systems. The authors are Girish Suryanarayana, Ganesh Samarthyam, and Tushar Sharma, and the document was published by Morgan Kaufmann in October 2014.

1. Abstraction
MissingAbstraction
This smell arises when clumps of data or
encoded strings are used instead of creating
a class or an interface.
ImperativeAbstraction
This smell arises when an operation is
turned into a class.
IncompleteAbstraction
This smell arises when a type does not
support a responsibility completely.
MultifacetedAbstraction
This smell arises when an abstraction has
more than one responsibility assigned to it.
UnnecessaryAbstraction
This smell occurs when an abstraction which
is actually not needed (and thus could have
been avoided) gets introduced in a software
design.
UnutilizedAbstraction
This smell arises when an abstraction is left
unused.
DuplicateAbstraction
This smell arises when two or more
abstractions have identical names or
identical implementation or both.
Encapsulation
DeficientEncapsulation
This smell occurs when the declared
accessibility of one or more members of an
abstraction is more permissive than actually
required.
LeakyEncapsulation
This smell arises when an abstraction “exposes”
or “leaks” implementation details through its
public interface.
MissingEncapsulation
This smell occurs when the encapsulation of
implementation variations in a type or hierarchy
is missing.
UnexploitedEncapsulation
This smell arises when client code uses explicit
type checks instead of exploiting the variation in
types already encapsulated within a hierarchy.
Modularization
Hierarchy
MissingHierarchy DeepHierarchy
Modularization
BrokenModularization
This smell arises when members of an
abstraction are broken and spread across
multiple abstractions.
InsufficientModularization
This smell arises when an abstraction exists that
has not been completely decomposed and a
further decomposition could reduce its size,
implementation complexity, or both.
Cyclically-dependent
Modularization
This smell arises when two or more abstractions
depend on each other directly or indirectly.
Hub-likeModularization
This smell arises when a class-level abstraction
has dependencies with large number of other
class-level abstractions.
MissingHierarchy
This smell arises when a code segment uses
conditional logic to explicitly manage variation
in behavior where a hierarchy could have been
created and used to encapsulate those
variations.
UnnecessaryHierarchy
This smell arises when the whole inheritance
hierarchy is unnecessary, indicating that
inheritanceis inappropriate for that context.
UnfactoredHierarchy
This smell arises when the types in a hierarchy
share unnecessary duplication in the hierarchy.
WideHierarchy
This smell arises when an inheritance hierarchy
is “too” wide and shallow indicating that
intermediate abstractions may be missing.
SpeculativeHierarchy
This smell arises when one or more types in a
hierarchy are provided speculatively.
DeepHierarchy
This smell arises when an inheritance hierarchy
is "excessively" deep.
RebelliousHierarchy
This smell arises when a subtype rejects or
invalidates the methods provided by its
supertype(s).
BrokenHierarchy
This smell arises when a supertype and its
subtype conceptually do not share an “IS-A”
relationship resulting in broken substitutability.
MultipathHierarchy
This smell arises when a subtype directly and
indirectly inherits from one or more supertypes
leading to unnecessary inheritance paths in the
hierarchy.
CyclicHierarchy
This smell arises when a supertype in a
hierarchyrefers to any of its subtypes.
Authors:Girish Suryanarayana, Ganesh
Samarthyam,Tushar Sharma
Publisher:Morgan Kaufmann
Publicationdate: Oct 2014