One very big reason for runtime binding is licensing. If an application
includes subroutines from another vendor and they are hard linked, users
of the software may be required to purchase the subroutine package. It
gets even more complicated when open source software is used. The GNU
GPL makes the new product a derivative product, covered by the same
license and requiring it to become open source (if it is distributed
outside the developing company). 

Dennis Roach
GHG Corporation
Lockheed Martin Mission Services
Facilities Design and Operations Contract
NASA/JSC
Address:
   2100 Space Park Drive 
   LM-15-4BH
   Houston, Texas 77058
Mail:
   P.O. Box 58487
   Mail Code H4C
   Houston, Texas 77258
Phone:
   Voice:  (281)336-5027
   Cell:   (713)591-1059
   Fax:    (281)336-5410
E-Mail:  dennis.ro...@lmco.com

All opinions expressed by me are mine and may not agree with my employer
or any person, company, or thing, living or dead, on or near this or any
other planet, moon, asteroid, or other spatial object, natural or
manufactured, since the beginning of time.


-----Original Message-----
From: IBM Mainframe Discussion List [mailto:ibm-m...@bama.ua.edu] On
Behalf Of john gilmore
Sent: Tuesday, July 14, 2009 5:03 PM
To: IBM-MAIN@bama.ua.edu
Subject: Re: complexity

I have propagated this thread name, but it is a dubious one:
computational complexity is the standard name for an important
computer-science topic that has nothing much to do with the content of
this thread.
 
Still, what Chris Craddock had to say about what I shall call binding
times was of great interest.
 
Decisions about the resolution of from where and/or when an external
entry is to be invoked or a table is to be loaded may be taken at
different times. These actions may, that is, be bound
 
o at programming time,
 
o at compile time,
 
o at linkage time, or, finally,
 
o at execution time.
 
In PL/I, but not in C or its sequelae, one can use generic function
references like
 
x = sqrt(y) ;
 
delegating to a compiler the responsibility to choose an appropriate
entry, one consonant with the data types of x and y.  However this is
managed, execution-time binding of a sqrt routine is something to be
avoided. 
 
Or again, one can write a division-method hashing routine that always
uses the divisor/modulus m=29 (a convenient small prime), or instead one
can make m an execution-time formal parameter of the hashing routine.
(The option of making the decision which of a set of hashing routines,
one each for m=2,3,5,7,11,13,..., an execution-time one is
unattractive.)   
 
In recent years late binding times have come to be more and more heavily
used.  Sometimes this is appropriate because the maintenance/replacement
cycles of invoker and invoked are very different.  A CICS application
that uses DB2 may not, for example, wish to commit itself at linkage
time to the use of a particular version and modification level of DB2;
and the dynamic invocation of a DB2 interface routine by alias provides
one mechanism for avoiding the need to do so.
 
Interestingly, however, the original IBM OS/360 linkage editor accepted
load mules it had created on one occasion as inputs for modification on
another; and the z/OS binder still does so.  For reasons that I have
never understood--There is no neurosurgery involved--these facilities
have been used only by coloro che sanno.  They are perceived to be too
difficult for mandolinisti to master, and heroic measures are taken to
avoid their use.  Thus, while incompetence is not the only rationale for
the use of DLLs and the like, it is the chief one. 

 

There are legitimate uses of late binding times, but two things about
them must be understood:
 
o deferring binding times incurs additional overheads and it incurs them
repeatedly, and
 
o doing so gives scope for more errors, not, in my experience, fewer of
them.
 
Generic preferences for early or late binding times are thus always
unhelpful.
 
These things said, Chris Craddock's projection of what the future holds
is prescient, all but certainly correct.
 
I wish I were as sanguine as he is about the consequences.  Most
homegrown systems are ugly, badly designed and badly implemented; and,
while some acquired systems are radically better, many are not.

 

Poor programming, inferior system design, and the like are things that
we have tacitly agreed not to talk much about; instead we embrace, more
or less briefly, and then discard a succession of shibboleths, each,
like its predecessor, touted as a simple global remedy for all of our
problems.  There is little to be done about this; but we should all be
familiar with Forster's story, 'The day the machine stopped'.  
 
John Gilmore Ashland, MA 01721-1817 USA




_________________________________________________________________
Windows Live(tm): Keep your life in sync. 
http://windowslive.com/explore?ocid=TXT_TAGLM_WL_BR_life_in_synch_062009
----------------------------------------------------------------------
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@bama.ua.edu with the message: GET IBM-MAIN INFO
Search the archives at http://bama.ua.edu/archives/ibm-main.html

 that has nothing much to do with the content of this thread.
 
Still, what Chris Craddock had to say about what I shall call binding
times was of great interest.
 
Decisions about the resolution of from where and/or when an external
entry is to be invoked or a table is to be loaded may be taken at
different times. These actions may, that is, be bound
 
o at programming time,
 
o at compile time,
 
o at linkage time, or, finally,
 
o at execution time.
 
In PL/I, but not in C or its sequelae, one can use generic function
references like
 
x = sqrt(y) ;
 
delegating to a compiler the responsibility to choose an appropriate
entry, one consonant with the data types of x and y.  However this is
managed, execution-time binding of a sqrt routine is something to be
avoided. 
 
Or again, one can write a division-method hashing routine that always
uses the divisor/modulus m=29 (a convenient small prime), or instead one
can make m an execution-time formal parameter of the hashing routine.
(The option of making the decision which of a set of hashing routines,
one each for m=2,3,5,7,11,13,..., an execution-time one is
unattractive.)   
 
In recent years late binding times have come to be more and more heavily
used.  Sometimes this is appropriate because the maintenance/replacement
cycles of invoker and invoked are very different.  A CICS application
that uses DB2 may not, for example, wish 

----------------------------------------------------------------------
For IBM-MAIN subscribe / signoff / archive access instructions,
send email to lists...@bama.ua.edu with the message: GET IBM-MAIN INFO
Search the archives at http://bama.ua.edu/archives/ibm-main.html

Reply via email to