Java Reference
In-Depth Information
appendix A
OSGi—the basics
OSG
i is a big subject, and we're not going to attempt to cover all of it in a single
appendix. Instead, we'll be going over the basics of
OSG
i at a high level. We'll also
delve into greater detail into some aspects of
OSG
i that may not be familiar to most
readers, but that are important to understand when writing enterprise
OSG
i appli-
cations. For a more comprehensive introduction to
OSG
i and
OSG
i reference, have
a look at
OSG
i in Action
by Richard Hall, Karl Pauls, Stuart McCulloch, and David
Savage (Manning, 2011).
A.1
Where did OSGi come from, and where is it going?
One of the stories of software engineering has been that of increasing abstraction and
resulting improvements in modularity. The earliest programs were written in assem-
bly 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, little abstraction, and limited scope for
sharing and reusing 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 sub-
routines, allowing code to be grouped into named functions and reused. The abstrac-
tion away from raw machine instructions also meant that code could be recompiled
rather than rewritten for new hardware. Next came libraries, 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 orien-
tation provided finer-grained modularity by grouping data and behavior 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.
339
