Download ebooks file Flow based Programming A New Approach To Application Development 2nd Edition J. Paul Morrison all chapters
Download ebooks file Flow based Programming A New Approach To Application Development 2nd Edition J. Paul Morrison all chapters
https://ebookultra.com/download/introduction-to-computing-and-
programming-in-python-a-multimedia-approach-mark-j-guzdial/
https://ebookultra.com/download/the-compassionate-mind-a-new-approach-
to-life-s-challenges-1st-edition-paul-gilbert/
https://ebookultra.com/download/knowledge-based-development-f-j-
carrillo/
OpenCV Computer Vision Application Programming Cookbook
2nd Edition Robert Laganiere
https://ebookultra.com/download/opencv-computer-vision-application-
programming-cookbook-2nd-edition-robert-laganiere/
https://ebookultra.com/download/evidence-based-teaching-a-practical-
approach-2nd-edition-geoff-petty/
https://ebookultra.com/download/neuromuscular-disease-a-case-based-
approach-1st-edition-john-h-j-wokke/
https://ebookultra.com/download/android-wireless-application-
development-2nd-edition-shane-conder/
https://ebookultra.com/download/a-complexity-approach-to-
sustainability-theory-and-application-1st-edition-angela-espinosa/
Flow based Programming A New Approach To
Application Development 2nd Edition J. Paul Morrison
Digital Instant Download
Author(s): J. Paul Morrison
ISBN(s): 9781451542325, 1451542321
Edition: 2
File Details: PDF, 3.67 MB
Year: 2010
Language: english
Flow-Based Programming,
2ND EDITION
A New Approach To
Application Development
ISBN: 1451542321
EAN-13: 9781451542325
BMS MFS
CICS, CICS/ESA MQSeries
CMS MVS, MVS/ESA
CMS Pipelines PDF
CP/CMS PGF
DB2 PL/I
DFDM REXX
DL/I RPG
GDDM System/370
GPSS VM/XA
IBM VS/COBOL II
IMS, IMS/ESA, IMS TM VTAM
ISPF
Since it has been about 15 years since the publication of the 1994
edition, and the industry is very different from where it was in those
days, it seems timely to produce a new edition, which will try to
capture some of the effects of the drastically changed computing
environment on our thinking about Flow-Based Programming. Of
course, there is much that has not changed, and FBP is still far ahead
of the pack! One major difference, however, is that people all over
the world are discovering its advantages, and in fact there are now a
number of companies that have been explicitly set up to capitalize on
these concepts.
This edition keeps most of the original chapters, but I have dropped
quite a bit of material that I judge to be of little interest to 21st-century
readers. In particular, there will be less emphasis on mainframe
systems and software, as this does not seem to be an area where the
new concepts are taking root. However, as I feel that “number-
crunchers” will be around for quite a while longer, some of that
material will be retained. There has been such an explosion of new
material in the last few years that I hope my readers will forgive me if
a certain patchiness results! Of course, the 1994 edition still remains
available second-hand, and a PDF version of that edition is available
at http://www.jpaulmorrison.com/fbp/book.pdf. As we have moved
into an Internet world since my book was published, there is now a
web site describing the concepts behind FBP at
http://www.jpaulmorrison.com/fbp/, and a wiki with a lot of interesting
comments and feedback at http://www.jpaulmorrison.com/cgi-
bin/wiki.pl.
An article on FBP has been on Wikipedia for several years:
http://en.wikipedia.org/w/index.php?title=Flow-
based_programming&oldid=363964067. The latest version now
reflects the chapter numbers in the current edition of this book.
All references to OOP have been changed to OO, which seems to
have become the current usage.
In the previous edition there was an Appendix describing THREADS,
an early C implementation. I have now expanded it to add high-level
descriptions of two more recent ones, namely a Java implementation
(JavaFBP) (http://www.jpaulmorrison.com/fbp/#JavaFBP) and a C#
implementation (C#FBP)
(http://www.jpaulmorrison.com/fbp/#CsharpFBP), and have reduced
the amount of information on THREADS
(http://www.jpaulmorrison.com/fbp/#THREADS), as this can still be
found on the web site. THREADS is in process of being upgraded to
use Windows “fibres” (Windows spells it “fiber”, but I am going to stay
with the Canadian spelling in what follows), and there are some other
minor changes to take advantage of the Microsoft C++ compiler.
In addition to the above, I am including some information about
DrawFBP (http://www.jpaulmorrison.com/fbp/#DrawFBP), an FBP
diagramming tool written in Java.
There is also an additional chapter attempting to sketch out what I call
the “FBP explosion” that has taken place over the intervening 15
years (starting on page x). It is really impossible to do it justice as the
number of references grows even as I write this, but hopefully this will
give you some flavour of what has been happening! In particular, I
would like to direct your attention to two sections, contributed by
David Johnson and Dr. Ernesto Compatangelo, respectively, at the
end of this chapter, both very thought-provoking – in different ways.
Where web URLs are included in the text, I will be approximately
following the AMA Guidelines, as described in
http://en.wikipedia.org/wiki/Citing_Wikipedia#AMA_style (retrieved
2009-12-06).
Note that, due to the changing nature of information media, this
edition places much more emphasis on electronic resources, rather
than on paper resources as in the first edition. Where I have links in
the text, I will not repeat them in the bibliography. When quoting from
Wikipedia, I will usually remove any hyperlinks. A number of the
quotes in this new edition are taken from blogs, including the FBP
wiki. As this book is intended for Print On Demand, any comments
where this is not the case, or the original authors have changed their
views, can be corrected along the way, so please let me know!
In the 1994 edition I used the term “process” for the basic unit of
concurrency – however, it has been pointed out that this term is
somewhat ambiguous, as it has different usages in different
environments. The term “unit of concurrency” seemed a bit
cumbersome, so I tried Googling “unit of concurrency”, and found the
following synonyms:
process (Erlang) vat (E language)
actor (actor theory) island (Tweak)
agent task (Ada)
transaction resource (Minuet)
thread stage (John Hartmann’s CMS
operator (MIT, Expressor, et al.) Pipelines)
In the above list I have not included education, but of course this is
probably the most important item of all. To get the user started, there
is a need for formal education – this may only take a few days or
weeks, and I hope that this book will get the reader started on
understanding many of the basic concepts. However, education also
includes the practical experience that comes from working with many
different applications, over a number of months or years. In this area
especially, we have found that FBP feels very different from
conventional programming. Unlike most other professions, in
programming we tend to underestimate the value of experience,
which may in fact be due to the nature of the present-day
programming medium. In other professions we do not recommend
giving a new practitioner a pile of books, and then telling him or her
to go out and do brain surgery, build a bridge, mine gold or sail
across the Atlantic. Instead it is expected that there will be a series
of progressive steps from student or apprentice to master.
Application development using FBP feels much more like an
engineering-style discipline: we are mostly assembling structures out
of preexisting components with well-defined specifications, rather
than building things from scratch using basic raw materials. In such a
medium, experience is key: it takes time to learn what components
are available, how they fit together and what trade-offs can be made.
However, unlike bridge-builders, application developers using FBP
can also get simple applications working very fast, so they can have
the satisfaction of seeing quite simple programs do non-trivial things
very early. Education in FBP is a hands-on affair, and it is really a
pleasure seeing people’s reactions when they get something working
without having to write a line of code!
Now that graphics hardware and software have become available at
reasonable cost and performance, we can build powerful graphical
front-ends for our FBP systems. Since FBP is a highly visual
notation, we believe that a graphical front-end is one of the keys to
its wider acceptance. In Chapter 27 (page x), you will see that
graphical front-ends and visual languages have started popping up
like mushrooms in the grass! In 2008 and 2009 we developed a
graphical tool called DrawFBP, written using Java AWT, Java Swing
and the Java 2D API – this tool captures connectivity information, as
well as the spatial positions of the blocks and arrows, so that it can
actually generate a running JavaFBP program. It also supports what
is sometimes called “stepwise decomposition”, allowing the system
to be built up a layer at a time. The majority of the diagrams in this
book were built using this tool.
Now I feel it would be useful to give you a bit of historical
background on FBP: the first implementation of this concept was
built by myself in 1969 and 1970 in Montréal, Québec. Its first
incarnation was called (somewhat tongue-in-cheek) Data-Oriented
Organization Running Multiple Asynchronous Tasks (DOORMAT). I
still think this is a wonderful acronym, but it was felt (probably
correctly!) that it would not command sufficient respect, so we
renamed it the Advanced Modular Processing System (AMPS), and
it was used for a number of customer applications at the IBM
Montréal Data Centre. This technology proved very productive – so
much so that it was taken into a major Canadian bank, where it was
used for all the batch programming of a major on-line system. This
system and the experience gained from it are described in a fair
amount of detail in an article I wrote a few years later for the IBM
Systems Journal (Morrison 1978).
Although the concepts are not well known, they have actually been
in the public domain for many years. The way this happened is as
follows: in late 1970 or early ’71 I approached IBM Canada’s
Intellectual Property department to see if we could take out a patent
on the basic idea. Their recommendation, which I feel was prescient,
was that this concept seemed to them more like a law of nature,
which is not patentable. They did recommend, however, that I write
up a Technical Disclosure Bulletin (TDB), which was duly published
and distributed to patent offices world-wide (Morrison 1971). A TDB
is a sort of inverse patent – while a patent protects the owner but
requires him or her to try to predict all possible variations on a
concept, a TDB puts a concept into the public domain, and thereby
protects the registering body from being restricted or impeded in the
future in any use they may wish to make of the concept. In the case
of a TDB, it places the onus on someone else who might be trying to
patent something based on your concept to prove that their variation
was not obvious to someone “skilled in the art”.
Towards the end of the ’80s, Wayne Stevens and I jointly developed
a new version of this software, called the Data Flow Development
Manager (DFDM). It is described in Appendix A of what I think was
Wayne’s last book (Stevens 1991) (which, by the way, contains a lot
of good material on application design techniques in general). What I
usually refer to in what follows as “processes” were called
“coroutines” in DFDM, after Conway (1963), who described an early
form of this concept in a paper back in the ’60s, and foresaw even
then some of its potential. “Coroutine” is formed from the word
“routine” together with the Latin prefix meaning “with”, as compared
with “subroutine”, which is formed with the prefix meaning “under”.
(Think of “ co operative” vs. “ sub ordinate”).
DFDM was used for a number of projects (between 40 and 50) of
various sizes within IBM Canada. A few years later, Kenji Terao got a
project started within IBM Japan to support us in developing an
improved version for the Japanese market. This version, marketed
under the name “Data Flow Programming Manager” (データ・フロ
ー・プログラミング 管理 ), is, at the time of writing, the only official
IBM FBP product which has been made available in the market-
place, and I believe enormous credit is due to Kenji and all the
dedicated and forward-looking people in IBM Japan who helped to
make this happen. While this version of DFDM was in many ways
more robust or “industrial strength” than the one which we had been
using within IBM Canada, much of the experience which I will be
describing in the following pages is based on what we learned using
the IBM Canada internal version of DFDM (roughly 1983 – 1990), or
on the still earlier AMPS system (1969 – 1976). Perhaps someone
will write a sequel to this book describing the Japanese experience
with DFDM...
After I retired from IBM, I wrote a C implementation, which attempted
to embody many of the best ideas of its ancestors, called THREADS
– THREads-based Application Development System (I love self-
referential names!). Like DFDM, it also has interpreted and compiled
versions, so applications can be developed iteratively, and then
compiled to produce a single EXE file, which eliminates the network
decoding phase. The first version of THREADS used C functions
longjmp and setjmp, plus some hardware-level code, to switch
between a number of separate stacks. However, the code was
somewhat hardware- and operating system-specific, so in 2009 I
started converting THREADS to use the new Windows “fibres”
facility. Although the revised code has survived some of its early
tests, it needs a lot more testing. The latest information can be
found on the FBP web site
(http://www.jpaulmorrison.com/fbp/threads.htm).
A few years later, Java and C# versions were implemented, called
(unimaginatively) JavaFBP and C#FBP. They can both be found on
the author’s FBP web site, and on SourceForge
(https://sourceforge.net/projects/flow-based-pgmg/).
The terminology used in this book is not exactly the same as that
used by AMPS and DFDM, as a number of these terms turned out to
cause confusion. For instance, the data chunks that travel between
the asynchronous processes were called “entities” in those systems,
but, as I said above, this caused confusion for people experienced in
data modelling. They do seem to correspond with the “entities” of
data modelling, but “entities” have other connotations which could be
misleading. “Objects” would present other problems, and we were
not comfortable with the idea of creating totally new words (although
some writers have used them effectively). The “tuples” of Carriero
and Gelernter’s Linda (1989) are very close, but this name also
presents a slightly different image from the FBP concept. We
therefore decided to use the rather neutral term “information packet”
(or “IP” for short) for this concept. This term was coined by Herman
Van Goolen, then with IBM Netherlands, as part of work that we did
after DFDM, in which we tied FBP concepts in with other work
appearing in the literature or being developed in other parts of IBM.
Some of the extensions to the basic AMPS and DFDM substructure
that I will be talking about later were also articulated during this
period. When I need to refer to ideas drawn from this work I will use
the name FPE (for Flow-Based Programming Environment),
although that is not the acronym used for that project. THREADS
and its successor implementations follow this revised terminology,
and include a number of ideas from FPE.
As I stated in the prologue, for most of my 50 years (I can’t believe
it!) in the computer business I have been almost exclusively involved
with business applications. Although business applications are often
more complex than scientific applications, the academic community
generally has not shown much interest in this area up until now. This
is a “catch 22” situation, as business would benefit from the work
done in academia, yet academia (with some noteworthy exceptions)
tends not to regard business programming as an interesting area to
work in. My hope is that FBP can act as a bridge between these two
worlds, and in later chapters I will be attempting to tie FBP to other
related theoretical work which working programmers probably
wouldn’t normally encounter. My reading in the field suggests that
FBP has sound theoretical foundations, and yet it can perform well
enough that you can run a company on it, and it is accessible to
trainee programmers (sometimes more easily than for experienced
ones!). AMPS has now been in production use for over 35 years,
supporting one of the biggest companies in North America.
Business systems have to evolve over time as the market
requirements change, so clearly their system has been able to grow
and adapt over the years as the need arose – this is a living system,
not some outdated curiosity which has become obsolete with the
advance of technology.
And now I would like to conclude this chapter with an unsolicited
testimonial from a DFDM user, which we found particularly satisfying:
“I have a requirement to merge 23 ... reports into one .... As
all reports are of different length and block size this is more
difficult in a conventional PLI environment. It would have
required 1 day of work to write the program and 1 day to test
it. Such a program would use repetitive code. While drinking
coffee 1 morning I wrote a DFDM network to do this. It was
complete before the coffee went cold [my italics]. Due to the
length of time from training to programming it took 1 day to
compile the code. Had it not been for the learning curve it
could have been done in 5 minutes. During testing a small
error was found which took 10 minutes to correct. As 3 off-
the-shelf coroutines [components] were used, PLI was not
required. 2 co-routines were used once, and 1 was used 23
times. Had it not been for DFDM, I would have told the user
that his requirement was not cost justified. It took more time
to write this note than the DFDM network.”
Notice that in his note, Rej (short for Réjean), who, by the way, is a
visually impaired application developer with many years of
experience in business applications, mentioned all the points that
were significant to him as a developer – he zeroed right in on the
amount of reuse he was getting, because functions he could get right
off the shelf were ones he didn’t have to write, test and eventually
maintain! In DFDM, “coroutines” are the basic building blocks, which
programmers can hook together to build applications. They are
either already available (“on the shelf”), or the programmer can write
new ones, in which case he or she will naturally try to reuse them as
often as possible – to get the most bang for the proverbial buck.
Although it is not very hard to write new PL/I components, the
majority of application developers don’t want to write new code –
they just want to get their applications working for the client,
preferably using as little programming effort as will suffice to get a
quality job done. Of course there are always programmers who love
the process of programming and, as we shall see in the following
pages, there is an important role for them also in this new world
which is evolving.
Rej’s note was especially satisfying to us because he uses special
equipment which converts whatever is on his screen into spoken
words. Since FBP has always seemed to me a highly visual
technique, I had worried about whether visually impaired
programmers would have any trouble using it, and it was very
reassuring to find that Rej was able to make such productive use of
this technology. In later discussions with him, he has stressed the
need to keep application structures simple. In FBP, you can use
hierarchic decomposition to create multiple layers, each containing a
simple structure, rather than being required to create a single, flat,
highly complex structure. In fact, structures which are so complex
that he would have trouble with them are difficult for everyone.
Another Random Scribd Document
with Unrelated Content
CHAPTER VI
WHY DID HE DO IT?
Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.
ebookultra.com