From: ·········@gmail.com
Subject: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135268704.006271.325550@g14g2000cwa.googlegroups.com>
{I posted this to the mailing list, but people who are into
high-performance Lisps might be interested}

My view is that Bigloo's big failing is in MARKETING and the first
impression it makes on someone new to Bigloo, but not necessarily new
to Scheme/Lisp. I know this from first-hand experience and how people
responded to the survey. The problems of the first impression are
easily fixable, although you can't undo years of bad marketing.

Bigloo fails to get these points across (these should be on the front
page somewhere)

1. There are compiled Schemes, and then there are COMPILED Schemes. In
my tests, Bigloo actually beats Stalin handily on code that Stalin's
author had not seen. Stalin does well on the benchmarks included with
it, but overall, its performance seems to be unpredictable, while
Bigloo is consistently very good. I don't claim to have tested every
Lisp in the world, but my impression so far is that Bigloo has no
equal.

2. Bigloo does have a REPL

3. Type declarations are optional, and they are part of the symbol
being declared, not syntax scattered around the code. Macros can see
them, and macros can create them. When I think about it, it's hard to
come up with anything more convenient (And I'm aware of Common Lisp's
approach)


P.S. My lawyer told me to add this disclaimer: if you morally oppose
cross-posting, don't read the above :-) Bigloo is what brought me to
the Scheme camp though. I'm usually sitting on the fence or close to
it, between CL and Scheme.

From: Marco Antoniotti
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135269651.481135.35030@g47g2000cwa.googlegroups.com>
·········@gmail.com wrote:

>
> 3. Type declarations are optional, and they are part of the symbol
> being declared, not syntax scattered around the code. Macros can see
> them, and macros can create them. When I think about it, it's hard to
> come up with anything more convenient (And I'm aware of Common Lisp's
> approach)

This is Bigloo.  It ain't Scheme.  Plus I find the Bigloo style
cluttered and un-lispy.

> P.S. My lawyer told me to add this disclaimer: if you morally oppose
> cross-posting, don't read the above :-) Bigloo is what brought me to
> the Scheme camp though. I'm usually sitting on the fence or close to
> it, between CL and Scheme.

Bigloo brought you over to Bigloo, not Scheme :) .  CL, OTOH, is CL:
this is a crucial distinction.

Cheers
--
Marco
From: ·········@gmail.com
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135270250.422545.74430@g44g2000cwa.googlegroups.com>
Marco Antoniotti wrote:
> ·········@gmail.com wrote:
>
> >
> > 3. Type declarations are optional, and they are part of the symbol
> > being declared, not syntax scattered around the code. Macros can see
> > them, and macros can create them. When I think about it, it's hard to
> > come up with anything more convenient (And I'm aware of Common Lisp's
> > approach)
>
> This is Bigloo.  It ain't Scheme.  Plus I find the Bigloo style
> cluttered and un-lispy.

Or maybe it's more Lispy than CL?

Can compiler macros expand into (declare ...) ?

> Bigloo brought you over to Bigloo, not Scheme :) .

CL has a standard that many implementations almost comply with. Scheme
has a standard that most implementation (inc Bigloo) almost comply
with. No "crucial distinction" here.

Your type declarations in CL won't be very portable either, will they?
From: Marco Antoniotti
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135271020.657428.140190@g14g2000cwa.googlegroups.com>
·········@gmail.com wrote:
> Marco Antoniotti wrote:
> > ·········@gmail.com wrote:
> >
> > >
> > > 3. Type declarations are optional, and they are part of the symbol
> > > being declared, not syntax scattered around the code. Macros can see
> > > them, and macros can create them. When I think about it, it's hard to
> > > come up with anything more convenient (And I'm aware of Common Lisp's
> > > approach)
> >
> > This is Bigloo.  It ain't Scheme.  Plus I find the Bigloo style
> > cluttered and un-lispy.
>
> Or maybe it's more Lispy than CL?
>
> Can compiler macros expand into (declare ...) ?

Compiler macros are not used for that purpose.


>
> > Bigloo brought you over to Bigloo, not Scheme :) .
>
> CL has a standard that many implementations almost comply with. Scheme
> has a standard that most implementation (inc Bigloo) almost comply
> with. No "crucial distinction" here.

Nope.  The relative sizes of the standards are such that the "crucial
distinction" matters.  And my DECLAREs *will* work on any CL.  In CL I
even have a way to portably declare new declare forms to ensure
portability of DECLARE statements.

> Your type declarations in CL won't be very portable either, will they?

They are.  Type declarations in CL are well defined and portable.  This
is already part of the standard.  Bogloo declarations work only in
Bigloo and in "Schemes" that accept that notation.  The guarantee is
much lower in this case.

Then it is true that you can easily have CL programs that are not
portable across implementations, but that is another story altogether.

Cheers
--
Marco
From: ·········@gmail.com
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135273695.172682.287660@g43g2000cwa.googlegroups.com>
Marco Antoniotti wrote:

> > Or maybe it's more Lispy than CL?
> >
> > Can compiler macros expand into (declare ...) ?
>
> Compiler macros are not used for that purpose.

Any macro then. Show me a declare-2 that makes something simpler. Then
we can talk about what's more Lispy.

P.S. I don't care about standard sizes. What I care about is whether I
can run my code on any platform imaginable, whether I'll pay through
the nose to do it, and whether the programs will run fast and be easily
distributable.
From: Marco Antoniotti
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135274195.700530.3290@g14g2000cwa.googlegroups.com>
·········@gmail.com wrote:
> Marco Antoniotti wrote:
>
> > > Or maybe it's more Lispy than CL?
> > >
> > > Can compiler macros expand into (declare ...) ?
> >
> > Compiler macros are not used for that purpose.
>
> Any macro then. Show me a declare-2 that makes something simpler. Then
> we can talk about what's more Lispy.

What do you have in mind?  I cannot come up with any suggestions if you
do not tell us what exactly you have in mind.

> P.S. I don't care about standard sizes. What I care about is whether I
> can run my code on any platform imaginable, whether I'll pay through
> the nose to do it, and whether the programs will run fast and be easily
> distributable.

Nobody told you to care otherwise.  I was pointing out that you are
doing that with Bigloo.  Not Scheme.  If that works for you, then that
works for you. I have no problems with that.

That, however, does not change the fact that the number of programs
that I can write within the CL standard and have them ported to any
platform *and* implementation is definitively larger.

It may be nitpicking to you, but I am a nitpicker :)

Cheers
--
Marco
From: Pascal Costanza
Subject: Re: Why aren't THEY using Bigloo
Date: 
Message-ID: <410bbkF1ct7slU1@individual.net>
·········@gmail.com wrote:

> Can compiler macros expand into (declare ...) ?

Both compiler macros and ordinary macros can expand into

(locally
   (declare ...)
   ...)


Pascal

-- 
My website: http://p-cos.net
Closer to MOP & ContextL:
http://common-lisp.net/project/closer/
From: Förster vom Silberwald
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135332100.130257.45320@z14g2000cwz.googlegroups.com>
·········@gmail.com wrote:

> 1. There are compiled Schemes, and then there are COMPILED Schemes. In
> my tests, Bigloo actually beats Stalin handily on code that Stalin's
> author had not seen. Stalin does well on the benchmarks included with
> it, but overall, its performance seems to be unpredictable, while
> Bigloo is consistently very good. I don't claim to have tested every
> Lisp in the world, but my impression so far is that Bigloo has no
> equal.

I have to sort out your message: can you elaborate a little bit (maybe
in a new thread) and give some concrete examples where Stalin falls
behind. Your remarks seems very interesting to me.

Sir Franics Drake
From: ·········@gmail.com
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135367688.207087.115170@g43g2000cwa.googlegroups.com>
Förster vom Silberwald wrote:
> ·········@gmail.com wrote:
>
> > 1. There are compiled Schemes, and then there are COMPILED Schemes. In
> > my tests, Bigloo actually beats Stalin handily on code that Stalin's
> > author had not seen. Stalin does well on the benchmarks included with
> > it, but overall, its performance seems to be unpredictable, while
> > Bigloo is consistently very good. I don't claim to have tested every
> > Lisp in the world, but my impression so far is that Bigloo has no
> > equal.
>
> I have to sort out your message: can you elaborate a little bit (maybe
> in a new thread) and give some concrete examples where Stalin falls
> behind.

I can, but I don't think it's a good idea. If I just say what I did,
it's just my *vote* (it seems to me that Bigloo may actually be faster
on real code), but if I post examples, it looks as if I'm proposing a
*proof* that Stalin is slower. See the difference?

Even if I spend 2 hours writing about how my example is not "proof" of
relative speed, about selection bias, etc., some USENET asshole will
think he'll look  smart if he paraphrases all that back to me in form
of an accusation.

If you want to have an implementation/language speed comparison with
examples, post your own examples. IF they are interesting, we might
have a discussion about them.
From: David Rush
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135380285.005334.129870@g49g2000cwa.googlegroups.com>
·········@gmail.com wrote:
> Förster vom Silberwald wrote:
> > ·········@gmail.com wrote:
> >
> > > 1. There are compiled Schemes, and then there are COMPILED Schemes. In
> > > my tests, Bigloo actually beats Stalin handily on code that Stalin's
> > > author had not seen. Stalin does well on the benchmarks included with
> > > it, but overall, its performance seems to be unpredictable, while
> > > Bigloo is consistently very good. I don't claim to have tested every
> > > Lisp in the world, but my impression so far is that Bigloo has no
> > > equal.
> >
> > I have to sort out your message: can you elaborate a little bit (maybe
> > in a new thread) and give some concrete examples where Stalin falls
> > behind.
>
> I can, but I don't think it's a good idea.

Well many moons ago I did a fair bit of side-by-side comparison of
Scheme implementations in my quest for serious high-performance for
data mining in 2000-dimensional datasets. I could dig out my results
(although they live somewhere back in the data crypt that is
groups.google) but to summarize: Stalin produces the fastest code of
*anything*, assuming that you write well-typed Scheme code. This is
harder than you might think, and is probably the reason for your
experience with Stalin.

Bigloo was #2 by a factor of at least 3 (it was a decimal order of
magnitude before I started tweaking gcc options) - and Bigloo gets fast
(or at least used to) by making some ugly tradeoffs w/rt RnRS
semantics. And no, I don't really remember them anymore, I just
remember my Bigloo code crashing mysteriously, when every other Scheme
(including Stalin) would run the code to completion - which left me
with grave doubts about Bigloo's commitment to full TCO, which, I might
add, is crucial is you want to program in a truly type-aware idiom.

Gambit and Larceny came in very close to each other for the third place
spot. IIRC, I think Larceny won, and it was my favorite platform for a
long time - up until my Intel CPUs were kicking my Sparc systems' butts
(the Sparcs were not upgraded due to corporate policy). Gambit has
supplanted Larceny, because it's (with appropriate gsc and gcc tweaks)
darn close to as fast as Bigloo and *much* closer to RnRS in crucial
areas like full TCO, numeric compliance &cet.

Given all that, I still love Bigloo, if only because it's a great
example of how C programming *ought* to work. It is also very fast and
it's pretty darn easy to graft C libraries onto it.

As in all such things though, YMMV. I love the amount of choice there
is in Scheme. At one point I had my data-mining codebase building on
five or six different platforms.

david rush
-- 
Scheme ex-geek
From: ·········@gmail.com
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135390338.607381.172650@o13g2000cwo.googlegroups.com>
David Rush wrote:

> Bigloo was #2 by a factor of at least 3 (it was a decimal order of
> magnitude before I started tweaking gcc options) - and Bigloo gets fast
> (or at least used to) by making some ugly tradeoffs w/rt RnRS
> semantics.

Same factor of 3 here, but in favor of Bigloo, on some fixnum-intensive
code with no floating point. And I didn't even supply any
Bigloo-specific type declarations (regular Scheme)

Two tips/opinions: Bigloo is the one that's more "type-aware" (INRIA
and all); use -Obench / -O6 (safe, but slightly slower) to turn the
optimizations on.

P.S. It's possible that I'm not using Stalin right, I just supply -On
argument it demands.

P.P.S. It's also possible that Stalin does better on floating
point-intensive jobs, which I didn't test it on much.
From: David Rush
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135395884.211846.111300@g47g2000cwa.googlegroups.com>
·········@gmail.com wrote:
> Two tips/opinions: Bigloo is the one that's more "type-aware"

Ummm - Bigloo is brain-damaged about types. It (historically, I've been
out of the Bigloop for at least 2 years) simply uses the fastest native
types in a very simple-minded fashion.

Stalin requires you as the programmer to be type-aware and very
consistent in your use of types. Imagine Stalin as being like an SML
compiler where, instead of the compiler throwing your program out as
*wrong*, the performance just degrades to accomodate the necessity for
run-time type disambiguation.

> P.S. It's possible that I'm not using Stalin right, I just supply -On
> argument it demands.

You're not, but it's not a matter of compilation options, it's a matter
of learning to think about your program structure typologically. A
classic example is the ASSOC function which has the type:

        (datum, datum pair list) -> boolean | datum pair

The return type alone guarantees the necessity of run-time type
dispatch getting compiled into your code. Now compare that to  ASSOC-K
(a non-standard function which I have in my standard library):

    (assoc-k tag a-list k-success k-fail):
        (datum, datum pair list, datum pair -> datum, nil -> datum)

which completely eliminates the run-time dispatch involved with the
failure case of ASSOC. Carrying this type-awareness through you can
make sure that ASSOC-K's context *also* receives a monomorphic value,
which eliminates even more type dispatch.

In summary, Stalin makes your code go fast only when it can *prove* the
correctness of the speedup. Bigloo makes your code go fast by doing
nothing. At the end of the day, Stalin can make your code go *faster*
if you program in a type-sensitive way. Some may argue whether or not
this violates the spirit of Scheme, but as far as I'm concerned, all
programs should be striving for a high degree of type coherence.

And I'm not religious about this either. If I was I'd be programming in
SML, but the lesson of SML is still very useful: high levels of
type-coherence tend to promote *correct* programs. It's also bloody
nice that they can be made to go very fast.

david rush
From: ·········@gmail.com
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135396542.059545.326560@g44g2000cwa.googlegroups.com>
David Rush wrote:

> You're not, but it's not a matter of compilation options, it's a matter
> of learning to think about your program structure typologically.

I don't think I need to learn that. I did my share of ML coding. I just
looked in the manual though, and found out that Stalin does not provide
GCC with any compile-time options, and decided to try -copt -O3, and
woah 6x improvement! Hmm...
From: Hermann Jurksch
Subject: Re: Why aren't THEY using Bigloo
Date: 
Message-ID: <9kTQ5uC9v+B@jurksch.focus.ping.de>
········@gmail.com wrote:

> Gambit and Larceny came in very close to each other for the third place
> spot. IIRC,

Did you compare an actual Gambit Beta or Gambit 3.0?

Regards
        Hermann
From: Rob Thorpe
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135448864.994086.230280@g43g2000cwa.googlegroups.com>
David Rush wrote:
> ·········@gmail.com wrote:
> > Förster vom Silberwald wrote:
> > > ·········@gmail.com wrote:
> > >
> > > > 1. There are compiled Schemes, and then there are COMPILED Schemes. In
> > > > my tests, Bigloo actually beats Stalin handily on code that Stalin's
> > > > author had not seen. Stalin does well on the benchmarks included with
> > > > it, but overall, its performance seems to be unpredictable, while
> > > > Bigloo is consistently very good. I don't claim to have tested every
> > > > Lisp in the world, but my impression so far is that Bigloo has no
> > > > equal.
> > >
> > > I have to sort out your message: can you elaborate a little bit (maybe
> > > in a new thread) and give some concrete examples where Stalin falls
> > > behind.
> >
> > I can, but I don't think it's a good idea.
>
> Well many moons ago I did a fair bit of side-by-side comparison of
> Scheme implementations in my quest for serious high-performance for
> data mining in 2000-dimensional datasets. I could dig out my results
> (although they live somewhere back in the data crypt that is
> groups.google) but to summarize: Stalin produces the fastest code of
> *anything*, assuming that you write well-typed Scheme code. This is
> harder than you might think, and is probably the reason for your
> experience with Stalin.
>
> Bigloo was #2 by a factor of at least 3 (it was a decimal order of
> magnitude before I started tweaking gcc options) - and Bigloo gets fast
> (or at least used to) by making some ugly tradeoffs w/rt RnRS
> semantics. And no, I don't really remember them anymore, I just
> remember my Bigloo code crashing mysteriously, when every other Scheme
> (including Stalin) would run the code to completion - which left me
> with grave doubts about Bigloo's commitment to full TCO, which, I might
> add, is crucial is you want to program in a truly type-aware idiom.

Interesting.  Last time I installed Stalin it couldn't even complete
it's own benchmarks.  I couldn't figure out whether the problem was
with Stalin or GCC, but it made it useless to me.

I haven't tried Bigloo yet.
From: ·········@gmail.com
Subject: Re: Why aren't THEY using Bigloo (was: Stalin)
Date: 
Message-ID: <1135466927.935583.218550@o13g2000cwo.googlegroups.com>
Rob Thorpe wrote:

> Interesting.  Last time I installed Stalin it couldn't even complete
> it's own benchmarks.  I couldn't figure out whether the problem was
> with Stalin or GCC, 

The problem is with the shell script