News for hackers. Stuff that matters.
Re:15 Years of Concurrency by Bahamut on Wednesday November 30, 2016 @10:29PM (#13076985)
Performance - immutability comes at a high cost sometimes.
Re:15 Years of Concurrency by jandrese on Wednesday November 30, 2016 @11:16PM (#13077135)
When I saw the example in the paper of building a list by copying the entire list for every new entry and trashing the old one I knew performance would be a problem. A smart compiler can optimize that if it knows what you are doing, but they were writing a research compiler.

There is a tradeoff with this kind of immutable oriented programming that you trade off relatively easy parallelism for heinous memory thrashing--and cache misses are already a huge bottleneck on modern architectures. Rust seems to have struck a good balance here, I'm keeping a close eye on it as it continues to mature.

Re:15 Years of Concurrency by harpocrates on Thursday December 01, 2016 @06:19AM (#13078670)
Another thing to keep in mind is that with everything being immutable you end up with a pure language. Once that happens, the compiler starts being able to perform some really nice rewrites of your code really easily. The problem is that this is all or nothing - unless your language is actually pure you can't do this.

See this blog post for more <https://donsbot.wordpress.com/2008/06/04/haskell-as-fast-as-...

Re:15 Years of Concurrency by VodkaHaze on Wednesday November 30, 2016 @10:37PM (#13077009)
Especially when memory constrained
Re:15 Years of Concurrency by victorcase on Wednesday November 30, 2016 @10:52PM (#13077048)
Ok in the context of - critical - constrained memory I understand;

However do you agree that is more easy to solve memory (buying new hardware) than handle with race condition? kkkk

Then, Maybe we need to think about optimize our daily data structures.. I have following a few papers about this.. e.g:

http://dl.acm.org/citation.cfm?id=2658763 http://dl.acm.org/citation.cfm?id=2993251

Re:15 Years of Concurrency by jandrese on Wednesday November 30, 2016 @11:18PM (#13077141)
It's easy to buy memory, but hard to buy L2/L3 cache. The whole point of the exercise is to scale more easily on multicore architectures, but it's no good if you blow out the cache thousands of times per second and bottleneck the system on memory accesses.
Re:15 Years of Concurrency by AstralStorm on Thursday December 01, 2016 @03:23AM (#13078028)
Additionally, DRAM and VRAM bandwidth are always at premium. Whenever you're making a copy (which you do a lot when objects are immutable), you use memory bandwidth.

This is especially important on mobile, FPGAs and in cases where sheer volume of data is huge. (GPU and big data)

Re:15 Years of Concurrency by adwn on Thursday December 01, 2016 @02:25AM (#13077821)
In addition to what jandrese said: You can nearly always add main memory capacity, but you cannot easily improve main memory throughput or latency.