Re: [announcement] SYSAPI and SYSSVC for Windows

[Hyman Rosen <hyrosen@mail.com>]

Ekkehard Morgenstern wrote:
> Some concepts require the use of pointers, such as linked lists,
> and pointers to instances of objects.

How many times are you going towrite a linked list?
Are you going to have hundreds of linked list implementations
in your program? Is std::list unsuitable for som ereason?

As for pointers to instances, if you mean many pointers to some
single object, then you can copy those pointers around willy-nilly
anyway, so you still don't need custom copy and assignment.

> That's not a bad design to create a pointer to a instance of an object.
> It's a perfectly normal C++ way of programming.

It's a perfectly normal way of C programming.
In C++, it's much more suspect.

> I don't know what kind of programs you deal with, but you seem
> somehow detached from the real world of programming.

I've been doing nothing professionally but programming for twenty years.

> Well, some documents say that access types can be garbage collected by
> the runtime system.

Only if the compiler implements it. By far the vast majority do not,
except for implementations which target JVMs. C++ implementations could
do the smae as well, and many programs use the Boehm conservative collector
in just such a fashion.

> Copying a pointer value is about the worst thing you can do, 
> unless you know exactly what you're doing.

Some of us do, you know.

> That really depends on what kind of class you're dealing with.
> Not all pointers can be held in smart pointers, nor be copied.

Neither of those statements is true.

> As if that would be a major software-engineering task.

Sigh. You may want to look up the discussions on auto_ptr, and have a
look at the implementation of the Boost smart pointers before making
remarks like that. You remind me of those inexperienced mountain climbers
who die on mountains that are far beyond the range of their abilities,
because they do not even know enough to know what things are dangerous.

> They're not the same. The value might be the same, but it depends
> on floating-point accuracy. But to prevent such problems, one
> could postulate they aren't the same.

I'm awaiting with eagerness the ensuing discussions here on c.l.a.
where I get to defend why x<1.0 + 1.0> is different from x<2.0>.

> This would definitely take more time (understanding all that code,
> plus modifying and porting it), than writing an all-new compiler.
> 
> I like writing compilers and so that will not be a major effort for me.

I will now invite the people in this newsgroup who have actually worked
on Ada compilers to respond to this. I'll be over there banging my head
against the wall. Holler if you need me. (Oh, and if your compiler will
target x86 architecture, don't forget to write to Intel and AMD for the
manuals on how to optimize code for each different version of the Pentium
and Athlon procesors.)

> Like, a compiler might be huge for you, but for me it's just medium-scale.

Be sure to let me know when you're done.