One of the stories of software engineering has been that of increasing abstraction
and resulting improvements in modularity. The earliest programs were written in
assembly language, which mapped directly to the instruction set of the machine
executing the program, or coded directly as machine instructions. There was no
higher level structure above the individual machine codes, very little abstraction,
and limited scope for sharing and re-using programs. Because there was so little
abstraction between the code and the hardware it ran on even slight hardware
changes could mean that the application had to be extensively rewritten. Higher
level languages introduced subroutines, allowing code to be grouped into named
functions and re-used. The abstraction away from raw machine instructions also
meant that code could be re-compiled rather than re-written for new hardware.
Next came libraries, very large groupings of code with a separate interface and
implementation. This abstraction allowed different pieces of code to be changed
independently from one another without rebuilding entire applications, these
libraries are therefore modular code. Finally, object orientation provided
finer-grained modularity by grouping data and behaviour together into
encapsulated objects. This abstraction substantially improved the level to which
changes in a program could be isolated from the rest of the program, and the level
to which code could be reused, marking a dramatic improvement in modularity.
One of the reasons modularity has become increasingly necessary is the scale of
modern computer programs. They are developed by globally dispersed teams and
can occupy several gigabytes of disk space. In this kind of environment, it is
critical that code can be grouped into distinct modules, with clearly delineated
areas of responsibility and well-defined interfaces between modules.
Another striking change to software engineering within the last decade is the
emergence of open source. Almost every software need can now be satisfied with
open source applications. There are open source application servers, IDEs,
databases, and messaging engines. There is also a bewildering range of open
source projects which address particular development needs from Java bytecode
generation to web presentation layers. Because the projects are open source, they
can easily be re-used by other software. As a result most programs now rely on
some open source libraries. Even commercial software often uses open source
componentry; numerous GUI applications, for example, are based on the Eclipse
Rich Client Platform, and many application servers incorporate the Apache Web
Server.
1.1 Why the world needs modularity
