[OT] Comment about Late Binding

[David C. Holley]

I was looking up some information on Late Binding and found one
particular comment as quite humerous. The emphasis is mine.

"For now, the important point is that the variable is bound to the
class, and it’s bound late. You’ll hear a lot about early binding and
late binding in the rest of this book. Late binding means that the
variable is connected to the class at run time. *This is evil.* If you
learn only one thing from this book, it should be how to avoid late
binding. Early binding means that the variable is connected to the class
at compile time. This is good. You should always try to achieve early
binding. Alas, there was no such thing back in the old days when the
story server was written."

 

[Marshall Barton]

I was looking up some information on Late Binding and found one
particular comment as quite humerous. The emphasis is mine.

"For now, the important point is that the variable is bound to the
class, and it’s bound late. You’ll hear a lot about early binding and
late binding in the rest of this book. Late binding means that the
variable is connected to the class at run time. *This is evil.* If you
learn only one thing from this book, it should be how to avoid late
binding. Early binding means that the variable is connected to the class
at compile time. This is good. You should always try to achieve early
binding. Alas, there was no such thing back in the old days when the
story server was written."

Quite a superficial view. I read something similar in an MS
document way back when there was only one version of
anything to bind to. At that time the emphasis was on
convenience verses the extra time it took to resolve the
references at runtime. With modern machines, time is not a
significant issue and binding to a bewildering array of
versions is a paramount concern.

 

[David C. Holley]

It was the *THIS IS EVIL* comment that struck me as funny.

 

[David C. Holley]

I was the *THIS IS EVIL* comment that struck me as funny. I personally
wouldn't rank late binding up there with the 9/11 attacks and such.

 

[Rick Brandt]

I was looking up some information on Late Binding and found one particular
comment as quite humerous. The emphasis is mine.

"For now, the important point is that the variable is bound to the class, and
it’s bound late. You’ll hear a lot about early binding and late binding in the
rest of this book. Late binding means that the variable is connected to the
class at run time. *This is evil.* If you learn only one thing from this book,
it should be how to avoid late binding. Early binding means that the variable
is connected to the class at compile time. This is good. You should always try
to achieve early binding. Alas, there was no such thing back in the old days
when the story server was written."

Yes, this was written when the "dream of COM" had not yet been realized as the
"nightmare of DLL Hell".

In the context of an app where the various libraries and controls are all
bundled into the delivered app (as in VB) this viewpoint might still have some
legitimacy. I mean just the idea that you can catch errors at compile time
instead of at runtime is huge. Who would argue that the former is not
preferred?

But when the library dependency is on a DLL that is not entirely within the
control of your application's installation the idea simply breaks down. At the
end of the day the app has to actually work and early binding (more often than
not) is a hindrance to that goal.

 

[Alex Dybenko]

I would say - use early binding when you are sure that typelib is up to
date, else use late.
only difference - is a performance issue - late binding takes more time to
initialize a component. But as Marsh said - this is nothing now

 

[David C. Holley]

It was the *THIS IS EVIL* comment that I found funny.

 

[Tim Ferguson]

I was the *THIS IS EVIL* comment that struck me as funny. I personally
wouldn't rank late binding up there with the 9/11 attacks and such.

I think it means Evil as in Google, not the other one..


Tim F

 

[RD]

I was looking up some information on Late Binding and found one
particular comment as quite humerous. The emphasis is mine.

"For now, the important point is that the variable is bound to the
class, and it’s bound late. You’ll hear a lot about early binding and
late binding in the rest of this book. Late binding means that the
variable is connected to the class at run time. *This is evil.* If you
learn only one thing from this book, it should be how to avoid late
binding. Early binding means that the variable is connected to the class
at compile time. This is good. You should always try to achieve early
binding. Alas, there was no such thing back in the old days when the
story server was written."

LOL! Eeeeevil! What book is that from?

 

[David C. Holley]

Actually it was an article that I found online. I don't remember the
article (I forgot that I even posted this), but I do recall that it was
authored by a supposed Access guru/professional. S/he might even have
been a MVP. (Which is why it caught my attention.)