On Friday 09 May 2008, Richard Jones wrote:
On Fri, May 09, 2008 at 07:09:57PM +0100, Jon Harrop wrote:
F# has long since overtaken all other functional languages in terms of
industrial uptake and I have not heard that complaint from anyone. Like
OCaml, it follows simple rules and is
FWIW this is an implementation using Ancient:
--
let n = 1024
let a = Array.make_matrix n n 6.7
let b = Array.make_matrix n n 8.9
(* Result array, stored in shared memory. *)
let c =
let c = Array.make_matrix n n 0. in
let
The concrurent GC that we are writing? You must know more things than
I do. Note to myself: raise this in the next meeting.
I think you are referring to the Ocaml summer project which is to be
done by Emmanuel Chailloux's student.
Till
2008/5/12 Arthur Chan [EMAIL PROTECTED]:
let c =
On Tuesday 13 May 2008 03:03:10 Gerd Stolpmann wrote:
Am Dienstag, den 13.05.2008, 02:19 +0100 schrieb Jon Harrop:
On Tuesday 13 May 2008 01:42:42 Gerd Stolpmann wrote:
In this (very unoptimized) multiplier message passing accounts for ~25%
of the runtime. Even for 2 cores there is
On Sat, May 10, 2008 at 9:52 AM, Richard Jones [EMAIL PROTECTED] wrote:
On Sat, May 10, 2008 at 01:01:03AM +0200, Berke Durak wrote:
But you are saying in the README that values in the ancient heap have
some
limitations, namely no ad-hoc polymorphic primitives.
You misunderstand this
On Sat, May 10, 2008 at 10:24:50AM +0200, Berke Durak wrote:
(1) Ad-hoc polymorphic primitives (structural equality, marshalling
and hashing) do not work on ancient data structures, meaning that you
will need to provide your own comparison and hashing functions. For
more details see
On Friday 09 May 2008 23:25:49 David Teller wrote:
On Fri, 2008-05-09 at 19:10 +0100, Jon Harrop wrote:
Parallelism is easy in F#.
Now, that's a cliffhanger. Could you elaborate?
Sure. Review the concerns cited regarding parallel programming in OCaml:
1. When do we fork? Earlier to amortize
Message
passing is fine for concurrent applications that are not CPU bound or for
distributed computing but it is not competitive on today's multicore machines
and will not become competitive in the next decade.
i don't understand any of this.
2. How do we avoid excessive copying? What if
Am Freitag, den 09.05.2008, 06:09 +0100 schrieb Jon Harrop:
On Friday 09 May 2008 05:45:53 you wrote:
On Thu, May 8, 2008 at 5:39 PM, Jon Harrop [EMAIL PROTECTED] wrote:
1. Lack of Parallelism: Yes, this is already a complete show stopper.
Exploiting multicores requires a scalable
On Friday 09 May 2008 16:38:55 Jeff Polakow wrote:
Hello,
We investigated alternative languages to diversify into last year and
Haskell
was one of them. The single biggest problem with Haskell is that it is
wildly
unpredictable in terms of performance and memory consumption.
This is
First of all let's try to stop the squabling and have some actual some
discussions with actual content (trolling is very tempting and I am
the first to fall for it). OCaml is extremly nice but not perfect.
Other languages have other tradeoffs and the INRIA is not here to
fullfill all our desires.
On Fri, 2008-05-09 at 19:10 +0100, Jon Harrop wrote:
Parallelism is easy in F#.
Now, that's a cliffhanger. Could you elaborate ?
Cheers,
David
I think that the cost of copying data is totally overrated. We are doing
this often, and even over the network, and hey, we are breaking every
On Fri, May 09, 2008 at 11:13:26PM +0200, Berke Durak wrote:
- For sharing complex data, you can marshall into a shared Bigarray.
If the speed of Marshal becomes a bottleneck, a specialized Marshal that
skips most of the checks/byte-oriented, compact serialization things that
extern.c
On Fri, May 09, 2008 at 07:09:57PM +0100, Jon Harrop wrote:
F# has long since overtaken all other functional languages in terms of
industrial uptake and I have not heard that complaint from anyone. Like
OCaml, it follows simple rules and is predictable as a consequence.
Figures to back up
On Sat, May 10, 2008 at 12:25:49AM +0200, David Teller wrote:
On the contrary, that is not a theoretical statement at all: it
already
happened. F# already makes it much easier to write high performance
parallel
algorithms and its concurrent GC is the crux of that capability.
15 matches
Mail list logo
