With a mighty <3076789076329...@naggum.no>,
e...@naggum.no uttered these wise words...

So you're saying that I'm using the wrong OS? What should I be using,
then? Will you pay me to use it and write code for it?

I'll make it clear for you. Windows people make a big distinction
between an EXE and a DLL. Perhaps this distinction is a forced one,
but it exists. There are development tools that make the distinction,
and which complain if you give them the wrong type of module. Also,
when you load a module, it knows what type of module it is, and a DLL
does very different things to an EXE. The distinction may be forced,
but when you can't control where the event loop goes, or the way in
which the module is initialised, the way in which you can use that
module become somewhat limited.

So, could you please tell me how I turn a WinMain function in
somebody else's code into a LibMain function? Do you have any idea
what I'm talking about? Can you do more than attempt to divert this
thread into another subject? It's obviously one that you're good at
discussing, as you've done little here but rant about Bill Gates.

* Martin Rodgers
| So you're saying that I'm using the wrong OS?

no, Martin, that is not what I'm saying.  please try to understand your
native language for a change.

I'm actually saying that whatever OS Martin Rodgers is using (be it Windows
or some Unix or whatever) is utterly irrelevant for any public discussion
of anything whatsoever that has any bearing at all on anything outside of
his cubicle and his relationship with his colleagues.  Martin Rodgers'
choice (or lack thereof) of OS is as insignificant to the future of Lisp as
the fact that my second 19" Sun M monitor burned the other day, and that
the spare I received from a friend also burned.  yes, I used to run a
dedicated Emacs with Allegro Common Lisp on that display.  of course, I'm
very sad about this loss, and I have to find a way to either use virtual
displays or crowd the Emacs I run Allegro in into the first display which
is full of status-displaying windows, ZenIRC, Gnus, etc, if I can't locate
another monitor that's still in good shape.  should I quit using Lisp, now
that I have had a small setback?  should I sit down and cry that the world
is harsh and uninhabitable?  and are _you_ getting bored yet?

you see, Martin, the above irrelevant rant is the level on which you're
talking to us about Windows and DLLs, Martin.  irrelevant technical details
from your immediate surroundings that have no trace of value to discuss
with anybody.  who _cares_ what Martin Rodgers suffers through in his
working day?  who _cares_ what other Windows victims suffer through in
their working day?  who _cares_ how many gazillions of Windows victims
there are as long as there are enough of the _relevant_ people to keep the
Lisp vendors happy and growing?

now, of course it would be useful if one could program on a real computer
and deploy on the GAIDS-infected wastes, but hey, if somebody actually has
the money to put where their mouth is, it'll happen.  as long as some
whining loser lost somewhere in Britain makes a lot of noise about it, but
refuses to buy it when it comes out (ooh, it's too expensive for my toy
budget!), refuses to pay for the development (oh, no, I didn't mean _I_
should help them), and effectively argues against people who do make a
living using Lisp in non-Windows environments and even against those who
make a living in the Windows world _without_ that magic DLL thingy (oh,
that's not the "real world"), _why_ should anyone do it?

and _if_ somebody does it, what will Martin Rodgers complain about next?
you see, Martin, you don't do anything constructive here at all, so I'm
loathe to have a vendor actually come up with a solution to your problem,
as you might accidentally stumble on some relevant issue to whine about if
you don't continue to whine that you can't use it, it's too expensive, it
has the wrong color, it has American spelling, or something like that.

| I'll make it clear for you.  Windows people ...

I wonder how clear a message needs to be for you to get it, Martin.  let's
try again with a single sentence:

    "Windows people" DO NOT MATTER on the time scale where Lisp matters.

you seem to be utterly unable to handle anything but the most trivial of
technical details, unable to lift your gaze to anything having a time frame
of more than a slight elongation of the moment, and incapable of handling
the fact that Microsoft's reign will pass.  you're just like the incredibly
annoying people who argue against building infrastructure because they
can't immediately use it themselves to go shopping groceries, and they need
a water melon that's soft, but not too soft, and ...  you get the idea.

| So, could you please tell me how I turn a WinMain function in somebody
| else's code into a LibMain function?

(make-library-entry-point <function>)

| Do you have any idea what I'm talking about?

no.  why the hell should I?  you don't matter.  Windows doesn't matter.

| Can you do more than attempt to divert this thread into another subject?

oh, like it's _you_ who understand the _real_ issue?  I see.  HAHAHAHA!!

| It's obviously one that you're good at discussing, as you've done little
| here but rant about Bill Gates.

you have already proved beyond any possible doubt that you don't get any
message but your own, but I regret that I have given you an opportunity to
think you have.

* Martin Rodgers
| It appears that some Lisp people are rather hostile to this platform, and
| are unwilling to discuss the _technical_ issues.

I see.  you actually think you discuss technical issues.  that's pretty
amazing, considering that you don't include anything constructively
technical in any of your messages at all.

tell you what, Martin, if you had discussed technical issues, this thread
would have run to its completion in February 1996, and you would have the
ability to create DLLs in a Lisp you could afford to buy.  the fact is,
however, that _you_ don't know enough about creating DLLs to help anybody
who could have done it.  (IF you had known, you would have shared of this
knowledge to help fulfill your actual wishes, instead of whining for month
upon month that you don't get what you want.  if you actually DO know how
to create DLLs, but keep going with your whining, you're more destructive
than I thought possible, so in the interest of being generous, I disregard
that possibility.)

| The political issues should be irrelevant.  The Lisp vendors I've asked
| about this have replied to me in a much more civilised manner, and I
| appreciate that.

hm.  you know what?  if you call a company with a really stupid question or
being incredibly annoying, whoever answers can reply to you in a civilized
manner because they can share the experience with their colleagues as soon
as they hang up.  this is one of the great benefits of having large rooms
of support people answering phones.  this is why going out to lunch was
invented.  it's very important to relieve stress, and having to deal with
people like you sure is stressful.  if I were to answer a phone call from
you, I would be civilized to your face, too.  if I worked for a Lisp
vendor, I would, however, insist that you help me solve the problem in a
constructive way, I would probably request a purchase order for the product
whenever it was finished, and I would probably also ask for funding to get
the job done in a timely fashion if you were in a hurry.  _then_ it would
be a professional relationship between me and you, and you would be paying
me to be civilized to you on the phone, too.  also, it doesn't take much to
be civilized to somebody on the phone if no commitments are made, no plans
are altered, no costs incurred (except the wasted time of the one person
answering the phone and those he tells afterwards).  what _does_ take real
effort and goodwill is to be generous and civilized to people who make
destructive noises about Lisp vs the "real world" in a crowd of thousands.
your goodwill account is seriously overdrawn, Martin, and that's why I get
seriously hostile to you when you don't quit being annoying.  you could
rectify your goodwill account by publishing _technical_ details necessary
for somebody to, like, change a WinMain to a LibMain function instead of
being an annoying asshole by asking others to "prove" to you they know some
idiotic arcana of Windows.  consider this: if you asked somebody on the
phone to prove the same to you the way you do it here, they would hang up
and refuse to take more calls from you, IF they were civilized.  if they
were not civilized, or the civilized veneer cracked, I sure wouldn't want
to be you.

| I believe that I'm just being realistic.  Perhaps if I were being truely
| realistic, I might listen to the people who tell me to use something
| other than Lisp, instead of looking for ways to convince them that Lisp
| can solve their problems.

let's see.  you would like us to infer that you are using Lisp, not
something other than Lisp, but Lisp cannot be used in your world, because
the DLL is the sine qua non of software development and no Lisp can build
DLLs.  this contradiction must mean that you are _in_fact_ using something
other than Lisp, and it is obviously impossible successfully to convince
anybody that Lisp can solve their problems when Lisp can't solve their
problems because Lisp lacks the sine qua non.  this means that all the
evidence presented can only suggest that Martin Rodgers would _like_ people
to believe he uses Lisp and has a real problem that he desperately needs
solved, but what people who read his rants carefully _actually_ believe is
that Martin Rodgers does not know Lisp, does not use Lisp, does not intend
to use Lisp, and even if he wanted to and tried, his boss (who must have
_some_ brains even though he hired Martin, because he finds my articles
entertaining) would turn down his desire to buy a professional version of a
commercial Lisp that could create DLLs.

who do you think you're kidding?

why do you insist upon wasting other people's time so much?

more importantly, who do I waste my time with you?  (the answer is obvious,
actually.  when I got back to reading comp.lang.lisp after a few weeks of
absence, as much as 90% of the articles contained whining about Windows or
followups to whining about Windows.  if this is what Windows does to
people, I have one more reason to avoid it.  when I'm faced with a serious
irritant, I try to remove it -- be that Windows or Windows fanatics.  I
don't know whether I have actually succeeded in removing Martin Rodgers'
incessant whining, but I _have_ removed the irritant as far as _I'm_
concerned.  and I doubt that anybody else is reading this, anyway, so the
danger of having annoyed any third party in the process is slim.)

With a mighty <3076828202548...@naggum.no>,
e...@naggum.no uttered these wise words...

I think that you're trying to direct this thread away from the real
questions, like how come LWW and ACL/PC can't create a DLL?
Fortunately, Harlequin are fixing that with DylanWorks. They describe
of the features as "DLL interoperability and library generation"
See: <URL:http://www.harlequin.com/full/products/sp/dylan.html>.

Instead, you're trying to make this personal. Don't bother with the
insults, Erik, as I don't take any of this personally. I've seen you
flame to many people in the same way to believe that this could be
about me. I suspect that I'm saying some things that make you
uncomfortable, and that you're using these bully tactics simply to try
to make me shut up.

Why not simply address the issue directly? I'm not the only one asking
about the value of dynamic linking for Lisp. For example, in a recent

As Kent himself said, part of this depends on what you think counts as
Lisp. If Lisp is only what you personally will use, and you insist on
flaming anyone who thinks that it should be just a tad different, then
you're nothing more than a bully. You've made disparaging comments
about Bill Gates, but I'll leave the question of whether or not he too
is a bully for an advocacy newsgroup.

This article is being crossposted to an appropriate newsgroup, BTW.
I'm sure you know this, as you keep removing it when you post. Are you
denying that your strong negative feelings toward Windows make this an
advocacy issue, or are you denying that you such feelings?

Placing the runtime support code into a DLL instead of the image (or
the EXE, in the case of LWW) would also help, as the EXE or DLL could
then be much smaller. One of the reasons I like Gambit C so much is
that the support code is in a DLL. With some effort, it should also be
possible to get it to create a DLL. However, this is not "Lisp" as you
define it, as that could only be Common Lisp, and Gambit C is Scheme.

Still, you may see my point. It can be done, and a number of other
languages succeed in doing far more demanding things than this.
There's an APL that can save the workspace as an OLE object, and
Smalltalk/MT can create DLLs. So can VB!

Why not Lisp? Apart from your stock answer, which is to place the
entire burden on the Lisp programmer rather than the vendor. You may
not like Windows, but can you not see how Lisp may benefit from
gaining a few more programmers, by supporting the things that they
need from a language?

In article <3076789076329...@naggum.no>, Erik Naggum  <e...@naggum.no> wrote:

In order to keep Lisp live, it behooves us to see that people use it.
It therefore behooves us to see that people *can* use it.  If you care
only about yourself, Erik, that's your business.  I'd like to see my
son grow up in a world where he can program in Lisp, or something better
if something better is invented.

Besides, both Harlequin and Franz are already selling Common Lisps for
Windows.  Why should they keep their products substandard?

Martin simply wants a CL system for Windows that will go along with
industry standards, the same as any other non-Microsoft language system
for windows.  There are several of them, and they aren't showing signs
of going out of business soon.

Have you ever called or written or emailed to a Lisp vendor and said
"Gee, it would be really neat if..."?  If you were working on a commercial
Lisp that didn't handle tail recursion, would you write and call
and politely ask when they might add it, or would you think, "Gee,
would I want to fund the necessary programming to do tail recursion?
Maybe I'll just use DO rather than complain, even when tail recursion
would be cheaper."

The intemperate language I've seen in this thread has *not* come from
Martin.  He has been civilized and mostly courteous, even when
exasperated.  Now, I don't have any problems with intemperate language
being used to refer to Microsoft or Microsoft products, and I haven't
seen Martin object to that either.  I do have a problem with intemperate
language being used against Martin.  He has a need, and there are
products that almost address it.  I don't have a problem with Erik's
view that it would be best if no professional touched Microsoft Windows,
in the hopes of killing Microsoft sooner, although I don't think it's
practical.  I do have problems with Erik impugning professionals that
do, and who hope that others will help, or possibly just sympathise,
with them.

With a mighty <5pdnob$qj...@darla.visi.com>,
thorn...@visi.com bravely poked his head over the parapet and risked
being shot at...

Remove DLLs from Windows and nothing would be left. Somewhat like
removing forking from a Unix without any threading. Oops, your OS has
no bones to support the flesh. While Unix may not depend so heavily on
shared libraries, no Windows program can run without using a DLL. The
entire Windows API is in DLLs. While Win32 doesn't depend on forking
(coz of threading), and Win16 doesn't even have threading, where would
Unix be without multitasking?

I'm only comparing Windows with Unix to show how these two systems
both have features without which they couldn't function. I'm ignoring
the forking vs threading issue, as that isn't relevant here. While
there are still crtical Unix programs that depend on forking, that OS
feature will be seen as important by Unix programmers. For Windows
programmers, there are also vital features. DLLs, for example.

It's regretable that Erik fails to appreciate this and flame those who
_do_. Well, his lack of appreciation of Windows could be excused if
not for the manner (flaming) with which he expresses himself on this
subject. He might have something useful to contribute, as he so often
does. Alas, when the issue concerns Windows, it's hard to tell.

Most Windows people I know think that Lisp is dead. If Erik is typical
of Lisp programmers (I hope not), then perhaps they're right. At
least, as far as Windows is concerned. I'm more optimistic, tho. I
also have an interest in Lisp, while most people I know do not. If I
didn't feel that CL and Scheme were useful to me, I'd just quit Lisp  
(as Erik seems to define it, i.e. no DLLs) and instead use Dylan.

Frankly, I could do without Erik's negativity. Until 1992, when I
discovered comp.lang.lisp, I was alone. I knew no other Lisp
programmers. UseNet has put me in contact with many like-minded
individuals, but now it seems to be isolating me again.

While I once felt that Lisp could do anything, I found on UseNet that
people have a much more limited view of how and where Lisp may be
used, while paradoxically claiming that "Lisp can do anything".

Apparently.

] I'll make it clear for you. Windows people make a big distinction
] between an EXE and a DLL. [...]

That's sad.  After all, what is a dynamically linked library if
not a library that is dynamically linked?  And what is an
executable if not a library + loader?

] So, could you please tell me how I turn a WinMain function in
] somebody else's code into a LibMain function? Do you have any
] idea what I'm talking about? Can you do more than attempt to
] divert this thread into another subject? It's obviously one
] that you're good at discussing, as you've done little here but
] rant about Bill Gates.

What a goober!  Ok, I'm jumping into this thread, but just
convert the lisp code into C with any number of high-quality
programs.

Lisp compilers and interpreters are some of the very best of
their kind, and many high-quality solutions exist.  If the
appropriate tools do not exist for Microsoft Windows, instead of
reflecting poorly on Lisp it is a sad commentary on Windows.

(Personally, I prefer Scheme to Common Lisp .. who needs side
effects anyway?)

] <URL:http://www.wildcard.demon.co.uk/> You can never browse enough

I agree with Martin.  C++ is a horrible language to develop Windows
apps in, but there are few alternatives (Basic?!?!?).  I would spend
money on a Lisp development system that could  parse and
produce all the crap you need to interface to existing code (like
C and C++ header files, MIDL files, TLB files, etc.) and produced DLL
's
as output.  It would be especially good if CLOS objects could be compiled
into
``ActiveX'' components.  I'd like to be able to produce deliverables
for my clients without having the fact that the code was written in
Lisp be any concern whatsoever to them.

Well, if some Lisp implementation can't directly generate DLLs, and one
can't reasonably convert EXEs (or a bunch of non-linked object files, if
that's what the Lisp implementation happens to generate - I don't know)
to DLLs, an obvious strategy would be to use an EXE in Lisp as the server
process for one or more (depends on typical usage of the code) non-Lisp
programs - including some DLLs not written in Lisp.

You wrote you could do that with sockets or similar means, but it would
be to slow. Now I don't know much Windows internals, but I'd hope it's
not too primitive to allow/support some form of shared memory - which
should be sufficiently quick for all but the most extreme applications
(from what you wrote you don't seem to need a high-volume database with
heavy io rates as Lisp DLL). To cut down synchronization overhead for the
cases where one Lisp server has to work with more than one client (or
equivalently, with several threads from the same client program), such
code should obviously pre-allocate and reserve communication areas to the
performance-relevant threads of the client, thus serializing the access
protocol between one logical client-thread and the respective server
(re-)actions.

Unless Windows is even more primitive than I already thought, something
like the above shouldn't be very hard to do for a professional Windows
programmer, and probably require at least not much beyond C with Windows-
specific and Lisp-implementation-specific parts (though even most of the
communication logic should possibly remain more abstract than this).

Once the technology to do this is understood, generating the partially
application-specific protocol for each respective application semantics
should be simple from Lisp (after all, building a more abstract - and
more comfortably usable - layer on top of specifications is one of the
strenghts of Lisp). Of course, as far as it makes sense, even this form
of marshalling should be done essentially once and for all, with suitable
reflexive protocol specifications - which could be either compiled for
each specific usage, or even interpreted dynamically where that's needed.
Naturally, the C/whatever low-level side of application-specific instances
would also be generated by Lisp from the specification (a _general_ inter-
preter on the client-side may or may not need to be hand-optimized C for
best performance, depending on the complexity and performance-requirements
of your sytem).

If this is designed and implemented well, it may perhaps even be adapted
to other forms of byte-level communication paths than shared memory, and
different run-time data structures of other implementations and even of
other programming languages. (Who knows, somebody might even have done
something similar already, possibly without noticing that it might help
with this problem?)

Sure, doing all this would be more work for you than having someone else
change a Lisp implementation to generate DLLs and do the dirty parts of
primitive-to-high-level data interfaces for you, but it doesn't sound too
hard if the current alternative is not to use Lisp where you'd like to
use it, and if you really have such a big desire to use Lisp as you imply
in your postings here. Whether it would be good for Lisp vendors to do this
and try to become more widely used within the Windows world is a question
which goes far beyond technical discussions (Erik has mentioned some of
the potential problems, which are hardly unrealistic, even if you may not
like the way he phrased it, or don't agree with his evaluation of risks),
and for the most part wouldn't belong in comp.lang.lisp at all - even if
it made sense to discuss some company's business strategies in a public
forum (which I doubt quite strongly, for almost all cases - people don't
have the relevant information, rarely understand the problems with the
required depth, and are likely to evaluate other people's risk differently
from those where they'll have to live with the consequences themselves).

If you have Windows-specific technical questions, the Windows-related
newsgroups should be the relevant target (and you don't even need to
mention any relation of your questions to Lisp over there, preventing
possible "acceptance problems", uninformed flames and language wars).
On the other hand, if only some conceptual hindrance or Lisp-related
technical problem comes up while trying to implement such a solution,
I guess even Erik wouldn't attack you for actually trying to do it,
and might even contribute some helpful advice.

Martin Rodgers <m...@gubbishwildcard.demon.co.uk> wrote in article
<MPG.e248c12b65f554b989...@news.demon.co.uk>...

Another shock I am having to endure is the C++ tunnel vision of the MFC jocks
we do have on the project. So far, I can see no reason to do the main GUI in
MFC -- VB or Java would have been preferable and far more effective IMO, but
suggestions in that direction have met with enormous pushback. Oh well, once
you buy into a religion, objectivity goes out the door. Lisp religion is no
different, I guess, but it's too bad -- a good Windows-centric Lisp would save
light-years of work on this beast!

On Sun, 29 Jun 1997 21:09:59 +0100, m...@gubbishwildcard.demon.co.uk

Not quite.
You can have one EXE link to another EXE.  Using LoadLibrary routines,
you can map in modules exported by either a .dll or a .exe.  And I
suspect, pretty much any .<suffix> you want.

: IPC techniques like pipes and sockets can pass data
: between an EXE and a DLL that acts as its "front end", for other EXEs
: to link to.

Linked libraries and IPC are not the same thing.

With a mighty <5pei0e$ce...@trumpet.uni-mannheim.de>,
m...@ipx2.rz.uni-mannheim.de uttered these wise words...

While some programmers have the patience to study the internals of the
MFC classes, most of us would prefer not to. It takes time, and it's
very ugly. Even MFC fans might hesitate to do this! When a simpler,
and more importantly, faster solution is available, even a programmer
like myself who would prefer to use Lisp will find resistance from
colleagues and management.

Using Lisp would need to provide a massive time saving to be worth it.
For a large project, this might be so. However, due to the nature of
Windows, what we often find is a collection of small components used
by servers, apps, and Windows itself.

The Lisp approach favours a large monolithic application. The Windows
style of development is increasingly oriented toward the small units
of code refered to as components (OLE, OCX, basic DLL, etc).

Has anyone done this yet? Has anyone even looked into how this might
be done? All I know is that MS keep changing the API, the rules, the
language (VC++ acquires new featurses all the time, and not all of
them will be documented), MFC and anything else they want to. Any task
like this will be a race with MS.

As I've said before, there are languages not at all dissimilar to Lisp
that have no trouble creating DLLs. When creating a DLL is the obvious
answer to the demand for a DLL, the ugly kludged solution discussed
above will only make Lisp look like a language that uses ugly kludges.
This is exactly what you're saying.

What was it that Richard Bach said? Something like, "If you argue for
your limits, you get to keep them." Why accept a limitation that C++
compilers don't?

With a mighty <33bf1a5d.84922796@siesta>,
sang...@inlink.com.remove.everything.after.dot.com uttered these wise
words...

With a mighty <01bc8738$5acc7b80$03d3c9d0@wjh_dell_133.dazsi.com>,
bho...@dazsi.nospam.com uttered these wise words...

 MR> Ooh, lovely. Another flame.

The old Martin-Rodgers Windows-and-Lisp flame-war, huh ?

 MR> So you're saying that I'm using the wrong OS? What should I be
 MR> using, then? Will you pay me to use it and write code for it?

What he says is: if you need A and can't (or don't want) to write it
yourself, pay for it. If you don't want that either, try looking for
another possibility which might be to get a job that does not involve
that W-word. These are your three possibilities, whining in this
newsgroup to a lot of people (and thus wasting bandwith and people's
time) is of no help. If you want to convince someone (useful, I might
add), go and ask some vendor: we can't or don't want to write code for
free so that only you have some benefit from it (as you seem to be the
only one in this NG that is constantly longing for it). If you need it
(e.g. DLLs production from Lisp) so urgently, go and write it, go and
pay some professionals, etc. but please stop posting this stuff over
and over again.

This does not mean that I think DLLs for Lisps under Windows are
useless. In fact, I think that they are important. But discussing this
issue here instead of with <your favourite lisp-vendor here> does not
help anybody.

In article <5peagt$mp...@newsie.cent.net> "Emergent Technologies Inc." <emerg...@eval-apply.com> writes:

   From: "Emergent Technologies Inc." <emerg...@eval-apply.com>
   Newsgroups: comp.lang.lisp,comp.lang.scheme
   Date: Wed, 2 Jul 1997 15:35:11 -0400
   Organization: CENTnet, Inc.
   Lines: 21
   NNTP-Posting-Host: tsa-143.cape.com
   X-Newsreader: Microsoft Outlook Express 4.71.0544.0
   X-MimeOLE: Produced By Microsoft MimeOLE Engine V4.71.0544.0
   Xref: agate comp.lang.lisp:29048 comp.lang.scheme:22097

        ...

   Actually, given the way that Microsoft's DCOM works (late binding,
   explicitly tagged arguments, reference count GC, structured
   exception handling, etc.) it looks like they'll reinvent Lisp at some
   point.

Has not this being clear since 1984?  Most "new" programming language
reinvent some Lisp feature sooner or later.

Besides, if the Windows market would be even half as component-oriented
as all the marketing hype claims, instead of mostly throwing out lots
of ill-defined dangerous toys, and if you'd be as happy and productive
with Lisp as you seem to claim, why don't you and some fellow Windows
programmers who want to use Lisp pay someone to develop such a tool as
a component? If that isn't financially attractive, why do you think it
would be more attractive for Lisp vendors to invest considerable effort
for this market, and what keeps them from "seeing the light" as you do?

It seems we agree by now that you indeed could use it - but somehow you
prefer not to use a sub-optimal but workable solution, only lamenting for
a superior solution which appearently just isn't on the market: the very
market which leads you to label Windows as the "real world" in contrast
to those areas where Lisp is actually used, right now. I'm certainly not
saying that there wouldn't be room for improving Lisp, both as a language
and as particular implementations, but the problem is far from being as
severe as you make it appear, and I can understand why some readers find
your articles annoying.

On Thu, 3 Jul 1997 09:06:51 +0100, m...@gubbishwildcard.demon.co.uk

Huh?!?
LoadLibrary does not require you to have the exe running to link to
it.  It treats the exe as if it was another dll which just happen to
include some program loading stuff which you don't care about.

I routinely link into both dlls and exes from my own code without any
concern regarding whether the exe is running or not.  If it's running,
NT will simply map the exported routines into my process's space and
increment an internal counter.  When I FreeLibrary or terminate my
process gracefully, NT will decrement the counter.  The only
difference I would notice is that if the exe isn't already running
(and consequently already in memory), it will take just a tad longer
to initialize the entry points from my code.  But programmatically, it
would be completely transparant.

: ...Would you do this for every OLE, OCX, or DLL that you wish to
: write in Lisp?

OLE/COM/OCX are treated differently.  You wouldn't even bother with
LoadLibrary.  You simply use the underlying COM mechanism to grab the
dispatch pointer to the routine you want to use.  You can specifically
tell your code to either attempt to grab the active dispatch (ie.,
grab the instance of the object currently running if any), if it can
find one or create an instance of the object on the fly.  Infact,
using COM, you can do some very late binding on your library routines.
Yes, do you have to worry about decrementing the ref count to the
object, but using OLE/COM libraries and/or your own classes, this can
be done automatically when your dispatch goes out of scope.

With a mighty <5ph22e$3r...@trumpet.uni-mannheim.de>,
m...@ipx2.rz.uni-mannheim.de uttered these wise words...

With a mighty <64pvt0bjn4....@gmd.de>,
Holger.Scha...@gmd.de uttered these wise words...

Has the market decided? I don't know. Perhaps the Lisp vendors I've
queried have only been humouring me. Perhaps the Windows support that
Harlequin claim will be in DylanWorks is just vapourware or hype?
Their tether technology is something that neither VC++ nor VB have,
but if it works as Harlequin describe, then I can imagine hords or
Windows programmers _begging_ to use it.

Does the market even know what's possible? I don't know. Without any
public discussion, we only have the word of Lisp vendors. And perhaps
people like Erik Naggum? He may even be right (note that I've not
denied any of his anti-Windows anti-MS comments), in which case it may
be that most people have got it horribly wrong. Including a couple of
Lisp vendors! Good grief.

Life is too short. I've added Erik to my "bozo" filter. I'll miss his
more constructive posts, but I have no time for his negativity. Not
until somebody pays me to use something other than Windows, anyway.
I was hoping for a constructive discussion, but Erik is making that
impossible. In spite of enouraging email from people (thanks to all of
you, you know who you are), I have a Lisp compiler to write, so I'd
like to follow the advise of someone who disagrees with me, and spend
more time working on it.

Any offers of Lisp work will be gratefully received.

With a mighty <33c35afb.167000156@siesta>,
sang...@inlink.com.remove.everything.after.dot.com uttered these wise
words...

With a mighty <kigiuyspksv....@jagor.srce.hr>,
hnik...@srce.hr uttered these wise words...