Tuesday 26th June, 2012
11:15am to 12:00pm
The principles of modularity have been applied to engineering projects since Gorak built the wheel, and Thag the barrow of the world's first wheelbarrow. Thag's barrow didn't care that the wheel was first hewn from rock, and later upgraded to a lighter, wooden one, and the same wheel design was reused for the world's first chariot.
Analogous principles of modularity are taught in Software Engineering 101 - information hiding, interfaces, clear responsibility, high internal cohesion, low external coupling, etc., and we apply these routinely as we develop, and continuously refactor the code encapsulated within classes.
However when the number of classes reaches some threshold, higher level abstractions are needed in order to manage the complexity of the growing codebase. This limit is usually overshot and the team is soon drowning in an ocean of classes. At this point it is time to restructure the code-base into a hierarchy of modules above the class level, or watch the team's frustration continue to rise, and productivity plummet.
This talk will introduce strategies for improving the modularity in an existing codebase, with minimum impact on the code itself. The importance of "levelization" as a first step in this process will be explained, as well as the benefits of top-down vs. bottom-up approaches. Examples will be presented. This material is based on experience in helping many development teams through the restructuring process.
Sign in to add slides, notes or videos to this session