The more I dig into Racket, the more I like it. It seems like a perfect fit for 
both my personality and the type of applications I am, and will be, writing. 
For the vast majority of what I need to do, it's a great fit.

I do occasionally encounter a need for raw speed, so I'm looking for a 
complement to Racket for those few times when it's not fast enough. I chatted 
briefly about this on IRC the other day, but I thought I'd tap into the 
collective wisdom on the mailing list.

I'm open to suggestions, but I've tentatively narrowed the list down to Rust 
and C. I programmed in C/C++ for about a decade, then Java for a decade, and 
most recently in Ruby for a decade, so it's been a while since I was an expert 
C hacker, and my recent Ruby experience has lessened my polyglotness :)

If I were to do a *lot* of lower level coding, I think the niceties of Rust 
would win out over C, but I'm planning on doing most of my application coding 
in Racket, and only needing a lower level language for a few speedups, some 
ad-hoc file crunching programs, etc.. I like the memory safety Rust provides 
without giving up too much performance; the standard library seems fairly rich; 
the language features are fairly nice, etc.

Although I think there is a goal to reduce the amount of C code in Racket, I 
expect there will continue to be a fair amount for the foreseeable future, so 
getting my C chops back would allow me to possibly contribute in that area 
eventually (although I'd prefer to contribute Racket code). And there are some 
Schemes that compile down to C which would allow me to use them in some 
challenged environments (e.g. for Robotics, etc.), so renewing my C proficiency 
would be handy.

I think the FFI interaction between Racket & C may be smoother than between 
Rust & C, but that is conjecture.

Multi-core complicates things a bit. The specific program that motivated me to 
consider Rust or C is an easily parallellizeable program to parse & dump a file 
into a different format, and even though I wrote plenty of multi-threaded C 
code in the past, I'm almost positive this would be much more pleasant, and 
less error prone, in Rust. And given current CPU advances, I think multi-core 
is important for getting the most out of code these days.

Ultimately they're not mutually exclusive, but in the near term they are, I 
only have so much time.

Any thoughts from folks that are FFI'ing from/to Racket and/or using a second 
language in the same system as Racket ?

Thanks,
Brian


-- 
You received this message because you are subscribed to the Google Groups 
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to