@mcc It's been a long time since I wrote code in a strongly-typed language but I'll take strong type checking at compile time over trying to figure out what someone else's code does in a duck typing language.

Then again, I was trained as an applied mathematician / scientific applications programmer. Types are part of our innate toolset.

@andy_twosticks @mcc I work mostly in R/RStudio. The workflow is about as optimum as it can be, but even with that I still have run a lengthy validation suite that catches a few errors the syntax checker allows. And it's more of a linter than anything else.

R is garbage-collected, of course. I think that's

a) cheating, and
b) a sign you don't care about resource usage.

@AlgoCompSynth @mcc Hard opposite here. I feel like the fact C doesn't clean up after itself is Why We Can't Have Nice Things. Coders will always make mistakes.

Rust's approach is … interesting. But I feel like making the language a lot more complex in order to avoid both memory leaks and garbage collection is probably the wrong (but a damn clever) idea.

@andreasdotorg @mcc @AlgoCompSynth @andy_twosticks and let us not forget what happens in a manual environment when you free a huge quantity of data in one batch, eg delete a large dictionary or whatever. Much longer pause time than an incremental GC.

Though one assumes you don't do that in a time-critical place 😀

@andreasdotorg @mcc @AlgoCompSynth @andy_twosticks the memory safety in rust is awesome, except they insisted on building smart pointers (Box etc) on top of it for half-assed reference-counting memory management, though the last 30 years tells us that's not good enough.

Automated memory management requires a global not local (per pointer) view of liveness.

I want to see rust with real GC 😀

@phenidone @andreasdotorg @mcc @andy_twosticks

My most recent disappointment with garbage collection involves R and `tidyverse` pipes on some large-ish transit data in an 8 GB laptop. By breaking the pipe chains into single steps and forcing a garbage collect after each step I was able to run it.

#RStats

After that I

1. Upgraded the laptop to 32 GB, and
2. Rewrote the code using `data.table`, which can do the heavy lifting in place, rather that having multiple copies of large tables lying around.

#RStats

@phenidone @andreasdotorg @mcc @andy_twosticks

Laziness is not always a virtue, especially in large-scale scientific computing where getting bounds on resource usage during the software engineering process is fairly easy (compared to, say a compiler or a theorem prover).

@andreasdotorg @mcc @AlgoCompSynth @andy_twosticks "laziness" is also a term usually used to paper over macho Calvinist attitudes to programming, ie The Programmer Must Do It All, with a corollary of The Programmer Is Infallible.

We're writing software so we automate things. GC is automation, and it gets rid of several whole bug classes arising from the Infallible Programmer fallacy.

@andreasdotorg @mcc @AlgoCompSynth @andy_twosticks
IMHO we are sorely missing the ultimate combination of static lifetime analysis and borrow checking, with a modern/complete/incremental GC for the corner cases that a static checker cannot infer.

Basically, Rust with GC instead of smart pointers.

Yes I know I just made everyone angry but really it is for the better 😀

@andreasdotorg @mcc @AlgoCompSynth @andy_twosticks
Rust is kind of halfway there: it has mutexes (runtime access controls) because nobody is insane enough to claim that a static access control checker can work for all cases in a concurrent environment.

It just needs to make the next step and realize that runtime lifetime analysis is also required 😀

@phenidone @andreasdotorg @mcc @andy_twosticks

If I understand the motivation for the design choices the Rust team made, it was to make "system programming" - presumably compilers / interpreters, operating systems, webservers, databases, browsers, etc. - easier to get right on a successful compile without sacrificing performance.

@phenidone @andreasdotorg @mcc @andy_twosticks

Of that lot I've only done operating system programming, and that was so long ago that doing it in assembly was still the norm. 😀 If I were writing an OS today I'd do it in Rust. Case closed.

Operating systems don't have time for garbage collection. They don't even have time for floating-point computation. But they do need dynamic memory allocation and concurrency, and Rust is designed so the compiler saves the programmer time.

@AlgoCompSynth @andreasdotorg @mcc @andy_twosticks
Absolute nonsense.

If you have time to call free() or delete[] then you have time for the GC to do its thing.

@AlgoCompSynth @andreasdotorg @mcc @andy_twosticks also we are not running on 6502 and 68000 anymore. Cache locality is *critical* to performance, and you can often get measurable speedups using a compacting GC.

Admittedly the concept of "my data can move" is terrifying to people who were raised on C 😀 and there are terrible corner cases.

But you need to not think of GC as having only performance cost.