On Mar 22, 2012, at 9:45 AM, Terry Therneau <thern...@mayo.edu> wrote:

>>>>  strongly disagree. I'm appalled to see that sentence here.
>>> > 
>>> > Come on!
>>> > 
>>>> >> The overhead is significant for any large vector and it is in 
>>>> >> particular unnecessary since in .C you have to allocate *and copy* 
>>>> >> space even for results (twice!). Also it is very error-prone, because 
>>>> >> you have no information about the length of vectors so it's easy to run 
>>>> >> out of bounds and there is no way to check. IMHO .C should not be used 
>>>> >> for any code written in this century (the only exception may be if you 
>>>> >> are passing no data, e.g. if all you do is to pass a flag and expect no 
>>>> >> result, you can get away with it even if it is more dangerous). It is a 
>>>> >> legacy interface that dates way back and is essentially just re-named 
>>>> >> .Fortran interface. Again, I would strongly recommend the use of .Call 
>>>> >> in any recent code because it is safer and more efficient (if you don't 
>>>> >> care about either attribute, well, feel free ;)).
>>> > 
>>> > So aleph will not support the .C interface? ;-)
>>> > 
>> It will look at the timestamp of the source file and delete the package if 
>> it is not before 1980 ;). Otherwise it will send a request for punch cards 
>> with ".C is deprecated, please upgrade to .Call" stamped out :P At that 
>> point I'll be flaming about using the native Aleph interface and not the R 
>> compatibility layer ;)
>> Cheers,
>> S
> I'll dissent -- I don't think .C is inherently any more dangerous than .Call 
> and prefer it's simplicity in many cases.  Calling C at all is what is 
> inherently dangerous -- I can reference beyond the end of a vector, write 
> over objects that should be read only, and branch to random places using 
> either interface. 

You can always do so deliberately, but with .C you have no way of preventing it 
since you don't even know what is the length! That is certainly far more 
dangerous than .Call where you can simply loop over the length, check that the 
lengths are compatible etc. Also for types like strings .C is a minefield that 
is hard to not blow up whereas .Call it is even more safe than scalar arrays. 
You can do none of that with .C which relies entirely on conventions with no 
recorded semantics.

> If you are dealing with large objects and worry about memory efficiency then 
> .Call puts more tools at your disposal and is worth the effort.  However, I 
> did not find the .Call interface at all easy to use at first

I guess this depends on the developer and is certainly a factor. Personally, I 
find the subset of the R API needed for .Call fairly small and intuitive (in 
particular when you are just writing a safer replacement for .C), but I'm 
obviously biased. Maybe in a separate thread we could discuss this - I'd be 
happy to write a ref card or cheat sheet if I find out what people find 
challenging on .Call. Nonetheless, my point is that it is more than worth 
investing the effort both in safety and performance.

> and we should keep that in mind before getting too pompous in our lectures to 
> the "sinners of .C".  (Mostly because the things I needed to know are 
> scattered about in multiple places.)
> I might have to ask for an exemption on that timestamp -- the first bits of 
> the survival package only reach back to 1986.  And I've had to change source 
> code systems multiple times which plays hob with the file times, though I did 
> try to preserve the changelog history to forstall some future litigious soul 
> who claims they wrote it first  (sccs -> rcs -> cvs -> svn -> mercurial).   
> :-)

;) Maybe the rule should be based on the date of the first appearance of the 
package, fair enough :)

        [[alternative HTML version deleted]]

R-devel@r-project.org mailing list

Reply via email to