| Manufacturing The Software
Applications |
| |
| Software’s
greatest irony is that after taming the complexity of
every other discipline of the engineering (e.g. CAD
or chip design), goods and services, software researchers
has still not been able create rational model to control
or manage the complexity of the software projects. |
| |
OK!
Software is unique and faces a unique set of complex
problems. It should not be an excuse. The software,
on the other hand, can be made highly intelligent and
flexible, unlike the physical objects, like light bulb
or automobile engine. How can we compare a software
component (i.e. an intelligent code module) with piece
of dumb metal (e. g. engine)? We must be ashamed of
it?L |
| |
|
| |
Examples
from the physical world often are invoked to explain
software systems—in some systems; for example,
standard software interfaces for network communications
are called "sockets." The analogies are insidious,
however, because the realm of software is nothing like
the realm of physical objects. The idea of manufacturing
only one kind of light bulb, which would be reconfigured
automatically at the point of use to fit into any desired
socket at any voltage, is absurd. But for software components,
the idea is not only feasible—it could be the
necessary enabling technology for the complex systems
software needed for new, advanced information technology
applications. |
| |
In
other words, ATP is saying that, you need to build a
configurable component that can be used in any car one
can make at that time. That is, you should have a universal
engine that fits, Camry, Civic, BMW, Porch, Cadillac
and Taurus. Of course, it is physically impossible and
absurd.K |
| |
OK!
Lets see, how to overcome this problem? How to setup
an automobile assembly line, in software? We need to
build a Software module, a factory that takes the parts
and assembles them to build the automobile. For Example: |
| |
Autofactory.addAutoBody
(Component
AutoBody);
Autofactory.addEngine(Component
Engine);
// Assemble selected
Transmission
If (Request.TransmissionOption
== Auto)
Autofactory.addTransmission
(Component
AutoTransmission);
Else Autofactory.addTransmission
(Component
ManualTransmission);
// Assemble the
selected entertainment system
If (Request.EntertainmentOption == CD_Player_Option)
Autofactory.addEntertainmentSystem
(Component
CD_Player);
Else If (Request.EntertainmentOption ==
Stereo_ CassetPlayer)
Autofactory.addEntertainmentSystem(Component
CassetPlayer); |
|
| |
You
get the picture. You supply the appropriate parts and
the factory assembles them to build the Automobile for
the customer. If you are manufacturer of the components,
such as, the Stereo Player or CD-Player, You may use
the same process to set up the assembly line that assembles
its subcomponents. This process to setup a factory works
well for any product. |
| |
We
know this process works very well for manufacturing.
Toyota setup a factory to make Camry and Honda setup
a factory to make Accord. But, most experts argue that
it doesn’t work for software, because it is so
unique. Why is it so unique? The problem is not the
software’s uniqueness, but we are unable to leverage
the intelligence, we can program into the software modules,
which can easily be far more intelligent and flexible
compare to a piece of metal (e.g. engine) possible can
offer. Therefore, the intelligence, which we can include
in the software-modules, must overcome the complexity
and uniqueness. |
| |
We
all know standardized or predefined plug-in interfaces
for the parts revolutionized the product manufacturing.
It is not substantiated here, but has discussed in other
places and of course experts many software researchers
agree that: If we can invent loosely coupled systems
(i.e. systems assembled using plug-in parts), we can
eliminate 80% of integration complexity and also reduces
the cost of the parts by allowing specialists (having
skills in the relevant domain) to independently design
and refine manufacturing of each plug-in part. |
| |
There
are two main obstacles we must cross: (1) the applications
dosn’t have such plug-in parts today. In other
words, we must invent plug-in software components. (Review,
Loosely Coupled
components, and plug-n-play components) (2). Two
Camry could
have exactly same engines. That is, all the engines
are identical twins and it is very hard to make out
any difference. But, in the software, every component
is unique, for example, a portfolio chart in user e-trade
account. The chart changes from user to user and minute
to minute (e.g. company stocks are sold/bought or
stock values fluctuate). |
| |
The
software is unique. It needs to create highly
custom application
for each user. This is akin to building a universal
automobile manufacturing plant, which builds any car
you want (e.g. Camry, BMW or Accord). That means, you
should have a universal engine that fits, Camry, Civic,
BMW, Porch, Cadillac and Taurus. Of course, it is physically
impossible. However, it is possible for the software
overcome these problems, by employing a simple
indirection. |
| |
We
could do this by employing two intelligent software
modules and partitioning the responsibilities between
them. We could have a “Component Factory”
(or “CF”) that can dynamically build custom
“Application Component” (or “AC”)
on the fly (i.e. in real-time) using up to the minute
information based on user account number. The same CF
creates a different AC after few minutes even for the
same user, if stock values fluctuate. (Please review Examples
for Component Factory or This-CF) |
| |
Now,
you setup the software-manufacturing factory, which
uses the CF (the indirection) instead of using the parts
directly. We make the CF intelligent enough to custom
manufacture appropriate component for the Product/System.
Likewise, the CF for the component may use one or more
other CFs to build subcomponents. The following figure
shows the manufacturing supply chain.J |
| |
|
| |
Site Map
//
CF custom builds
the plug-n-play
AC using data in Request (at real-time)
Autofactory.addAutoBody (ComponentFactory
AutoBody (Request)
);
Autofactory.addEngine(ComponentFactory
Engine(Request));
If (Request.TransmissionOption == Auto)
Autofactory.addTransmission(ComponentFactory
AutoTransmission (Request));
Else Autofactory.addTransmission(ComponentFactory
Manual Transmission (Request));
If (Request.EntertainmentSystemOption == CD_Player_Option)
Autofactory.addEntertainmentSystem(ComponentFactory
CD_Player(Request));
Else If (Request.EntertainmentSystemOption
== Stereo_ CassetPlayer)
Autofactory.addEntertainmentSystem(ComponentFactory
CassetPlayer(Request));
|
|
| |
To
build a custom online-application, we are setting up
a supply chain for the manufacturing of each custom web
page (or an application screen). In this supply chain, each CF builds appropriate
component (or plug-in AC) for the custom application,
based on each user's profile and preferences. The
real innovations are: Loosely coupled AC (which
doesn’t exist today, in Object
Oriented Paradigm) and the “CF-indirection”
to custom build the
plug-n-play AC
at real-time. |
