On Aug 19, 5:30 pm, Jon Harrop ffconsultancy.com> wrote:

In summary, Jon's blocg says the haskell compiler is GHC is dropping
the haskell-based darc as its source control system.

good news to know.

See also:

Distributed RCS, Darcs, and Math Sacrilege
http://xahlee.org/UnixResource_dir/writ/darcs.html

plain text version below.
-------------------------

Distributed RCS, Darcs, and Math Sacrilege

Xah Lee wrote:
«
“Distributed RCS, Darcs, and Math Sacrilege”
http://xahlee.org/UnixResource_dir/writ/darcs.html
»

As of 2007-10, the “theory of patches” introduction section of darc's
documentation that contains the “don't care for math” phrase is at
“http://darcs.net/manual/node8.html#Patch”. As of 2008-08-19, that
section seems to moved to a different section, in this url “http://
darcs.net/manual/node9.html” , and the “don't care about math” bit has
been removed.

Thanks to Xah Lee, whose harsh criticism on society sometimes takes
effect silently.

Xah
∑ http://xahlee.org/

☄

On 19 ago, 22:15, "xah...@gmail.com" gmail.com> wrote:

Physics and engineers don't care much about math, it's just a useful
tool for their more pragmatic goals.

Oh, he does criticize OCaml at every oportunity there is to sell
F#. :)

xahlee@gmail.com wrote:

Despite my foray into other FPLs, OCaml has remained my favourite language
for getting work done (F# is arguably better for making money) but OCaml
does have some problems:

. OCaml lacks a concurrent garbage collector and, consequently, is unable to
leverage shared-memory parallelism on a wide range of tasks. F# fixed this.

. OCaml's has unsafe built-in polymorphic functions such as equality,
comparison and hashing. These can silently break if they are accidentally
applied to abstract types and the subsequent bugs can be almost impossible
to fix.

. OCaml has a cumbersome foreign function interface.

. OCaml lacks run-time type information and, consequently, type-safe
serialization and generic printing. F# solved this problem.

. OCaml lacks operator overloading so mathematical expressions involving
many different numeric types are unnecessarily. F# solved this problem.

. OCaml lacks many basic types such as int8, int16, float32, complex32. F#
solved this problem.

namekuseijin wrote:

You realize we sell OCaml products as well:

http://www.ffconsultancy.com/products/ocaml_for_scientists/?u
http://www.ffconsultancy.com/products/ocaml_journal/?u

In fact, there is currently more money in OCaml than F#...

On Wed, 20 Aug 2008 12:45:29 +0100, Jon Harrop wrote:

I've wondered about this ever since you first mentioned it: given it's
supposedly wonderful type inference, and its lack of scheme/lisp-like
bignums, why doesn't OCaml use native integers, instead of tagged ones?
What is the tag bit used to disambiguate at run-time?

Andrew Reilly areilly.bpc-users.org> writes:

Pointers from integers, for the purpose of garbage collection and,
possibly, for the (unsafe) polymorphic equality operator.

Torben

Haskell is awesome. I heard it might be better to start with ML if it
is your first strongly-typed FP, though.

Andrew Reilly wrote:

The tag distinguishes integers from pointers. Integers have their least
significant bit set. Pointers have their least significant bit unset (they
are multiples of 4).

This is used primarily by the GC in order to determine that pointers must be
followed and integers must not.

On Aug 19, 9:57 pm, "xah...@gmail.com" gmail.com> wrote: