What do you LISPers think of Haskell?

1995 views
Skip to first unread message

ssecorp

unread,
Aug 19, 2008, 1:31:27 PM8/19/08
to
What are you LISPers opinion of Haskell?

Pros and cons compared to LISP?

namekuseijin

unread,
Aug 19, 2008, 2:14:42 PM8/19/08
to
On Aug 19, 2:31 pm, ssecorp <circularf...@gmail.com> wrote:
> What are you LISPers opinion of Haskell?
>
> Pros and cons compared to LISP?

Pros: Haskell is cool loaded with cool features
Cons: Haskell is not Lisp

DeverLite

unread,
Aug 19, 2008, 6:52:06 PM8/19/08
to
On Aug 19, 12:31 pm, ssecorp <circularf...@gmail.com> wrote:
> What are you LISPers opinion of Haskell?
>
> Pros and cons compared to LISP?

Caveat: It's been a while since I've used Haskell (2-3 yrs), and I've
only been working in common lisp recently (2 yrs)

I remember Haskell being very succinct, and having a very powerful
typing system. Lisp has more of the former, and much less of the
latter. Although very flexible, and good at catching errors at compile
time, I found the typing system in Haskell sometimes got in the way.
Lisp let's you declare types, but if you don't want to you don't have
to, and this tends to make it more flexible than Haskell. Furthermore,
with good unit testing, the sorts of errors one would catch in
haskell, also get caught early on in lisp.

Likewise, although Haskell has some capacity to define new language
constructs, Lisp's macros are more powerful, and this provides a
further degree of flexibility.

Haskell's built-in syntax has more succinct ways of describing things
like list comprehensions, return of multiple variables from a
function, and function currying. The assumed lazy evaluation also
means that you can do some very pretty stuff with 'infinite' lists,
that get's a little uglier in lisp. However, I also find Haskell to be
harder to read than lisp, largely because of these very features.

I also seem to recall haskell being pretty slow, but that might just
have been the compiler I was using, and what I was using it for. Lisp
on the other hand can be quite fast. (I believe some claim, as fast or
faster than C).

So in summary:

Haskell: a more powerful type checking system, that can catch more
errors, more succinct for some operations. Not quite as readable as
lisp
Lisp: More flexible. Faster. Possibly less succinct for particular
applications, but often the flexibility means you can define
constructs that lead to more succinct code than one would write in
Haskell. Possibly less error catching at compile time, but unit
testing can largely make up for this.

Perhaps I am biased in this regard, but I generally prefer Lisp.
Though I might consider using Haskell for a well defined problem where
I knew the sort of lazy evaluation and pattern matching that is easily
expressed in Haskell would be useful.

Pascal J. Bourguignon

unread,
Aug 19, 2008, 8:07:30 PM8/19/08
to
DeverLite <derby....@gmail.com> writes:
> [...] Although very flexible, and good at catching errors at compile

> time, I found the typing system in Haskell sometimes got in the way.
> Lisp let's you declare types, but if you don't want to you don't have
> to, and this tends to make it more flexible than Haskell.

Actually, what the lisp type system means is that in lisp we program
in generic mode by default.

When you write:

int fact(int x){ return (x<=0)?1:x*fact(x-1); }

it's statically typed, but it's also SPECIFICALLY typed.

When you write in lisp:

(defun fact (x) (if (<= x 0) 1 (* x (fact (1- x)))))

it's already a generic function (not a lisp generic function,
technically, but what other programming languages call a generic
function):

(mapcar 'fact '(4 4.0 4.0l0 5/2))
--> (24 24.0 24.0L0 15/8)

to get the same in C++ you would have to write:

#include <rational.hxx>
template <typename T> fact (T x){ return (x<=0)?1:x*fact(x-1);}

... fact(4),fact(4.0),fact(4.0d0),fact(Rational(5,2)) ...


I hope Haskell is able to derive these instances automatically.


But you can easily get even more genericity, either using non CL
operators that you can easily redefine (eg. as lisp generic
functions), by shadowing them to the same effect, or by using
functions passed in argument. CL:SORT is generic because it takes a
LESSP function, so it can be applied on sequences of any kind of
object.


So what statically checked type system proponents detract as duck
typing is actually that lisp works in the Generic Mode gears by
default.


--
__Pascal Bourguignon__ http://www.informatimago.com/
I need a new toy.
Tail of black dog keeps good time.
Pounce! Good dog! Good dog!

Jon Harrop

unread,
Aug 19, 2008, 8:30:52 PM8/19/08
to
ssecorp wrote:
> What are you LISPers opinion of Haskell?
>
> Pros and cons compared to LISP?

Haskell's success rate at generating widely-used open source code is far
lower than most other languages:

http://flyingfrogblog.blogspot.com/2008/08/haskells-virginity.html

--
Dr Jon D Harrop, Flying Frog Consultancy
http://www.ffconsultancy.com/products/?u

xah...@gmail.com

unread,
Aug 19, 2008, 9:15:37 PM8/19/08
to
On Aug 19, 5:30 pm, Jon Harrop <j...@ffconsultancy.com> wrote:
> ssecorp wrote:
> > What are you LISPers opinion of Haskell?
>
> > Pros and cons compared to LISP?
>
> Haskell's success rate at generating widely-used open source code is far
> lower than most other languages:
>
> http://flyingfrogblog.blogspot.com/2008/08/haskells-virginity.html

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, 2007-10-19

When i first heard about distributed revision control system about 2
years ago, i heard of Darcs, which is written in Haskell↗. I was
hugely excited, thinking about the functional programing i love, and
the no-side effect pure system i idolize, and the technology of human
animal i rapture in daily.

I have no serious actual need to use a revision control system (RCS)
in recent years, so i never really tried Darcs (nor actively using any
RCS). I just thought the new-fangled distributed tech in combination
of Haskell was great.

About 2 months ago, i was updating a 5-year old page i wrote on unix
tools (The Unix Pestilence: Tools and Software) and i was trying to
update myself on the current state of the art of revision systems. I
read Wikipedia (Darcs↗) this passage:

Darcs currently has a number of significant bugs (see e.g. [1]).
The most severe of them is "the Conflict bug" - an exponential blowup
in time needed to perform conflict resolution during merges, reaching
into the hours and days for "large" repositories. A redesign of the
repository format and wide-ranging changes in the codebase are planned
in order to fix this bug, and work on this is planned to start in
Spring 2007 [2].

This somewhat bursted my bubble, as there always was some doubt in the
back of my mind about just how Darcs is not just a fantasy-ware
trumpeted by a bunch of functional tech geekers. (i heard of Darcs in
irc emacs channel, who are often student and hobbyists programers)

Also, in my light research, it was to my surprise, that Darcs is not
the only distributed system, and perhaps not the first one neither,
contrary to my impressions. In fact, today there are quite a LOT
distributed revision systems, actually as a norm. When one looks into
these, such as Git↗, one finds that some of them are already used in
the industry for large projects, as opposed to Darcs's academic/
hobbist kind of community.

In addition to these findings, one exacerbation that greatly pissed me
off entirely about Darcs, is the intro of the author (David Roundy)'s
essay about his (questionable-sounding) “theory of patches” used in
Darcs. ( http://darcs.net/manual/node8.html#Patch )

Here's a quote:

I think a little background on the author is in order. I am a
physicist, and think like a physicist. The proofs and theorems given
here are what I would call ``physicist'' proofs and theorems, which is
to say that while the proofs may not be rigorous, they are practical,
and the theorems are intended to give physical insight. It would be
great to have a mathematician work on this, but I am not a
mathematician, and don't care for math.

From the beginning of this theory, which originated as the result
of a series of email discussions with Tom Lord, I have looked at
patches as being analogous to the operators of quantum mechanics. I
include in this appendix footnotes explaining the theory of patches in
terms of the theory of quantum mechanics. I know that for most people
this won't help at all, but many of my friends (and as I write this
all three of darcs' users) are physicists, and this will be helpful to
them. To non-physicists, perhaps it will provide some insight into how
at least this physicist thinks.

I love math. I respect Math. I'm nothing but a menial servant to
Mathematics. Who the fuck is this David guy, who proclaims that he's
no mathematician, then proceed to tell us he doesn't fucking care
about math? Then, he went on about HIS personal fucking zeal for
physics, in particular injecting the highly quacky “quantum mechanics”
with impunity.

-------------------------

Btw, Jon, you often attack Lisp, Haskell. However, i don't think i've
ever seen you criticize OCaml.

Of course, since you sell OCaml thus you are probably very biased.

Is there some criticism of OCaml you could say? so at least to show
you are not that biased?

If you do reply to give some criticism of OCaml, please don't just
give some cursory lip service that appears to be negative criticism
but not. It might be true that you really think OCaml is
comparatively great in all or almost all aspects... but surely there
are some critically negative aspects?

Xah
http://xahlee.org/


Kenny

unread,
Aug 19, 2008, 10:27:50 PM8/19/08
to
ssecorp wrote:
> What are you LISPers opinion of Haskell?
>
> Pros and cons compared to LISP?

All I know is that some google yobbo listened to sean parent try to
explain for 76 minutes why the dataflow paradigm offered two orders of
magnitude code reduction and all the yobbo could ask was, "Why didn't
you use Haskell?" Far it be it from a Lisper to accuse someone of being
obsessed with an obscure niche language, but I just did.

I think only F# is better at turning otherwise intelligent engineers
into frothing at the mouth idiots. I would have added OCaml but I saw
some investment bank in NYC was Actually Using It, and The Kenny hasa
soft spot for Programmers Actually Programming.

hth, kt

DeverLite

unread,
Aug 19, 2008, 11:15:37 PM8/19/08
to
On Aug 19, 9:27 pm, Kenny <kentil...@gmail.com> wrote:
> I would have added OCaml but I saw
> some investment bank in NYC was Actually Using It, and The Kenny hasa
> soft spot for Programmers Actually Programming.

Also I think FFTW3, the very well used open source Fourier transform
library, uses OCaml to generate optimized C code...

DeverLite

unread,
Aug 19, 2008, 11:21:56 PM8/19/08
to
On Aug 19, 7:07 pm, p...@informatimago.com (Pascal J. Bourguignon)
wrote:

Right. Thanks for the clarification. I didn't mean to imply that there
was no typing by default in lisp: just that it wasn't something you
had to *declare*.

xah...@gmail.com

unread,
Aug 20, 2008, 12:57:44 AM8/20/08
to
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/


namekuseijin

unread,
Aug 20, 2008, 1:01:16 AM8/20/08
to
On 19 ago, 21:07, p...@informatimago.com (Pascal J. Bourguignon)
wrote:

> Actually, what the lisp type system means is that in lisp we program
> in generic mode by default.
>
> When you write:
>
>    int fact(int x){ return (x<=0)?1:x*fact(x-1); }
>
> it's statically typed, but it's also SPECIFICALLY typed.

Yes.

> When you write in lisp:
>
>    (defun fact (x) (if (<= x 0) 1 (* x (fact (1- x)))))
>
> it's already a generic function

Not quite. More on that in a moment.

> to get the same in C++ you would have to write:
>
>   #include <rational.hxx>
>   template <typename T> fact (T x){ return (x<=0)?1:x*fact(x-1);}
>
>   ... fact(4),fact(4.0),fact(4.0d0),fact(Rational(5,2)) ...

The C++ example with template is far more generic than the Lisp one:
it's defined for all types T capable of handling operatotions <= and
*, whereas the Lisp one just takes them for granted over numbers.

Of course, in the case of factorial, it doesn't matter, but it means
you can have complex datatypes redefining useful operators (or
functions) *at compile time*. Same for Haskell. Functions are
defined and dispatched per type.

You could of course do something like this, say, in Scheme:
(define +
(let ((o+ +))
(lambda (a b . more)
(apply (if (string? a)
string-append
o+)
(cons a (cons b more))))))

and use it more "generically" like this:
(+ 1 2 3 4 5) => 15
(+ "foo" "bar") => "foobar"

In implementations which actually permit redefining such fundamental
functions.

But then, you gotta do run-time checks on the arguments not present in
the Haskell and C++ compile-time functions. Note such checks can go
on as you nest deep into possibly yet previous redefinitions of the
operator that do almost like the above.

> But you can easily get even more genericity, either using non CL
> operators that you can easily redefine (eg. as lisp generic
> functions), by shadowing them to the same effect, or by using
> functions passed in argument.  CL:SORT is generic because it takes a
> LESSP function, so it can be applied on sequences of any kind of
> object.

These are all fine workarounds, even though perhaps more verbose than
simply being able to do function "overloading" per types. Sorry if I
sound froggy.

namekuseijin

unread,
Aug 20, 2008, 1:09:45 AM8/20/08
to
On 19 ago, 22:15, "xah...@gmail.com" <xah...@gmail.com> wrote:
> I love math. I respect Math. I'm nothing but a menial servant to
> Mathematics. Who the fuck is this David guy, who proclaims that he's
> no mathematician, then proceed to tell us he doesn't fucking care
> about math? Then, he went on about HIS personal fucking zeal for
> physics, in particular injecting the highly quacky “quantum mechanics”
> with impunity.

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

> Btw, Jon, you often attack Lisp, Haskell. However, i don't think i've
> ever seen you criticize OCaml.

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

Ralph Allan Rice

unread,
Aug 20, 2008, 1:11:16 AM8/20/08
to
On Aug 19, 1:31 pm, ssecorp <circularf...@gmail.com> wrote:
> What are you LISPers opinion of Haskell?
>

I recently did some Haskell (and Erlang) hacking, too. Although I like
both languages and they both have their niches, the biggest feature
that takes me back to Common Lisp every time is macros. Whenever I use
another language (does not matter what it is), deep down I wish the
language had macros like Common Lisp.

--
Ralph

Scott Burson

unread,
Aug 20, 2008, 1:55:42 AM8/20/08
to

You could try Liskell: http://liskell.org/

I haven't tried it, but it looks interesting.

-- Scott

Jon Harrop

unread,
Aug 20, 2008, 7:45:29 AM8/20/08
to
xah...@gmail.com wrote:
> Btw, Jon, you often attack Lisp, Haskell. However, i don't think i've
> ever seen you criticize OCaml.

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.

. OCaml lacks value types so complex numbers cannot be unboxed. F# solved
this problem and, consequently, is 5.5x faster at complex FFTs than
naively-written OCaml.

. OCaml has an old fashioned one-stage compiler design. F# improves upon
this with the CLR's ahead-of-time compilation. For example, the CLR
generates type specialized native code whereas OCaml uses a uniform generic
representation that can incur substantial performance hits.

. OCaml's uniform generic representation includes tagged 31- and 63-bit
integers. F#'s unboxed representation is ~3x faster.

. The OCaml implementation cannot be contributed to and we cannot pay INRIA
to fix or improve it. For example, I filed a bug with a verbatim source
code fix that was only actually instigated a year later.

I believe these problems can be solved in a future open source FPL without
sacrificing the key features that make OCaml so productive. However, many
of these problems do not constitute research and, consequently, they are
unlikely to be fixed by academic programming language researchers.

I am not sure how to proceed with such a project (e.g. build upon LLVM or
build upon Mono?) but there appears to be growing interest in this idea.
Ideally, FPL communities would collaborate to build a common language
run-time for OCaml, Lisp, Scheme, Haskell and so on but I cannot see that
happening for social reasons. Without such collaboration, I doubt any of
these languages will ever get a concurrent GC approaching the efficiency
of .NET's.

Jon Harrop

unread,
Aug 20, 2008, 7:53:04 AM8/20/08
to

And FFTW is part of MATLAB. Intel, Microsoft and Citrix all have huge OCaml
code bases as well...

Jon Harrop

unread,
Aug 20, 2008, 7:53:52 AM8/20/08
to
namekuseijin wrote:
> Oh, he does criticize OCaml at every oportunity there is to sell
> F#. :)

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#...

Grant Rettke

unread,
Aug 20, 2008, 11:53:18 AM8/20/08
to
Haskell is awesome. I heard it might be better to start with ML if it
is your first strongly-typed FP, though.

namekuseijin

unread,
Aug 20, 2008, 1:43:09 PM8/20/08
to
On Aug 20, 2:55 am, Scott Burson <FSet....@gmail.com> wrote:
> You could try Liskell:http://liskell.org/
>
> I haven't tried it, but it looks interesting.

Whoa! Looks mighty fine to me! :D

http://liskell.org/fifteen-minute-tour

The syntax and semantics look like a nice mix of Scheme and Haskell.
I the ease of defining ADTs:

(defdata Point3DType
(Point3D Rational Rational Rational))

and pattern matching on function definition without destructuring-bind
or other verbose macro workaround:
(define (distance3D (Point3D x y z))
(sqrt (+ (^ x 2)
(+ (^ y 2) (^ z 2)))))

or function definitions in let with the same syntax sugar as in define
(no lambda):
(define (scalar-multiply s point)
(let (((Point3D x y z) point)
((p x) (* s x)))
(Point3D (p x) (p y) (p z))))

Perhaps it also comes full with lazy semantics? A project to watch
closely.

Who knows, perhaps it attracts even more interest than Haskell or Lisp
alone... now Arc has some tough competition! :P

Marco Antoniotti

unread,
Aug 20, 2008, 2:05:30 PM8/20/08
to

or Common Lisp (with semi-Prolog naming convention).

(defmethod +//2 ((x string) (y string))
(concatenate 'string x y))
(defmethod +//2 ((x number) (y number))
(cl:+ x y))

(defun extmath:+ (x y &rest more-summable-things)
(reduce '+//2 more-summable-things
:initial-value (+//2 x y)))

You can expand on this code as much as you want.

Cheers
--
Marco

Marco Antoniotti

unread,
Aug 20, 2008, 2:09:42 PM8/20/08
to
On Aug 20, 1:43 pm, namekuseijin <namekusei...@gmail.com> wrote:
> On Aug 20, 2:55 am, Scott Burson <FSet....@gmail.com> wrote:
>
> > You could try Liskell:http://liskell.org/
>
> > I haven't tried it, but it looks interesting.
>
> Whoa!  Looks mighty fine to me! :D
>
> http://liskell.org/fifteen-minute-tour
>
> The syntax and semantics look like a nice mix of Scheme and Haskell.
> I the ease of defining ADTs:
>
> (defdata Point3DType
>   (Point3D Rational Rational Rational))
>
> and pattern matching on function definition without destructuring-bind
> or other verbose macro workaround:
> (define (distance3D (Point3D x y z))
>   (sqrt (+ (^ x 2)
>            (+ (^ y 2) (^ z 2)))))
>
> or function definitions in let with the same syntax sugar as in define
> (no lambda):
> (define (scalar-multiply s point)
>   (let (((Point3D x y z) point)
>         ((p x) (* s x)))
>     (Point3D (p x) (p y) (p z))))
>
> Perhaps it also comes full with lazy semantics?  A project to watch
> closely.

You mean CLAZY? (Shameless plug: common-lisp.net/project/clazy). Not
that the hack is particularly clever, but it shows you how you can do
these things *in* portable Common Lisp.

Cheers
--
Marco

Message has been deleted

xah...@gmail.com

unread,
Aug 20, 2008, 2:47:40 PM8/20/08
to

Arc is one of the despicable worthless shit there is.

Arc is the type of shit that when some person becomes famous for his
achivement in some area, who began to sell all sort of shit and
visions just because he can, and people will buy it.

So, please don't mention arc. Mention Qi, NewLisp, Liskell instead.
These are far more effort, dedication, earnestness, as well much more
technical merits or social benefits, than dignitary's fame selling
shits.

Qi is great because it adds advanced functional features to lisp yet
remain compatible with Common Lisp.

Liskell is worth looking into because it is a experiment exploiting
the the nested syntax, meanwhile brings in the semantics of a well
developed functional lang.

Qi and Liskell are very welcome, and non-trivial, addition to lisp
communities that can help lispers get new insights.

NewLisp is great because it is a earnest effort in modernizing lisp,
breaking away the ~3 decades of traditions and thought patterns that
are rooted in Common Lisp and Scheme. NewLisp's community is entirely
distinct from CommonLisp/SchemeLisp, attracting much newer generation
of hobbist and non-professional programers. NewLisp isn't one of the
fashionable new lang created for the sake of new lang. It has been
around more than a decade.

http://en.wikipedia.org/wiki/NewLisp
http://en.wikipedia.org/wiki/Qi_(programming_language)

I support Qi, NewLisp, Liskell. Please mention these in your
socializing chats.

Paul Graham, the author of Arc, of course have every right to create
his lang just like anyone else, and even for the sole purpose of
selling his name just because he can. And perhaps due to his past
contribution in the lisp community, Arc might be successful and
getting a lot users purely due to Paul's fame. However, please
consider the real value of a new lang, from technical to social, and
not as opposed to who's more famous. (for example, technical
considerations can be such as what new functionality it brings, such
as Qi, or what insight it might bring, such as Liskell. Social
consideration can be such as whether it bring the ideas of lisp to
entirely new segments of society, such as NewLisp.)

See also:

What Languages to Hate
http://xahlee.org/UnixResource_dir/writ/language_to_hate.html

plain text version follows:
----------------------------------

What Languages to Hate

Xah Lee, 2002-07-18

Dear lisp comrades and other concerned parties,

First, all languages have equal rights. Do not belittle other
languages just because YOUR favorite language is a bit better in this
aspect or that. Different people have different ideas and manners of
perception. Ideas compete and thrive in all unexpected fashions.
Societies improve, inventions progress. Lisp may be a first in this or
that, or faster or flexibler, or higher level than other languages old
and new, but then there are other languages the like of Mathematica &
Haskell & Dylan et al which ridicule lisps in the same way lisp
ridicule other languages.

Just because YOU are used to more functional programing or love lots
of parenthesis doesn't mean they are the only and best concepts. The
so-called Object Oriented programing of Java fame, or the visual
programing of Visual Basic fame, or the logic programing of Prolog
fame, or the format-stable syntax of Python fame, or the “one line of
Mathematica equals ten to one thousand lines of lisp” of _A New Kind
Of Science_ fame... all are parts of healthy competing concepts,
paradigms, or directions of growth.

The way some of you deride other languages is like sneering
heterogeneousness. If unchecked, soon you'll only have your sister to
marry to. Cute, but you do not want incest to become the only sex.
Next time your superiority complex makes you sneer at non-lisp or
newfangled languages, remember this. It is diversity of ideas, that
drives the welfare of progress.

Now, there is one judgmental criterion, that if a language or computer
technology fits it, then we not only should castigate at their
missionaries, but persecute and harass the language to the harshest
death. That is: utter sloppiness, irresponsibility, and lies. These
things are often borne out of some student's homework or moron's dirty-
work, harbored by “free” and wanton lies and personal fame, amassed
thru ignorance.

Of my short but diligent industrial unix computing experience since
1998, i have identified the following targets:

* C (and consequences like csh, C++)
* vi
* Perl
* MySQL
* unix, unixism, and things grown out of unix. (languages,
protocols, philosophies, expectations, movements)

In our software industry, i like to define criminals as those who
cause inordinate harm to society, not necessarily directly. Of the
above things, some of their authors are not such criminals or are
forgivable. While others, are hypocritical fantastic liers selfish to
the core. When dealing with these self-promoting jolly lying humble
humorous priests and their insidious superficially-harmless speeches,
there should be no benefit of doubt. Tell them directly to stop their
vicious lies. Do a face-off.

As to their brain-washed followers for example the not-yet-hard-core
unix, C, or Perl coders rampant in industry, try to snap them out of
it. This you do by loudly snapping fingers in front of their face,
making it sound like a ear piercing bang. Explain to them the utter
stupidity of the things they are using, and the harm to their brain.
IMPORTANT: _teach_, not _debate_ or _discuss_ or falling back into
your philosophical deliberating indecisiveness. I've seen enough
criticisms among learned programers or academicians on these, so i
know you know what i'm talking about. When you see a unixer
brainwashed beyond saving, kick him out of the door. He has became a
zombie who cannot be helped.

There are other languages or technology, by itself technically are
perhaps mediocre but at least is not a egregious irresponsible hack,
therefore does not deserve scorn, but sometimes it comes with
overwhelming popular outrageous lies (euphemized as hype). Java is a
example. For this reason, it is equally deserving the harshest
treatment. Any loud proponents of such should be immediately slapped
in the mouth and kicked in the ass in no ambiguous ways.

Summary: all languages have equal rights. However, those utterly
SLOPPY and IRRESPONSIBLE HACKS with promoter's LIES should be severely
punished. It is these, that cause computing industry inordinate harm.
Meanwhile, it is wrong to haughtily criticize other languages just
because they are not your cup of tea. Now, please remember this and go
do society good.

Xah
http://xahlee.org/


Tamas K Papp

unread,
Aug 20, 2008, 3:35:07 PM8/20/08
to
On Tue, 19 Aug 2008 10:31:27 -0700, ssecorp wrote:

> What are you LISPers opinion of Haskell?
>
> Pros and cons compared to LISP?

I tried Haskell before CL. Most of the programming I do is the
application/implementation of numerical methods for solving economic
models.

Even though I recognize the `elegance' of certain Haskell constructs, the
language was a straitjacket for me because of two things: the type system
and the functional purity.

The type system required a lot of scaffolding (Either, Maybe, ...) when I
wanted to do something non-trivial. Indeed, Haskell makes the
construction of this scaffolding really easy, but in CL, I just find that
I don't have to do it and I can spend time writing more relevant code
instead.

Also, sometimes I had difficulty rewriting my algorithms in purely
functional ways. I agree that it can always be done, but I had to spend
a lot of time fighting Haskell.

What attracted me to Haskell initially was the elegance found in toy
examples (eg the Fibonacci series). It took me a lot of time to realize
that toy examples are, well, toy examples, and whether a language handles
them well is not relevant to problems of a larger scale. For example,
pattern matching looked fascinating, until I realized that I am not using
it that often.

Also, when I tried Haskell I didn't know about macros, which give Lisp a
lot of extra power. Now of course I would not ever use a language
without CL-like macros.

Note that I am not claiming that CL is `better', just that it suits me
better. Haskell is a fine language, and I don't intend to disparage it.
You will have to make up your own mind. I would suggest that you try
both: even if you end up using only one of them, working in the other one
for at least a month will broaden your horizons.

Best,

Tamas

namekuseijin

unread,
Aug 20, 2008, 4:28:33 PM8/20/08
to
On Aug 20, 3:47 pm, "xah...@gmail.com" <xah...@gmail.com> wrote:
> On Aug 20, 10:43 am, namekuseijin <namekusei...@gmail.com> wrote:
> > Who knows, perhaps it attracts even more interest than Haskell or Lisp
> > alone... now Arc has some tough competition! :P
>
> Arc is one of the despicable worthless shit there is.

Good that my little sarcasm prompted such inspired response from
you. ;)

namekuseijin

unread,
Aug 20, 2008, 4:36:12 PM8/20/08
to
On Aug 20, 4:35 pm, Tamas K Papp <tkp...@gmail.com> wrote:
> I tried Haskell before CL.  Most of the programming I do is the
> application/implementation of numerical methods for solving economic
> models.

> Even though I recognize the `elegance' of certain Haskell constructs, the
> language was a straitjacket for me because of two things: the type system
> and the functional purity.

That's weird. Functional languages abstractions and syntax should go
hand-to-hand with numerical problems such as those you describe.

> The type system required a lot of scaffolding (Either, Maybe, ...) when I
> wanted to do something non-trivial.

You mean IO?

> Also, sometimes I had difficulty rewriting my algorithms in purely
> functional ways.  I agree that it can always be done, but I had to spend
> a lot of time fighting Haskell.

That doesn't make any sense: you don't fight Haskell when writing in
purely functional ways, only when allowing mutation and side-effects
in. And since you're mostly dealing with numerical computations and
algorithms, I believe IO would be very limited to just a few sections,
like reading lots of data from external sources and generating output.

> For example,
> pattern matching looked fascinating, until I realized that I am not using
> it that often.

Perhaps because you're programming in Haskell as if it was Lisp?

Tamas K Papp

unread,
Aug 21, 2008, 3:09:54 AM8/21/08
to
On Wed, 20 Aug 2008 13:36:12 -0700, namekuseijin wrote:

> On Aug 20, 4:35 pm, Tamas K Papp <tkp...@gmail.com> wrote:
>> I tried Haskell before CL.  Most of the programming I do is the
>> application/implementation of numerical methods for solving economic
>> models.
>
>> Even though I recognize the `elegance' of certain Haskell constructs,
>> the language was a straitjacket for me because of two things: the type
>> system and the functional purity.
>
> That's weird. Functional languages abstractions and syntax should go
> hand-to-hand with numerical problems such as those you describe.

Sometimes they do, sometimes they don't. You can always write the
problem in purely functional ways, but sometimes that required quite a
bit of effort. For example, something like using a simple hash table
(which is still "provisional") requires IO. Things like that were a pain.

>> The type system required a lot of scaffolding (Either, Maybe, ...) when
>> I wanted to do something non-trivial.
>
> You mean IO?

Nope, I mean handling cases when a non-numerical result needs to be
returned or handled. Think of using nil to indicate a missing number in
Lisp: in Haskell you would need a Maybe. Or think of a function that
could take a real number or a list, for that I had to use Either. Things
like this got tiresome after a while. But this was not why I stopped
using the language.

>> Also, sometimes I had difficulty rewriting my algorithms in purely
>> functional ways.  I agree that it can always be done, but I had to
>> spend a lot of time fighting Haskell.
>
> That doesn't make any sense: you don't fight Haskell when writing in
> purely functional ways, only when allowing mutation and side-effects in.
> And since you're mostly dealing with numerical computations and
> algorithms, I believe IO would be very limited to just a few sections,
> like reading lots of data from external sources and generating output.

Your beliefs do not coincide with my experience. If you have already
specified the algorithm that you are trying to implement, perhaps you can
figure out the uber-functional way to do it in the first try. But in my
line of work, you experiment with different algorithms and because you
don't know which one of them will work a priori. I find Lisp ideal for
that kind of tinkering, whereas in Haskell, I found this hard.

>> For example,
>> pattern matching looked fascinating, until I realized that I am not
>> using it that often.
>
> Perhaps because you're programming in Haskell as if it was Lisp?

If you reread my post, you will find that I started Haskell before CL.

Anyhow, please don't feel that you need to defend Haskell from me. I
emphasized that I consider Haskell a fine language, just not suitable for
my purposes. I gave Haskell an try, I used it for about 6 weeks. Of
course you can always claim that if I had used it for 6 years, I would be
more experienced and would see how to do things the Haskell way, but
honestly, I don't care. I was more productive in Lisp after a week than
in Haskell after 6 weeks.

Best,

Tamas

rvir...@gmail.com

unread,
Aug 21, 2008, 5:46:01 AM8/21/08
to

I just checked out the sight but it doesn't look like much has been
done there recently. Does anyone know any more about this.

Robert

Jon Harrop

unread,
Aug 22, 2008, 10:24:44 AM8/22/08
to
Tamas K Papp wrote:
> On Wed, 20 Aug 2008 13:36:12 -0700, namekuseijin wrote:
>> Perhaps because you're programming in Haskell as if it was Lisp?
>
> If you reread my post, you will find that I started Haskell before CL.

Sounds like you were not familiar with modern static typing though.

Daniel Pitts

unread,
Aug 24, 2008, 11:25:09 AM8/24/08
to
xah...@gmail.com wrote:
> Arc is one of the despicable worthless shit there is.
>
> Arc is the type of shit that when some person becomes famous for his
> achivement in some area, who began to sell all sort of shit and
> visions just because he can, and people will buy it.
That might be true, but I'd love it if you expounded on why you believe
that? I don't have a lot of lisp experience, so I need someone to
highlight facts about why Arc is bad comparatively.

Thanks.

--
Daniel Pitts' Tech Blog: <http://virtualinfinity.net/wordpress/>

Kenny

unread,
Aug 24, 2008, 11:43:18 AM8/24/08
to
Daniel Pitts wrote:
> xah...@gmail.com wrote:
>
>> Arc is one of the despicable worthless shit there is.
>>
>> Arc is the type of shit that when some person becomes famous for his
>> achivement in some area, who began to sell all sort of shit and
>> visions just because he can, and people will buy it.
>
> That might be true, but I'd love it if you expounded on why you believe
> that? I don't have a lot of lisp experience, so I need someone to
> highlight facts about why Arc is bad comparatively.

PG bet the ranch on terser code at all costs, including all sorts of
whacky syntax that is so whacky bits of it conflict and cannot be used
in combination. It was starting to look like Python when I left town.

And of course the single namespace is a disaster. Oh, and the absence of
an OO package.

kt

Pascal J. Bourguignon

unread,
Aug 24, 2008, 1:04:39 PM8/24/08
to
Daniel Pitts <newsgroup....@virtualinfinity.net> writes:

> xah...@gmail.com wrote:
>> Arc is one of the despicable worthless shit there is.
>> Arc is the type of shit that when some person becomes famous for his
>> achivement in some area, who began to sell all sort of shit and
>> visions just because he can, and people will buy it.
> That might be true, but I'd love it if you expounded on why you
> believe that? I don't have a lot of lisp experience, so I need
> someone to highlight facts about why Arc is bad comparatively.

As little lisp experience you may have, you have more than Xah.

Asking for advice to Xah in lisp matters (and probably in any other
matter), is like asking for financial advice to the first tramp you
meet.

--
__Pascal Bourguignon__ http://www.informatimago.com/

"This statement is false." In Lisp: (defun Q () (eq nil (Q)))

xah...@gmail.com

unread,
Aug 24, 2008, 6:49:28 PM8/24/08
to
On 2008-08-24, Daniel Pitts wrote:
> xah...@gmail.com wrote:
> > Arc is one of the despicable worthless shit there is.
>
> > Arc is the type of shit that when some person becomes famous for his
> > achivement in some area, who began to sell all sort of shit and
> > visions just because he can, and people will buy it.
>
> That might be true, but I'd love it if you expounded on why you believe
> that? I don't have a lot of lisp experience, so I need someone to
> highlight facts about why Arc is bad comparatively.

i haven't actually used arc. My opinion of it is based on reading Paul
Graham's essays about his idea of some “100 year language” and
subsequent lisper's discussions on it this year here (most are highly
critical). Also, Wikipedia info gives some insight too:

http://en.wikipedia.org/wiki/Arc_(programming_language)

Paul's essay:
“The Hundred-Year Language”
http://www.paulgraham.com/hundred.html

I consider one of the most wortheless essay. Worthless in the same
sense Larry Wall would have opinions on computer languages...

to fully detail will take several hours writing perhaps 2 thousands
words essay....

ok, perhaps a quick typing as summary of my impressions... but i know
all sort of flame will come.

Paul has some sort of infatuation with the concept of “hackers” (and
his languages is such that these “hacker” will like). I think this is
a fundamental problem in his vision.

If we look closely at the concept of “hacker”, from sociology's point
of view, there are all sort of problems rendering the term or notion
almost useless. In short, i don't think there is a meaningful class of
computer programer he calle “hackers” that one could say a computer
language is for them.

for example, hacker can be defined as knowledgeable programers, or
those exceptionally good at programing among professional programers,
or those who delights in technical details and their exploitation, or
those who are programers who tends to be extremely practical and
produce lots of useful codes, or those who's coding method heavily
relies on trial and error and less on formal methods or systems, or
perhas some element of all of the above. I don't mean to pick bones on
definitions, but i just don't see any sensible meaning in his frequent
use of the term in the context of designing a language.

put in another way... let's think about what langs are his “hackers”
like? would it be lisp?? perl?? or something such as Haskell? As you
know, these lang are quite different in their nature. However, it's
quite difficult to say which is the one hackers prefers. In some
sense, it's probably perl. But in another sense, it's lisp, since lisp
being unusual and has many qualities such as it's “symbols” and
“macros” concepts that allows it to be much more flexible at computing
tasks. But then, it could also be haskell. Certainly, lots of real
computer scientists with higher mathematical knowledge prefers it and
consider themselves real hackers in the classic sense of MIT's lambda
knight and ulimate lambda etc.

looking into detail on some of his idea about Arc's tech detail ... i
find them the most worthless.

so, yeah, in summary, i see arc as almost completely meritless, and as
a celebrity's intentional or unintentional effort to peddle himself.

Note, i find some of Paul's essays very insightful or i agree with,
such as one that talk about some psychology of nerds and highschool
bullies, and his opinion on OOP ...

----------------------------

here's some of my personal opinion on language design.

I think the criterions for “best” or “100-year” language is rather
very simple.

• it is easy to use. In the sense the masses can use it, not requiring
some advanced knowledge in math or computer science or practical
esoterica like unix bag.

• it is high level. This is related to easy to use. Exact, precise
definition of “High level” is hard to give, but typically it's those
so-called scripting langs, e.g. perl, python, php, tcl, javascript.
Typical features are typeless or dynamic typing, support many
constructs that do a lot things such as list processing, regex, etc.

• it has huge number of libraries. This can be part of the lang as
considered in java “API” or perl's regex or mathematica's math
functions, or can be bundled as many perl and python's libs, or as
external archive such as perl's cpan. The bottom line is, there are
large number of libraries that can be used right away, without having
to search for it, check reliability, etc.

the above are really down-to-earth, basic ideas, almost applicable to
anything else.

the tech geekers will you believe other things like garbage
collection, model of variable, paradigms like functional vs oop,
number systems, eval model like lazy or not lazy, closure or no, tail
recursion or no, has curry or no curry, does it have linder mayer
system or kzmolif type sytem, polymorphism yes?, and other moronic
things.

If you look at what lang becomes popular in the past 2 decades (thru
various website), basically those bubble up to top, are those with
good quality in hte above criterions. (e.g. perl, php, javascript,
visual basic.) C and Java are still at top, of course, because there
are other factors such as massive marketing done by Java, and C being
old and has been the standard low level system lang for decades.

(excuse me for typos and other errors... took me already a hour to
type and lots other newsgroup responses... will perhaps edit and put
on my website in the future...)

Xah
http://xahlee.org/


Ali

unread,
Aug 24, 2008, 9:13:03 PM8/24/08
to
I believe he meant "timeless". Timeless might imply that it was very
important to provide a decent language for encoding algorithms,
and not so much to the initial size of libraries at year 0. Whether or
not the language is great for encoding algorithms (or any other
timeless qualities) is largely matter of opinion, as you have stated
previously.

>> there are all sort of problems rendering the term or notion almost useless.

This page may be of use, http://www.catb.org/~esr/faqs/hacker-howto.html,
although I'm guessing you've already read it and maybe even have an
essay for it.

In fact, I wouldn't go looking for a dictionary style definition,
since he used the word "hacker" to convey what he thought a hacker
was, so his article on "great hackers" would be very relevant:
http://www.paulgraham.com/gh.html

Those language qualities you listed do seem to be a good measure for a
good language though.
It seems to me that Arc has the first 2 qualities but not the third.

xah...@gmail.com

unread,
Aug 25, 2008, 6:16:21 AM8/25/08
to
On Aug 24, 6:13 pm, Ali <emailalicl...@gmail.com> wrote:
> I believe he meant "timeless". Timeless might imply that it was very
> important to provide a decent language for encoding algorithms,
> and not so much to the initial size of libraries at year 0. Whether or
> not the language is great for encoding algorithms (or any other
> timeless qualities) is largely matter of opinion, as you have stated
> previously.
>
> >> there are all sort of problems rendering the term or notion almost useless.
>
> This page may be of use, http://www.catb.org/~esr/faqs/hacker-howto.html,
> although I'm guessing you've already read it and maybe even have an
> essay for it.

i red the jargon file, perhaps some 70% of it, in late 1990s online.

At the time, i appreciate it very much.

But today, i have came to realize that the maintainer Eric Raymond is
a selfish asshole.

For example, Wikipedia has this to say
http://en.wikipedia.org/wiki/Jargon_file

quote:

«Eric S. Raymond maintains the new File with assistance from Guy
Steele, and is the credited editor of the print version, The New
Hacker's Dictionary. Some of the changes made under his watch have
been controversial; early critics accused Raymond of unfairly changing
the file's focus to the Unix hacker culture instead of the older
hacker cultures where the Jargon File originated. Raymond has
responded by saying that the nature of hacking had changed and the
Jargon File should report on hacker culture, and not attempt to
enshrine it.[2] More recently, Raymond has been accused of adding
terms to the Jargon File that appear to have been used primarily by
himself, and of altering the file to reflect his own political views.
[3]»

Eric, one of the guy largely responsible for the Open Source movement
and plays a role a antagonistic to FSF. He also created a hacker logo
to sell himself. He's essay the Cathedral and Bazzar, which i read in
late 1990s, i consider stupid. You can often read his posts or
argument online in various places, and from those post you can see
he's often just a male ass.

Wikipedia has some illuminating summary of him:
http://en.wikipedia.org/wiki/Eric_S._Raymond

basically, a money hungry and selfish ass.

It used to also talk about how he supports the iraq war with some
racist undertone or some remarks he made about blacks ... i forgot the
detail but can be easily found in the article's history log.

He used to have a page on his website, not sure if it's still around,
about what he demands if people wants him to speak. Quite rude.

> In fact, I wouldn't go looking for a dictionary style definition,
> since he used the word "hacker" to convey what he thought a hacker
> was, so his article on "great hackers" would be very relevant:
> http://www.paulgraham.com/gh.html

Paul is a interesting guy. I mean, his lisp achievements and credits
is quite sufficient for me to find him intelligent and interesting.

However, his's essays related to hackers i just find quite
wortheless... not even sufficient enough for me to scan ... as
comparison, i'd rather read text books related to sociology or
psychology.

... many famous people write essays. Philosophers, renowed scientists
of all areas, successful businessman, famous award laureates ...
often, perhaps majority, of such essays are rather riding on fame and
worthless in quality when judged in the long term like decades or
centuries ...

> Those language qualities you listed do seem to be a good measure for a
> good language though.
> It seems to me that Arc has the first 2 qualities but not the third.

i wouldn't say arc is good at all with respect to ease of use or
power.

for ease of use... first of all it uses lisp syntax, and still has
cons business. These 2 immediately disqualifies it for the masses as
easy to use. Even if we take a step back, then there's Scheme lisp, so
in no way arc is easier to use than say Scheme 5.

for power... i doubt if it is in any sense more powerful than say
Scheme lisp or common lisp. In comparison to the profileration of
functional langs like Haskell, Ocaml/f# and perhaps also erlang, Q,
Oz, Mercury, Alice, Mathematica ... the power of arc would be a
laughing stock.

... adding the fact such controversies as using ascii as char set (as
opposed to unicode), using html table as web design, no name space
mechanism (all these i gathered as hearsay or on Wikipedia) ... arc to
me is totally without merit. (NewLisp and Qi, yay!)

see also...
Proliferation of Computing Languages
http://xahlee.org/UnixResource_dir/writ/new_langs.html

Xah
http://xahlee.org/

viper-2

unread,
Aug 25, 2008, 9:47:29 AM8/25/08
to
On Aug 25, 6:16 am, "xah...@gmail.com" <xah...@gmail.com> wrote:
>

> .... It used to also talk about how he supports the iraq war with some


> racist undertone or some remarks he made about blacks ... i forgot the
> detail but can be easily found in the article's history log.
>

You can find Raymond's remarks about blacks here:
http://en.wikiquote.org/wiki/Eric_S._Raymond


| In the U.S., blacks are 12% of the population
| but commit 50% of violent crimes; can
| anyone honestly think this is unconnected
| to the fact that they average 15 points of IQ
| lower than the general population? That
| stupid people are more violent is a fact
| independent of skin color.


--agt

Don Stewart

unread,
Aug 25, 2008, 6:21:21 PM8/25/08
to
On Aug 19, 5:30 pm, Jon Harrop wrote:

> Haskell's success rate at generating widely-used open source code is far
> lower than most other languages:

Your Debian install figures say nothing about "success rates", and do
nothing to compare this rate against "most other languages". Did you
compare against any other language than OCaml? No.

For example, what is the success rate of say, F# at generating widely-
used open source code?

I see nothing to justify your conclusions about the productivity of
*languages in general* based soley on the install figures of a handful
of tools on Debian.

All we can conclude here is that FFTW, a C library, is popular. At a
stretch you might make some conclusions about the effectiveness of the
ocaml-debian packaging team. Any other conclusion is lost in the
noise.

(BTW. this thread is worth it just to see Harrop and Xah Lee
discussing Haskell on a Lisp thread. I do believe this is how baby
trolls are born :)

Jon Harrop

unread,
Aug 26, 2008, 1:17:25 PM8/26/08
to
Don Stewart wrote:
> On Aug 19, 5:30 pm, Jon Harrop wrote:
>> Haskell's success rate at generating widely-used open source code is far
>> lower than most other languages:
>
> Your Debian install figures say nothing about "success rates",

The Debian and Ubuntu popcon results cover billions of software
installations, hundreds of thousands of users from two of the most popular
Linux distributions and tens of thousands of packages. They are undoubtedly
among the most reliable quantitative sources of information for how widely
adopted open source projects have become.

The article I cited contains a thorough analysis based upon these objective
quantifications and it estimates the order of magnitude ratio of the
success rates of OCaml and Haskell for creating widely-used open source
software. The conclusion is that Haskell is an order of magnitude less
successful than OCaml.

> For example, what is the success rate of say, F# at generating widely-
> used open source code?

Unknown: no comparable data are available for F# because it is a proprietary
Microsoft language.

> I see nothing to justify your conclusions about the productivity of
> *languages in general* based soley on the install figures of a handful
> of tools on Debian.

You are misrepresenting both the conclusion and the evidence. I am
disappointed: even Ganesh Sittampalam managed to create a plausible
sounding objection, although his quantifications turned out to be nothing
more than wildly inaccurate guesses.

> All we can conclude here is that FFTW, a C library, is popular.

You can get a lot more out of these data if you analyse them properly.
Moreover, the analysis is quite easy: even a web programmer could do it.

> At a stretch you might make some conclusions about the effectiveness of
> the ocaml-debian packaging team.

On the contrary, the success of projects like FFTW, Unison and MLDonkey had
nothing to do with the OCaml-Debian packaging team.

> Any other conclusion is lost in the noise.

Here are the facts again:

. 221,293 installs of popular OCaml software compared to only 7,830 of
Haskell.

. 235,312 lines of well-tested OCaml code compared to only 27,162 lines of
well-tested Haskell code.

Those are huge differences. How else do you explain them?

> (BTW. this thread is worth it just to see Harrop and Xah Lee
> discussing Haskell on a Lisp thread. I do believe this is how baby
> trolls are born :)

I find it far more enlightening that you would ban me from the Haskell Cafe
mailing list and IRC channel in order to avoid discussion of your own
findings. You must be much less confident in your work than I am in mine.

parnell

unread,
Aug 26, 2008, 4:09:40 PM8/26/08
to

>
> The Debian and Ubuntu popcon results cover billions of software
> installations, hundreds of thousands of users from two of the most popular
> Linux distributions and tens of thousands of packages. They are undoubtedly
> among the most reliable quantitative sources of information for how widely
> adopted open source projects have become.

This years results of the Debian and Ubuntu popularity contests are
based on 74011 submissions. There have never been more than 80,000
submissions in a single year.
This is hardly a comprehensive metric.

>
> The article I cited contains a thorough analysis based upon these objective
> quantifications and it estimates the order of magnitude ratio of the
> success rates of OCaml and Haskell for creating widely-used open source
> software. The conclusion is that Haskell is an order of magnitude less
> successful than OCaml.

The "article" you cite is your same bogus analysis of the debian
package popularity contest, basically it is a thinly veiled plug for
Flying Frog Consultancy.

Jon Harrop

unread,
Aug 26, 2008, 7:18:21 PM8/26/08
to
parnell wrote:
>> The Debian and Ubuntu popcon results cover billions of software
>> installations, hundreds of thousands of users from two of the most
>> popular Linux distributions and tens of thousands of packages. They are
>> undoubtedly among the most reliable quantitative sources of information
>> for how widely adopted open source projects have become.
>
> This years results of the Debian and Ubuntu popularity contests are
> based on 74011 submissions. There have never been more than 80,000
> submissions in a single year.

That is obviously wrong given that the article cited 184,574 installs of
FFTW alone.

> This is hardly a comprehensive metric.

You appear to have neglected the Ubuntu popularity contest that account for
an order of magnitude more people again.

>> The article I cited contains a thorough analysis based upon these
>> objective quantifications and it estimates the order of magnitude ratio
>> of the success rates of OCaml and Haskell for creating widely-used open
>> source software. The conclusion is that Haskell is an order of magnitude
>> less successful than OCaml.
>
> The "article" you cite is your same bogus analysis of the debian
> package popularity contest, basically it is a thinly veiled plug for
> Flying Frog Consultancy.

In other words, you also have no testable objections to the analysis
presented in the article so you are resorting to ad-hominem attacks. I am
not surprised: you clearly do not put your money where your mouth is, as I
do.

Rainer Joswig

unread,
Aug 26, 2008, 7:30:58 PM8/26/08
to
In article <g922ta$20b$1...@aioe.org>, Jon Harrop <j...@ffconsultancy.com>
wrote:

___________________________
/| /| | |
||__|| | Please don't |
/ O O\__ feed |
/ \ the troll |
/ \ \ |
/ _ \ \ ----------------------
/ |\____\ \ ||
/ | | | |\____/ ||
/ \|_|_|/ | __||
/ / \ |____| ||
/ | | /| | --|
| | |// |____ --|
* _ | |_|_|_| | \-/
*-- _--\ _ \ // |
/ _ \\ _ // | /
* / \_ /- | - | |
* ___ c_c_c_C/ \C_c_c_c____________

If you have to post something about Dr. Jon Harrop (or his
sock puppets), then post it here:

http://harrop-highly.blogspot.com/

namekuseijin

unread,
Aug 26, 2008, 10:55:07 PM8/26/08
to
On 26 ago, 20:30, Rainer Joswig <jos...@lisp.de> wrote:
>                             ___________________________
>                    /|  /|  |                          |
>                    ||__||  |       Please don't       |
>                   /   O O\__           feed           |
>                  /          \       the troll         |
>                 /      \     \                        |
>                /   _    \     \ ----------------------
>               /    |\____\     \     ||                
>              /     | | | |\____/     ||                
>             /       \|_|_|/   |    __||                
>            /  /  \            |____| ||                
>           /   |   | /|        |      --|              
>           |   |   |//         |____  --|              
>    * _    |  |_|_|_|          |     \-/                
> *-- _--\ _ \     //           |                        
>   /  _     \\ _ //   |        /                        
> *  /   \_ /- | -     |       |                        
>   *      ___ c_c_c_C/ \C_c_c_c____________            
>
> If you have to post something about Dr. Jon Harrop (or his
> sock puppets), then post it here:
>
>  http://harrop-highly.blogspot.com/

huahuhuhauhuhuahua

Oh, man. I think Xah and Louis Savant deserve something like
that... :)

parnell

unread,
Aug 27, 2008, 9:05:52 AM8/27/08
to

>You appear to have neglected the Ubuntu popularity contest that account for
>an order of magnitude more people again.
>

True, Ubuntu has 683367 submissions. The data gets murkier once you
pick through it for instance the FFTW data that you cite
vote old recent no files
Package: fftw3 139 9884 27 165142

Where
vote - number of people who use this package regularly;
old - number of people who installed, but don't use this package
regularly;
recent - number of people who upgraded this package recently;
no-files - number of people whose entry didn't contain enough
information
(atime and ctime were 0).

So although we have ~185,000 installs of FFTW only 139 of those
installs are "used".
Surly some of the "no files" set must be used so if we use the ratio
of vote to old we come up with 2,322 more that most likely should be
in the "vote" column.

You analysis of the data was not in any way thorough, your portrayal
of the data and the conclusions you draw about haskell on this list
and in your article are misleading.

Rainer Joswig

unread,
Aug 27, 2008, 9:29:46 AM8/27/08
to
In article
<c8f077e9-0fc9-4ee1...@y21g2000hsf.googlegroups.com>,
parnell <parnel...@ronin-capital.com> wrote:

Last I looked FFTW was a C library. Has that changed?

--
http://lispm.dyndns.org/

parnell

unread,
Aug 27, 2008, 11:24:52 AM8/27/08
to
On Aug 27, 8:29 am, Rainer Joswig <jos...@lisp.de> wrote:
> In article
> <c8f077e9-0fc9-4ee1-9bba-ce896af24...@y21g2000hsf.googlegroups.com>,

It is an excellent C library generated by OCaml code.

Here is an excerpt from their FAQ:

Question 2.7. Which language is FFTW written in?
FFTW is written in ANSI C. Most of the code, however, was
automatically generated by a program called genfft, written in the
Objective Caml dialect of ML. You do not need to know ML or to have an
Objective Caml compiler in order to use FFTW.

http://www.fftw.org/

Jon Harrop

unread,
Aug 27, 2008, 12:23:54 PM8/27/08
to
parnell wrote:
>>You appear to have neglected the Ubuntu popularity contest that account
>>for an order of magnitude more people again.
>>
>
> True, Ubuntu has 683367 submissions. The data gets murkier once you
> pick through it for instance the FFTW data that you cite
> vote old recent no files
> Package: fftw3 139 9884 27 165142
>
> Where
> vote - number of people who use this package regularly;
> old - number of people who installed, but don't use this package
> regularly;
> recent - number of people who upgraded this package recently;
> no-files - number of people whose entry didn't contain enough
> information
> (atime and ctime were 0).
>
> So although we have ~185,000 installs of FFTW only 139 of those
> installs are "used".

The fftw3 package transitioned to libfftw3-3 a year ago:

http://people.debian.org/~igloo/popcon-graphs/index.php?packages=fftw3%2C
libfftw3-3&show_installed=on&want_ticks=on&from_date=&to_date=&hlght_date
=&date_fmt=%25Y-%25m&beenhere=1

So you have analysed data about the wrong package.

> Surly some of the "no files" set must be used so if we use the ratio
> of vote to old we come up with 2,322 more that most likely should be
> in the "vote" column.

The old package is now largely unused now that the transition is complete,
yes.

> You analysis of the data was not in any way thorough, your portrayal of
> the data and the conclusions you draw about haskell on this list and in
> your article are misleading.

Let's just review the correct data from Ubuntu:

rank name inst vote old recent no-files
1735 libfftw3-3 104150 9084 77412 8288 9366
7652 darcs 2998 271 2634 92 1

As you can see, the "recent" column shows an even larger discrepancy: FFTW
has two orders of magnitude more recent installs than Darcs (8,288 vs 92).

Please do continue trying to disprove my findings or try to build a
similarly objective and statistically meaningful study that contracts these
results. I have actually tried to do this myself but I am only finding more
and more data that substantiate my original conclusion that Haskell is not
yet a success in this context.

For example, MLDonkey alone is still seeing tens of thousands of downloads
every month from SourceForge:

http://sourceforge.net/project/stats/detail.php?group_id=156414&
ugn=mldonkey&type=prdownload&mode=12months&package_id=0

I cannot find any software written in Haskell that gets within an order of
magnitude of that.

xah...@gmail.com

unread,
Aug 27, 2008, 2:25:35 PM8/27/08
to
hi Jon Harrop,

[ “Haskell's virginity” by Jon Harrop
http://flyingfrogblog.blogspot.com/2008/08/haskells-virginity.html
(a report on OCaml and Haskell use in linux)
]

First, i like to thank you for the informative study on particular
aspect of OCaml and Haskell popularity. I think it is informative, and
the effort of your report in to some degree non-trivial.

With that said, i do believe your opinion are often biased and tends
peddle your products and website about OCaml.

In particular, i don't think the conclusion you made, about how OCaml
is one order of magnitude more use in the industry, being valid.

For example, many commercial use of languages are not public. As a
example, Wolfram Research, the maker of Mathematica, sells more
Mathematica than any lisp companies combined.
This can be gathered from company size and financial records. However,
if you go by your methods, such as polling stats from linux distros,
or other means of checking stats among open source communities, you
won't find any indication of this.

Granted, your study is specifically narrowed to OpenSource project
queries. But there is still a fact about commercial, non-public use,
which often are far more serious and important. Open Source projects
are typically just happensances of some joe hacker's enthus about a
lang, and open source products's audience is again often not with any
serious considerations.

For example, your report contains FFTW, Unison, Darcs. Unison is a bi-
way file syncing tool, which i personally use daily. Darcs is a
revision system for source code. FFTW, as i learned, is a lib for
fourier transform. These tools, basically are results of some joe
hacker who happens to love or use a particular lang. Their users,
basically use them because there isn't others around (in the case of
Darcs, because it uses a lang they like). The other tools listed in
your report: MLDonkey, Free Tennis, Planets, HPodder, LEdit, Hevea,
Polygen, i haven't checked what they are, but i think you'd agree they
basically fit into my describtion about FFTW, Unison, Darcs above.
Namely, some hobby programers happened to create a software that does
X well above others, thus other hobby programers who happens to need
it, use them.

(the above is quickly written, i'm sure there are many flaws to pick
as i phrased it, but i think you get the idea)

In your report, you made a sort of conclusion as this:

«This led us to revisit the subject of Haskell's popularity and track
record. We had reviewed Haskell last year in order to ascertain its
commercial viability when we were looking to diversify into other
functional languages. Our preliminary results suggested that Haskell
was one of the most suitable functional languages but this recent news
has brought that into question.»

That remark is slightly off. You phrased “Haskell's popularity and
track record”, but note that your stat is just a measure of some pop
tools among linux.
It is a exageration to say that it's some sort of “track record” of
haskell like a damnatation. Haskell for example, has strong academic
background. So, a fair “track record” would also measure its academic
use.
You also used the word “popularity”. Again, popularity is a fuzzy
word, but in general it also connate to mindshare. Between Haskell and
OCaml, i doubt more programer heard or knows about OCaml than Haskell,
and as far as mindshare goes, both are dwarfed by Lisp.

Then, you mentioned “commercial viability”. Again, what tools happened
to be cooked up by idle tech geekers in particular lang does not have
much to do with “commercial viability”.

So, although i do find your report meaningful and has some force in
indicating how OCaml is more used in terms of number of solid tools
among idle programers, but i don't agree with your seemingly overboard
conclusion that OCaml is actually some order of magnitude more used or
popular than Haskell for serious projects.

This is a pure guess: i think any validity of OCaml's popularity in
open source industrial use than Haskell is probably because OCaml has
more industrial background than Haskell, given the lang's histories.

------------------

On a tangent, many here accuse you being a troll. As i mentioned, i do
find your posts tends to be divisive and selling your website, but
considered on the whole of newsgroup's posts in particular by many
regulars, i think your posting behavior overall are in any sense
particularly bad.

Recently, i answered to a post used your name and your photo in
group.goople.com's profile. When i answered that post, i thought it
was from you. Thanks for letting me know otherwise.

(See:

Fake Jon Harrop post
http://groups.google.com/group/comp.lang.lisp/msg/43f971ff443e2ce5

Fake Jon Harrop profile
http://groups.google.com/groups/profile?enc_user=Cv3pMh0AAACHpIZ29S1AglWPUrDEZmMqdL-C5pPggpE8SFMrQg3Ptg
)

I think many tech geekers on newsgroups are just ignorant fuckfaces.
The guy who fake'd your identity, to the degree of using your photo in
his fake profile, perhaps thinks he's being humorous.

Xah
http://xahlee.org/

On Aug 27, 9:23 am, Jon Harrop <j...@ffconsultancy.com> wrote:
> parnell wrote:
> >>You appear to have neglected the Ubuntu popularity contest that account
> >>for an order of magnitude more people again.
>
> > True, Ubuntu has 683367 submissions. The data gets murkier once you
> > pick through it for instance the FFTW data that you cite
> > vote old recent no files
> > Package: fftw3 139 9884 27 165142
>
> > Where
> > vote - number of people who use this package regularly;
> > old - number of people who installed, but don't use this package
> > regularly;
> > recent - number of people who upgraded this package recently;
> > no-files - number of people whose entry didn't contain enough
> > information
> > (atime and ctime were 0).
>
> > So although we have ~185,000 installs of FFTW only 139 of those
> > installs are "used".
>
> The fftw3 package transitioned to libfftw3-3 a year ago:
>

> http://people.debian.org/~igloo/popcon-graphs/index.php?packages=fftw...

parnell

unread,
Aug 27, 2008, 2:50:56 PM8/27/08
to
On Aug 27, 11:23 am, Jon Harrop <j...@ffconsultancy.com> wrote:
> parnell wrote:
> >>You appear to have neglected the Ubuntu popularity contest that account
> >>for an order of magnitude more people again.
>
> > True, Ubuntu has 683367 submissions.  The data gets murkier once you
> > pick through it for instance the FFTW data that you cite
> >                    vote  old   recent     no files
> > Package: fftw3     139  9884    27        165142
>
> > Where
> > vote - number of people who use this package regularly;
> > old - number of people who installed, but don't use this package
> > regularly;
> > recent - number of people who upgraded this package recently;
> > no-files - number of people whose entry didn't contain enough
> > information
> > (atime and ctime were 0).
>
> > So although we have ~185,000 installs of FFTW only 139 of those
> > installs are "used".
>
> The fftw3 package transitioned to libfftw3-3 a year ago:
>
> http://people.debian.org/~igloo/popcon-graphs/index.php?packages=fftw...

I don't need to you just proved my point.

Your claim of "221,293 installs of popular OCaml software " is
misleading at best given that there are only 10,911 installs of FFTW
out of the 184,574, that are actually used.

Without FFTW it is not looking good for either Haskell or OCaml on the
Unbuntu side:
vote old recent no-files
Package: mldonkey 7 56 2 1
Package: mldonkey-gui 262 4498 124 0
Package: mldonkey-server 830 5130 118 0
Package: unison 930 9214 277 7

Package: darcs 271 2634 92 1
Package: hpodder 157 2913 54 0

Sure OCaml is slightly ahead but your claim was that "OCaml is 30×
more successful at creating widely-used open source software" does not
hold up.

I agree with the claim:
FFTW is 10x more successful than any other open source OCaml or
Haskell software package in the Debian/Unbuntu popcon.

Jon Harrop

unread,
Aug 27, 2008, 4:14:51 PM8/27/08
to
parnell wrote:
> On Aug 27, 11:23 am, Jon Harrop <j...@ffconsultancy.com> wrote:
>> Please do continue trying to disprove my findings or try to build a
>> similarly objective and statistically meaningful study that contracts
>> these results. I have actually tried to do this myself but I am only
>> finding more and more data that substantiate my original conclusion that
>> Haskell is not yet a success in this context.
>> ...

>
> I don't need to you just proved my point.
>
> Your claim of "221,293 installs of popular OCaml software " is
> misleading at best given that there are only 10,911 installs of FFTW
> out of the 184,574, that are actually used.

I made the same mistake of trying to analyse the "recent" column but any
analysis of it is fraught with problems because it is strongly dependent
upon so many irrelevant variables. That data refers to the number of users
who upgraded a package within the past month. If you trend the data it
oscillates wildly and clearly cannot be proportional to the current number
of users (which would be a much smoother function) as one might have
expected:

http://people.debian.org/~igloo/popcon-graphs/index.php?packages=unison-gtk
%2Cdarcs&show_recent=on&want_legend=on&from_date=&to_date=&hlght_date=&
date_fmt=%25Y-%25m&beenhere=1

These wild variations are due to new package releases so this does not
reflect the number of current users at all.

One could argue that the maxima in this trend may be a more accurate
reflection of the current number of users but I believe even that is very
erroneous because of the 1 month window. For example, we only upgrade every
6-12 months.

So we cannot reasonably draw any relevant conclusions from this data, at
least not for Ubuntu where such trend data is not even available (AFAIK).

> Without FFTW it is not looking good for either Haskell or OCaml on the
> Unbuntu side:
> vote old recent no-files
> Package: mldonkey 7 56 2 1
> Package: mldonkey-gui 262 4498 124 0
> Package: mldonkey-server 830 5130 118 0
> Package: unison 930 9214 277 7

Ubuntu:

1735 libfftw3-3 104150 9084 77412 8288 9366

4355 unison-gtk 10458 1380 8662 412 4
6242 mldonkey-gui 4817 264 4423 130 0


7652 darcs 2998 271 2634 92 1

7045 freetennis 3629 226 3293 110 0
6928 planets 3786 184 3511 90 1
7549 hpodder 3080 148 2870 62 0
9733 ledit 1686 106 1505 75 0
8616 hevea 2320 127 2149 44 0
8661 polygen 2289 111 2122 55 1

Debian:

1702 libfftw3-3 9449 1827 3550 2032 2040
3206 unison 2408 651 1609 148 0
4274 mldonkey-server 1305 705 527 72 1
4186 darcs 1367 240 701 426 0
10206 freetennis 250 31 189 30 0
9794 planets 271 31 187 53 0
8084 hpodder 385 144 214 27 0
4791 ledit 1037 142 758 137 0
7046 hevea 502 84 386 32 0
8292 polygen 368 68 273 27 0

> Package: darcs 271 2634 92 1
> Package: hpodder 157 2913 54 0
>
> Sure OCaml is slightly ahead but your claim was that "OCaml is 30×
> more successful at creating widely-used open source software" does not
> hold up.

Due to the aforementioned problems those data are not an accurate reflection
of anything interesting and the conclusion stands.

> I agree with the claim:
> FFTW is 10x more successful than any other open source OCaml or
> Haskell software package in the Debian/Unbuntu popcon.

You are talking about binary packages. The core of the FFTW source code is,
of course, written in OCaml. Moreover, we can quantify the number of source
code installs, which certainly does explicitly include the OCaml code. For
Debian alone, we find:

847 fftw3 15976 2305 5802 2180 5689

So the OCaml source code to FFTW is being downloaded 2,180 times per month
by Debian users alone.

Jon Harrop

unread,
Aug 27, 2008, 4:20:51 PM8/27/08
to
xah...@gmail.com wrote:
> With that said, i do believe your opinion are often biased and tends
> peddle your products and website about OCaml.

I certainly do peddle our products whenever possible. However, the data I
presented are verifiable and I would encourage anyone interested to repeat
the analysis themselves. There are many caveats in doing so but I think any
reasonable study will come to the same conclusion because the data are so
clear in this case.

> In particular, i don't think the conclusion you made, about how OCaml
> is one order of magnitude more use in the industry, being valid.

That was not my conclusion! I was careful to say that this refers only to
open source software (having examined two major Linux distros). I added
that this undermines my confidence in using Haskell commercially but that
is a personal opinion and not a justifiable conclusion.

> For example, many commercial use of languages are not public. As a
> example, Wolfram Research, the maker of Mathematica, sells more
> Mathematica than any lisp companies combined.
> This can be gathered from company size and financial records. However,
> if you go by your methods, such as polling stats from linux distros,
> or other means of checking stats among open source communities, you
> won't find any indication of this.

Interestingly, Wolfram Research have used OCaml commercially as well.

> Granted, your study is specifically narrowed to OpenSource project
> queries. But there is still a fact about commercial, non-public use,
> which often are far more serious and important. Open Source projects
> are typically just happensances of some joe hacker's enthus about a
> lang, and open source products's audience is again often not with any
> serious considerations.
>
> For example, your report contains FFTW, Unison, Darcs. Unison is a bi-
> way file syncing tool, which i personally use daily. Darcs is a
> revision system for source code. FFTW, as i learned, is a lib for
> fourier transform. These tools, basically are results of some joe
> hacker who happens to love or use a particular lang. Their users,
> basically use them because there isn't others around (in the case of
> Darcs, because it uses a lang they like). The other tools listed in
> your report: MLDonkey, Free Tennis, Planets, HPodder, LEdit, Hevea,
> Polygen, i haven't checked what they are, but i think you'd agree they
> basically fit into my describtion about FFTW, Unison, Darcs above.

Some do but FFTW certainly does not. FFTW is the result of decades of work
by the world's foremost experts on the subject who received prestigious
awards for their ground breaking work. FFTW is such a tremendous
achievement that many commercial users, including The MathWorks for MATLAB,
have paid to incorporate FFTW into their commercial products under license
from MIT.

MLDonkey has been one of the most prolific file sharing utilities ever, and
is believed to have had ~250,000 users at its peak. LEdit is a widely used
tool for command line editing. Hevea is a widely used LaTeX to HTML
translator.

So some of these programs are fun toys (like Planets) but many are really
serious tools.

> «This led us to revisit the subject of Haskell's popularity and track
> record. We had reviewed Haskell last year in order to ascertain its
> commercial viability when we were looking to diversify into other
> functional languages. Our preliminary results suggested that Haskell
> was one of the most suitable functional languages but this recent news
> has brought that into question.»
>

> That remark is slightly off. You phrased ?Haskell's popularity and
> track record?, but note that your stat is just a measure of some pop
> tools among linux.
> It is a exageration to say that it's some sort of ?track record? of


> haskell like a damnatation. Haskell for example, has strong academic
> background.

While the vast majority of Haskell's use appears to be academic, I am not
even sure that it is fair to say that Haskell has a "strong academic
background".

> So, a fair ?track record? would also measure its academic
> use.

That is a question of perspective and I am interested in commercial
applications of these languages, of course.

> You also used the word ?popularity?. Again, popularity is a fuzzy


> word, but in general it also connate to mindshare. Between Haskell and
> OCaml, i doubt more programer heard or knows about OCaml than Haskell,

I agree.

> and as far as mindshare goes, both are dwarfed by Lisp.

I do not believe that.

> Then, you mentioned ?commercial viability?. Again, what tools happened


> to be cooked up by idle tech geekers in particular lang does not have

> much to do with ?commercial viability?.

I disagree. The direct commercialization of FFTW is the most obvious counter
example but many of the other tools have direct commercial counterparts.

> So, although i do find your report meaningful and has some force in
> indicating how OCaml is more used in terms of number of solid tools
> among idle programers, but i don't agree with your seemingly overboard
> conclusion that OCaml is actually some order of magnitude more used or
> popular than Haskell for serious projects.

The data speak for themselves, IMHO.

> This is a pure guess: i think any validity of OCaml's popularity in
> open source industrial use than Haskell is probably because OCaml has
> more industrial background than Haskell, given the lang's histories.

I certainly find the OCaml community to be very grounded in practicality and
the Haskell community to be intolerably theoretical.

parnell

unread,
Aug 27, 2008, 4:59:22 PM8/27/08
to

> > I don't need to you just proved my point.
>
> > Your claim of "221,293 installs of popular OCaml software " is
> > misleading at best given that there are only 10,911 installs of FFTW
> > out of the 184,574, that are actually used.
>
> I made the same mistake of trying to analyse the "recent" column but any
> analysis of it is fraught with problems because it is strongly dependent
> upon so many irrelevant variables. That data refers to the number of users
> who upgraded a package within the past month. If you trend the data it
> oscillates wildly and clearly cannot be proportional to the current number
> of users (which would be a much smoother function) as one might have
> expected:
>
> http://people.debian.org/~igloo/popcon-graphs/index.php?packages=unis...

> %2Cdarcs&show_recent=on&want_legend=on&from_date=&to_date=&hlght_date=&
> date_fmt=%25Y-%25m&beenhere=1
>
> These wild variations are due to new package releases so this does not
> reflect the number of current users at all.
>
> One could argue that the maxima in this trend may be a more accurate
> reflection of the current number of users but I believe even that is very
> erroneous because of the 1 month window. For example, we only upgrade every
> 6-12 months.
>
> So we cannot reasonably draw any relevant conclusions from this data, at
> least not for Ubuntu where such trend data is not even available (AFAIK).
>

Yes we finally agree.

> Due to the aforementioned problems those data are not an accurate reflection
> of anything interesting and the conclusion stands.

Conclusion stands, I don't think so. Remember what you just said: "we
cannot reasonably draw any relevant conclusions from this data".

If you examine the graph of the old vs the recent you see that they
are nearly the inverse of each other and as recent jumps old falls.
It would seem to be that these are caused by people who do not
otherwise use the packages updating the package and then as the
package remains unused it moves from the recent into the old category.

http://people.debian.org/~igloo/popcon-graphs/index.php?packages=unis...%2Cdarcs&show_installed=on&show_vote=on&show_old=on&show_recent=on&want_legend=on&from_date=&to_date=&hlght_date=&date_fmt=%25Y-%25m&beenhere=1

The voted installs seem to trend right along with the installs, so if
they are not "an accurate reflection of anything interesting" then
neither are the total installs in which case we are in complete
agreement.

> > I agree with the claim:
> > FFTW is 10x more successful than any other open source OCaml or
> > Haskell software package in the Debian/Unbuntu popcon.
>
> You are talking about binary packages. The core of the FFTW source code is,
> of course, written in OCaml. Moreover, we can quantify the number of source
> code installs, which certainly does explicitly include the OCaml code. For
> Debian alone, we find:
>
> 847   fftw3                          15976  2305  5802  2180  5689                              
>
> So the OCaml source code to FFTW is being downloaded 2,180 times per month
> by Debian users alone.

Jon I agree 100% that FFTW is an "OCaml" package I did not mean to
imply otherwise. My point is that it is 10 times more popular than
any of the other packages that you included in your data. The other
OCaml and the Haskell packages are in the same ball park as far as
total installs or "votes" are concerned. So what one can conclude
from this is that the language that one chooses to create an open
source project in does not seem to matter nearly as much as what that
package will do (or really to be more accurate some unknown factor
that is not captured in the data).

Jon Harrop

unread,
Aug 27, 2008, 7:33:56 PM8/27/08
to
parnell wrote:
>> So we cannot reasonably draw any relevant conclusions from this data, at
>> least not for Ubuntu where such trend data is not even available (AFAIK).
>
> Yes we finally agree.
>
>> Due to the aforementioned problems those data are not an accurate
>> reflection of anything interesting and the conclusion stands.
>
> Conclusion stands, I don't think so. Remember what you just said: "we
> cannot reasonably draw any relevant conclusions from this data".

Note that I was talking about the "recent" data that you analyzed and
not the "installed" data that was analyzed in the article that I cited.

> If you examine the graph of the old vs the recent you see that they
> are nearly the inverse of each other and as recent jumps old falls.

Yes.

> It would seem to be that these are caused by people who do not
> otherwise use the packages updating the package and then as the
> package remains unused it moves from the recent into the old category.
>
> http://people.debian.org/~igloo/popcon-graphs/index.php?packages=unis..

%2Cdarcs&show_installed=on&show_vote=on&show_old=on&show_recent=on&want_legend=on&from_date=&to_date=&hlght_date=&date_fmt=%25Y-%25m&beenhere=1
>
> The voted installs seem to trend right along with the installs,

I disagree. Indeed, over the past year the "voted" has fallen whereas
the "installs" have risen for Darcs according to the data you just cited.

From the data you cite, large fluctuations correlate between the "old"
and "recent" data and the "vote" column to a lesser degree but
the "installed" column (that I analyzed) does not exhibit these
fluctuations at all.

> so if
> they are not "an accurate reflection of anything interesting" then
> neither are the total installs in which case we are in complete
> agreement.

Had your previous assertion been true then I would agree but I cannot see
that this is the case. The "installed" data that I analyzed does not trend
with the "vote" data and does not correlate with the fluctuations in
the "recent" and "old" data. So this source of error did not affect my
analysis.

>> > I agree with the claim:
>> > FFTW is 10x more successful than any other open source OCaml or
>> > Haskell software package in the Debian/Unbuntu popcon.
>>
>> You are talking about binary packages. The core of the FFTW source code
>> is, of course, written in OCaml. Moreover, we can quantify the number of
>> source code installs, which certainly does explicitly include the OCaml
>> code. For Debian alone, we find:
>>
>> 847   fftw3                          15976  2305  5802  2180  5689
>>
>> So the OCaml source code to FFTW is being downloaded 2,180 times per
>> month by Debian users alone.
>
> Jon I agree 100% that FFTW is an "OCaml" package I did not mean to
> imply otherwise. My point is that it is 10 times more popular than
> any of the other packages that you included in your data.

Yes.

> The other
> OCaml and the Haskell packages are in the same ball park as far as
> total installs or "votes" are concerned.

Unison also has 3x more installs than anything written in Haskell but my
original point was also that there are many more popular projects written
in OCaml than Haskell. Indeed, even excluding FFTW, open source OCaml
software on Debian+Ubuntu still has 7x more users than Haskell and that (to
me) is a very significant discrepancy. Moreover, it is an underestimate
because we have not counted several other popular OCaml projects like
MTASC, ADVI, HaXe and so on.

> So what one can conclude from this is that the language that one chooses
> to create an open source project in does not seem to matter nearly as much
> as what that package will do (or really to be more accurate some unknown
> factor that is not captured in the data).

That is only one of many possible explanations. For example, another
equally-plausible explanation is that Haskell is inherently incapable of
solving these problems in a usable way. I suspect the truth is somewhere in
between.

jos...@corporate-world.lisp.de

unread,
Aug 27, 2008, 7:39:37 PM8/27/08
to

This (popularity of Haskell and OCAML) is completely off-topic in
comp.lang.lisp. Move to comp.lang.functional. You may advertise there.

Andrew Reilly

unread,
Aug 27, 2008, 9:49:06 PM8/27/08
to
On Wed, 27 Aug 2008 21:20:51 +0100, Jon Harrop wrote:

> Some do but FFTW certainly does not. FFTW is the result of decades of
> work by the world's foremost experts on the subject who received
> prestigious awards for their ground breaking work. FFTW is such a
> tremendous achievement that many commercial users, including The
> MathWorks for MATLAB, have paid to incorporate FFTW into their
> commercial products under license from MIT.

FFTW is a superb piece of work, but I think that it's important to note
that its use of OCaml is strictly off-line and not performance critical.
The OCaml is used to generate C code, and is not actually run by anyone
but the FFTW developers. Everyone else just compiles and runs the
generated C code.

So the choice of OCaml comes down to familiarity and convenience for the
developers, rather than run-time performance. Given what it's doing (I
haven't looked at the OCaml code since the very first version came out,
so I've essentially forgotten it) I suspect that the pattern matching
functional nature was much more important than the type safety or
compiled performance. I suppose that Frigo and Johnson have written
about their choice of OCaml somewhere. Doesn't seem to be one on the
FFTW web site though. Skimming some of their papers, it's clearly a good
choice, because the expression simplifiers can be expressed quite neatly,
and matching seems to be used extensively. I suspect that Haskell or
Prolog or even one of the modern schemes (with structures and match)
could have been used just about as well, had the authors been so inclined.

Cheers,

--
Andrew

Nicolas Neuss

unread,
Aug 28, 2008, 4:07:03 AM8/28/08
to
"xah...@gmail.com" <xah...@gmail.com> writes:

> hi Jon Harrop,
> [...]


>
> Recently, i answered to a post used your name and your photo in
> group.goople.com's profile. When i answered that post, i thought it
> was from you. Thanks for letting me know otherwise.
>
> (See:
>
> Fake Jon Harrop post
> http://groups.google.com/group/comp.lang.lisp/msg/43f971ff443e2ce5
>
> Fake Jon Harrop profile
> http://groups.google.com/groups/profile?enc_user=Cv3pMh0AAACHpIZ29S1AglWPUrDEZmMqdL-C5pPggpE8SFMrQg3Ptg
> )

Thanks for reminding me. I enjoyed reading those also a second time.

Nicolas

Jon Harrop

unread,
Aug 28, 2008, 6:39:36 AM8/28/08
to
Andrew Reilly wrote:
> On Wed, 27 Aug 2008 21:20:51 +0100, Jon Harrop wrote:
>> Some do but FFTW certainly does not. FFTW is the result of decades of
>> work by the world's foremost experts on the subject who received
>> prestigious awards for their ground breaking work. FFTW is such a
>> tremendous achievement that many commercial users, including The
>> MathWorks for MATLAB, have paid to incorporate FFTW into their
>> commercial products under license from MIT.
>
> FFTW is a superb piece of work, but I think that it's important to note
> that its use of OCaml is strictly off-line

Yes.

> and not performance critical.

No. OCaml's performance is as important here as it is in any other compiler:
compile time performance is important.

> The OCaml is used to generate C code, and is not actually run by anyone
> but the FFTW developers. Everyone else just compiles and runs the
> generated C code.

On the contrary, FFTW's performance stems from its ability to generate
custom codelets for transform lengths that the user values. Users do this
by running the OCaml code to generate more C. Hence the Debian source
package is downloaded more often than the binary package because users need
the OCaml source code.

> So the choice of OCaml comes down to familiarity and convenience for the
> developers, rather than run-time performance.

I do not believe so.

> Given what it's doing (I
> haven't looked at the OCaml code since the very first version came out,
> so I've essentially forgotten it) I suspect that the pattern matching
> functional nature was much more important than the type safety or
> compiled performance.

On the contrary, generating custom codelets is a very time consuming process
that required days of computation when FFTW was first released. Moreover,
the authors of FFTW would have repeated this process countless times to
obtain their results and perform thorough benchmarking of the run-time.

So OCaml's predictable and excellent performance was unquestionably of
critical importance to this high-profile project.

> I suppose that Frigo and Johnson have written
> about their choice of OCaml somewhere. Doesn't seem to be one on the
> FFTW web site though. Skimming some of their papers, it's clearly a good
> choice, because the expression simplifiers can be expressed quite neatly,
> and matching seems to be used extensively.

Yes.

> I suspect that Haskell or
> Prolog or even one of the modern schemes (with structures and match)
> could have been used just about as well, had the authors been so inclined.

Until there is evidence to support your hypothesis, we know only that OCaml
is capable of this.

parnell

unread,
Aug 28, 2008, 8:05:47 AM8/28/08
to
> Had your previous assertion been true then I would agree but I cannot see
> that this is the case. The "installed" data that I analyzed does not trend
> with the "vote" data and does not correlate with the fluctuations in
> the "recent" and "old" data. So this source of error did not affect my
> analysis.

http://people.debian.org/~igloo/popcon-graphs/index.php?packages=unis..%2Cdarcs&show_installed=on&show_vote=on&want_legend=on&from_date=&to_date=&hlght_date=&date_fmt=%25Y-%