Software ICs

“Complexity must be grown from simple systems that already work.” —Kevin Kelly

Message Synchronization

One of the goals of any software design is to produce
software which behaves predictably and reproducibly under a given
stimulus. Many object-oriented and message-oriented design
paradigms suffer because they introduce a degree of
unpredictability and randomness into a software product. If a
message is exchanged with a mailbox scheme and the sender and the
receiver are never brought into synchronization it will be
exceedingly difficult to replicate or predict all possible states
that two process system can be in. Much depends on the environment
and timing considerations in which these two processes find
themselves. These modules may work fine in one environment and
suffer sporadic failures in another. This leads to increased
testing and maintenance costs and a poorer software product. Often
the blame is incorrectly directed at the multiprocess design
paradigm. How often have we heard it said that client/server
software design does not handle complexity well. The original
designers of Send/Receive/Reply synchronized messaging believed
that the answer lies in forcing a state-machine-like
synchronization to occur on each message pass.

It works like this: a sending process composes a message and
arranges to send it to a receiving process. While waiting for a
reply the sending process is blocked. The receiving process, on the
other hand, is held blocked until a message arrives destined for
it. It unblocks, reads the message, processes its contents and then
replies to the sender. This reply then unblocks the sender and the
two processes are free to operate independently once again.

Many have argued that this blocking/forced synchronization
introduces unnecessary complexity into a message exchange, but when
properly applied it achieves exactly the opposite effect. By
forcing synchronization to occur at each message pass, one finds
that our multi-process applications now start to behave in a very
predictable and reproducible manner. Gone are the timing and
environmental effects that often plague nonsynchronized message
passing schemes. When dealing with huge complex applications, this
represents a huge strategic advantage. As an added bonus, since the
sender is blocked during message transmission and is explicitly
unblocked by the receiver process with the reply, it is very simple
to arrange to transport these messages over a variety of media
(including some which are “slow”). The messages could be
exchanged via shared memory if the processes were on the same
processor, or they could be exchanged via the Internet if the
processes were physically separated or on a serial line in a dial
up situation. While the performance of the collective of processes
would obviously be affected by the message transmission speed, the
predictability and reproducibility of that performance would not
be.

The importance of predictability of software cannot be
overstated when it comes to software testing. Nothing makes
software QA people wish for a career change more than an
application which exhibits unpredictable and unreproducible
behavior.

SIMPL Open-Source Project

To help promote this software IC paradigm in the Linux
community we started the SIMPL open-source project
(www.holoweb.net/~simpl).
SIMPL enabled processes are Linux processes with all the features
and protections that affords. SIMPL enabled processes are able to
exchange tokenized binary messages using a blocking
Send/Receive/Reply messaging scheme. In short SIMPL processes have
the makings of some great software ICs.

Before going into more detail on how these software ICs might
be built, it is worth emphasizing the advantages of this
model.

In principle, SIMPL processes can be written in any
language. While much of the code on the SIMPL web site is still
written in C, there is no reason why a C++ or JAVA SIMPL process
could not be created and talk transparently to another SIMPL
process written in Tcl/Tk or Python.

The language used to write the software IC itself
in no way dictates the language of another software IC with which
interaction takes place. Furthermore, a given SIMPL process has no
way of discovering what language was used to construct another IC
with which it is exchanging a message.

A SIMPL software IC has no way of discovering or
knowing the physical location of its exchange partner. This means
that the same binary image can be tested with local message
exchanges and then deployed with remote message exchanges. Overall
collective application performance would differ but the individual
software IC would not need to change in any way. In may instances
even a recompile is unnecessary.

A SIMPL software IC has no way of discovering the
internal algorithm of an exchange partner. This means that test
stubs can be created which completely simulate and replicate the
environment in which a given software IC finds itself. In
particular, error conditions which would be costly or difficult to
reproduce in the full system can readily be simulated in a test
environment. These SIMPL software ICs can be rigorously tested
before being deployed in the real-world application.

SIMPL software ICs lend themselves well to projects
with multiple developers. The implementation details of a SIMPL
enabled process cannot affect any interacting process, provided
that implementation conforms to the agreed upon message API. While
a poor IC implementation will certainly adversely affect the
overall application performance, the application will still
operate. Once a poor algorithm has been identified it can be worked
on in isolation from the real application and substituted once
tested without even recompiling the adjacent ICs.

Trending Topics

Upcoming Webinar

Getting Started with DevOps - Including New Data on IT Performance from Puppet Labs 2015 State of DevOps Report

August 27, 2015
12:00 PM CDT

DevOps represents a profound change from the way most IT departments have traditionally worked: from siloed teams and high-anxiety releases to everyone collaborating on uneventful and more frequent releases of higher-quality code. It doesn't matter how large or small an organization is, or even whether it's historically slow moving or risk averse — there are ways to adopt DevOps sanely, and get measurable results in just weeks.