Nexus Programming Language

[William James]

That dates back to Pascal.

Foolish? Seems a bit strong.

There are lots of errors caused by = vs ==. How much time is lost in
that regard? I think an hour of debugging time is worth a whole lot
of :'s.

C:

if (over_run = -1)
self_destruct();

I often arrange my comparisons like

if -1 = over_run

Gary Wright

--

 

[M. Edward (Ed) Borasky]

That dates back to Pascal.

Actually it dates back to Algol. The people who designed it did it for
a reason, but I can't remember what it was. I think it was to remind
people that assignment was not equality, and the purists pronounce

a := b

as "a becomes b".

 

[M. Edward (Ed) Borasky]

I . . . don't think that's really productive at all. =C2=A0Common Lisp st=
ill

has its advantages as a language, even if it's not the LISP many people
wish it could be.

Having learned Lisp as Lisp 1.5, I'm much more inclined to Scheme than
Common Lisp, because Scheme fixed a lot of the warts on Lisp 1.5.
--=20
M. Edward (Ed) Borasky
http://www.linkedin.com/in/edborasky

I've never met a happy clam. In fact, most of them were pretty steamed.

 

[Gregory Brown]

He's harmless. =A0CL (Commode Lord) is so bloated and hideous
that only a religious zealot would use it.

Just to clarify... my question was not meant to be patronizing. My
point is that Pascal would probably benefit more by advocating Common
Lisp in more general forums rather than trying to 'convert' folks who
are interested in Ruby. I don't think your flame-bait has helped
support that point at all. That said, kill-files solve problems like
this much faster than long discussions about Netiquette do.

-greg

 

[Tom Cloyd]

The Nexus (left-to-right) assignment operator '^' is also referred to
as the 'goes to' operator. The choice of symbol is meaningful, you
might think of the '^' character as an arrow meaning the value you
just put on the stack (the left side of the expression) 'goes to' to
the memory location (i.e. variable) on the right-side of the
expression (i.e. 123^x, 123 'goes to' x).

A most fascinating thread, coming from a very distant universe, as I do.

As for this use of "^", it is about as needless as yet another poem
about a flower. Don't we already have one, somewhere? I fully realize
that calculation (computer) languages are not poems, but they ARE
containers for thought, and in that they are brothers/sisters to poems.

I'm with Eleanor in loving the exploration of different ways of
thinking/working with stuff (and in having an appreciation for the
elgance of RPN). A large part of the sheer burst of joy that grabbed me
and threw me into the Ruby world, on the occasion of my fifth look at
the language, was the delight I experienced upon finally understanding
that this language was "working" the notion that everything could be an
object, and have access to methods belonging to the class of which it
was a member. The sheer elegance of this was new to me and is still a
very major delight.

So, I have to wonder, when meeting up with a new language, if maybe I'm
about to hear my first Stravinsky ballet, or perhaps run into something
like Spencer Brown's "Laws of form" (1972). Beauty is found in strange
places. If we're all lucky, the Nexus project will come up with some
we've not seen yet. That would be most excellent, howsoever difficult it
may be to achieve.

Tom

--

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tom Cloyd, MS MA, LMHC - Private practice Psychotherapist
Bellingham, Washington, U.S.A: (360) 920-1226
<< (e-mail address removed) >> (email)
<< TomCloyd.com >> (website)
<< sleightmind.wordpress.com >> (mental health weblog)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 

[Tom Cloyd]

A little history:

1. Polish notation was originally prefix. It was invented by the
Polish logician Lukaciewicz because it removed parentheses, and was
called "Polish" notation because people had trouble spelling and
pronouncing his name. And yes, I looked it up to get it right.

2. That was pretty much that until computers and programming languages
came on the scene. But in the olden days, when every electron was
precious and compactness and efficiency were of the utmost import, it
turned out that *reverse* Polish notation was *slightly* more
efficient. If you look at a parser for algebraic expressions and the
resulting run-time execution engine, you'll see that.

3. Lisp used prefix notation because McCarthy was a disciple of Church
and Church used it. Forth used reverse Polish notation because Chuck
Moore had taken apart the Burroughs compilers and stack architecture
and determined that it was the way to go for maximum compactness and
efficiency.

But the efficiency differences really are negligible these days, and
Lisp / Scheme are much more popular than Forth. Incidentally, the RPL
stands for "Reverse Polish Lisp".

Very interesting Ed. Thanks for the contribution. ~t

--

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tom Cloyd, MS MA, LMHC - Private practice Psychotherapist
Bellingham, Washington, U.S.A: (360) 920-1226
<< (e-mail address removed) >> (email)
<< TomCloyd.com >> (website)
<< sleightmind.wordpress.com >> (mental health weblog)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 

[Ken Bloom]

He's harmless. CL (Commode Lord) is so bloated and hideous that only a
religious zealot would use it.

(Yeah but (He) (uses (strange syntax)))
((he) (just might convince (some newbie) (to program Ruby) (as though
((it) (were (LISP)))))

--Ken

 

[Pascal J. Bourguignon]

Why are you subscribed to ruby-talk if you hate Ruby so much? Is
someone forcing you to use it? And if so, how is that our problem.

If you were using CL (if more people were using CL), and Ruby were not
invented, more bosses would let us use CL as a dynamic language, and
indeed we wouldn't be forced to use Ruby (or worse, perl or python).

Of course, you share the culpability with perl, PHP, Python, Java and
so on.

But I'm mostly justified in thinking this, by the authors of most of
these languages themselves. Some of these authors are just poor chaps
not knowing better, but some other including Java and Ruby knew very
well Lisp, and instead of choosing to help develop and spread lisp,
they voluntarily chosed to create different and inferior languages,
picking only parts of lisp, and grafting over their abortive creation
some monstruous syntax.

The fact that these monstruous syntaxes view good in the eyes of the
unwashed masses, and that the lack of features (when it's not just the
inclusion of misfeatures) is oblivious to the same masses IS NOT an
excuse.

The only result is that Lisp is relegated as just an elegant weapon
from a more civilized time, still mastered only by a few remaining
Jedi.

But there is still hope!

This is perhaps the good that will come from these evils. A lot of
programmers are now exposed on the goodness of dynamic languages, and
they may notice (or if not by themselves, *I* will try to make them
notice in threads like this), that their fad language of the day, is
actually some incomplete subset of Lisp, and then why not use the full
and authentic thing? Common Lisp is this way!


PS: I'm not subscribed to "Ruby-Talk", there's a gateway between this
mail-list and --
__Pascal Bourguignon__

 

[karlvonl]

Actually it dates back to Algol. The people who designed it did it for
a reason, but I can't remember what it was. I think it was to remind
people that assignment was not equality, and the purists pronounce

a := b

as "a becomes b".

If I ever design my own programming language, I'm going to use := for
assignment and == for equality, and let a single = be a syntax error,
just to avoid the whole confusion.

 

[Gregory Brown]

If I ever design my own programming language, I'm going to use :=3D for
assignment and =3D=3D for equality, and let a single =3D be a syntax erro= r,
just to avoid the whole confusion.

Not a bad idea.

-greg

--=20
Technical Blaag at: http://blog.majesticseacreature.com
Non-tech stuff at: http://metametta.blogspot.com
"Ruby Best Practices" Book now in O'Reilly Roughcuts:
http://rubybestpractices.com

 

[Glen F. Pankow]

...


If you were using CL (if more people were using CL), and Ruby were not
invented, more bosses would let us use CL as a dynamic language, and
indeed we wouldn't be forced to use Ruby (or worse, perl or python).

What perfidy! Won't someone loosen your chains?

I bet your boss won't let you throw in lots of parentheses in your
Perl code, too.

Of course, you share the culpability with perl, PHP, Python, Java and
so on.

Oh, the humanity!

But I'm mostly justified in thinking this, by the authors of most of
these languages themselves. Some of these authors are just poor chaps
not knowing better, but some other including Java and Ruby knew very
well Lisp, and instead of choosing to help develop and spread lisp,
they voluntarily chosed to create different and inferior languages,
picking only parts of lisp, and grafting over their abortive creation
some monstruous syntax.

I know what you mean. I can't understand why people choose to use
such inferior and wimpy regular expression engines when they could
be experiencing the full power of snobol4 pattern matching.

The fact that these monstruous syntaxes view good in the eyes of the
unwashed masses, and that the lack of features (when it's not just the
inclusion of misfeatures) is oblivious to the same masses IS NOT an
excuse.

Yes, it's all bread and circuses to us. The world's morals have
truly been weakened by a language that deigns to make users happy!

The only result is that Lisp is relegated as just an elegant weapon
from a more civilized time, still mastered only by a few remaining
Jedi.

And you consider yourself one such Jedi? I wonder. I sense much
fear in you, young one.

Every once in a while you should raise the blast shield and look
around. Even a Jedi will use a Perl blaster when he needs to.

But there is still hope!

So you're the one prophesied to bring balance to the Language Force.
Great!

This is perhaps the good that will come from these evils. A lot of
programmers are now exposed on the goodness of dynamic languages, and
they may notice (or if not by themselves, *I* will try to make them
notice in threads like this), that their fad language of the day, is
actually some incomplete subset of Lisp, and then why not use the full
and authentic thing? Common Lisp is this way!

Impressive, young Skyparenthesizer. And here I thought Darth Java
had won the Clone/Dup/Bloat War.

You will try to make us notice? There is no 'try'. You will find
that leads only to the Dark Side.

Isn't there a better way? Maybe you can do for CL what others have
done for Java and .Net? Were you to do that, you'd have more fans
than parentheses.

 

[M. Edward (Ed) Borasky]

McCarthy was really ahead of his time. =C2=A0Even Common Lisp and Scheme
haven't caught up with his vision.

1. Nobody has *ever* caught up with Chuck Moore -- not even he
himself. He's still tweaking Forth, even though his disciples
standardized it long ago and are in a second round of standards
negotiation. For Chuck's view, see http://www.intellasys.net/.
Warning: here there be dragons, but not of the Dragon Book.

2. Lisp 1 and 1.5 were (elegant) hacks for the IBM 704 and its close
descendants. As such, they're very much as elegant as the early Scheme
interpreters. In one of his papers, McCarthy covers the transition
from his 1960 paper to the physical implementation in another paper.
I'm pretty sure it's on the web, but I don't recall where. It *should*
have been reprinted in "Beautiful Code".
--=20
M. Edward (Ed) Borasky
http://www.linkedin.com/in/edborasky

I've never met a happy clam. In fact, most of them were pretty steamed.

 

[Tony Arcieri]

[Note: parts of this message were removed to make it a legal post.]

On Tue, Feb 24, 2009 at 9:14 AM, Pascal J. Bourguignon <

If you were using CL (if more people were using CL), and Ruby were not
invented, more bosses would let us use CL as a dynamic language, and
indeed we wouldn't be forced to use Ruby (or worse, perl or python).

Of course, you share the culpability with perl, PHP, Python, Java and
so on.

So your argument is Common Lisp would win by default if it were the only
game in town? That's not exactly a confidence boosting argument.

But I'm mostly justified in thinking this, by the authors of most of

these languages themselves. Some of these authors are just poor chaps
not knowing better, but some other including Java and Ruby knew very
well Lisp, and instead of choosing to help develop and spread lisp,
they voluntarily chosed to create different and inferior languages,
picking only parts of lisp, and grafting over their abortive creation
some monstruous syntax.

Guy Steele, famous for his "drag them halfway to Lisp" quote about Java,
also spent his time making a better Lisp... in his case Scheme.

But this further demonstrates their pragmatism: since it's clear that Lisps
will not see widespread popularity, the next best thing is to look to Lisp
for good ideas and use those in the creation of new languages.

That's exactly what Matz did with Ruby.

The fact that these monstruous syntaxes view good in the eyes of the

unwashed masses

The quality of a grammar isn't not inversely proportional to its size, and
indeed despite the complexity of the Ruby grammar people find it not only
easy to read, but easy to transform.

You may wish to place emphasis on the latter as Lisp's homoiconicity makes
it easier to conceptualize things like macros, but I prefer to place
emphasis on the former as I spend much more time reading code than
transforming it.

Your "unwashed masses" find it easier to read the code of languages with
complex grammars than they do to read Lisp. While you seem to attribute
this to some failing on their part, I'd attribute it to Lisp's homoiconicity
leading to an excess of tokens, making the language syntactically noisy.
Perhaps the "unwashed masses" simply prefer their languages use a more
complex grammar to eliminate some of that syntactic noise.

This is perhaps the good that will come from these evils. A lot of

programmers are now exposed on the goodness of dynamic languages, and
they may notice (or if not by themselves, *I* will try to make them
notice in threads like this), that their fad language of the day, is
actually some incomplete subset of Lisp, and then why not use the full
and authentic thing? Common Lisp is this way!

On the contrary, I think programmers who decide to learn a Lisp and try out
CL as their first are far more likely to be turned off to Lisp in general,
as opposed to those who try saner Lisps like Scheme. That was certainly the
case with myself, and I didn't really come to like Lisp until I tried out
Scheme.

I think the failure of Lisp to gain widespread popularity can largely be
attributed to Common Lisp itself.

 

[David Masover]

If you were using CL (if more people were using CL), and Ruby were not
invented, more bosses would let us use CL as a dynamic language,

No one can know that. For all you know, if Ruby were not invented, we
would all be using Bash.

It's also not an argument of superiority -- if C was not invented, more
bosses would let us use assembly. You could argue that higher-level
languages were an inevitability -- and I would similarly argue that a
more readable syntax (like Ruby) was inevitable.

Of course, you could always go try to find a job with Paul Graham, or
found a startup of Lisp people. There's no need to force everyone to use
the same language, when you can always work in whatever language you want.

The fact that these monstruous syntaxes view good in the eyes of the
unwashed masses, and that the lack of features (when it's not just the
inclusion of misfeatures) is oblivious to the same masses IS NOT an
excuse.

What you're trying to argue is that everyone else in the world is wrong,
and you are right.

Extraordinary claims require extraordinary proof, and you haven't
provided any.

The fact that many people prefer this syntax, even when exposed to Lisp
syntax, should tell you something about the value of each. And that's
even before you consider that the purpose of syntax is communication.
Any syntax that is hard to understand has failed at its purpose.

PS: I'm not subscribed to "Ruby-Talk", there's a gateway between this
mail-list and

Then why do you read and participate in comp.lang.ruby? I'm sure you'd
find much more agreement, and maybe even some useful discussion, over at
comp.lang.lisp. (I assume that exists.)



Now, here's the part you really don't want to hear:

"It's easy to talk big. It's damn hard to _implement_ a complex system,
and make it stable and bug-free..."
-- Linus Torvalds

http://article.gmane.org/gmane.linux.kernel/232093

I was involved in a discussion overlapping the kernel mailing list, and
this is perhaps the only email I've received directly from Linus
Torvalds, addressed to me.

It made me sit down, and shut up, and actually try to get something done
before I opened my big mouth again.

So I am curious -- what have you actually done in Common Lisp? How does
it address the challenges of communication and organization of a large
project? How fast can you whip up small, 100-line scripts to process
text, or to provide a simple service over HTTP and REST? How many cores
(or machines) do your programs scale to, and how much time do you spend
dealing with concurrency issues?

It's easy to talk big.

But you haven't even done that -- you've listed no advantage of Lisp,
other than claiming other languages have "monstrous syntax" -- how so?

One more link for you:

http://xkcd.com/224/

 

[William James]

If you were using CL

CL = COBOL Lisp

(if more people were using CL), and Ruby were not
invented, more bosses would let us use CL as a dynamic language, and
indeed we wouldn't be forced to use Ruby (or worse, perl or python).

Of course, you share the culpability with perl, PHP, Python, Java and
so on.

But I'm mostly justified in thinking this, by the authors of most of
these languages themselves. Some of these authors are just poor chaps
not knowing better, but some other including Java and Ruby knew very
well Lisp, and instead of choosing to help develop and spread lisp,
they voluntarily chosed to create different and inferior languages,
picking only parts of lisp, and grafting over their abortive creation
some monstruous syntax.

In his city R'lyeh, dead Cthulhu lies dreaming.
"Ph'nglui mglw'nafh Cthulhu R'lyeh wgah'nagl fhtagn!"

The fact that these monstruous syntaxes view good in the eyes of the
unwashed masses, and that the lack of features (when it's not just the
inclusion of misfeatures) is oblivious to the same masses IS NOT an
excuse.

The only result is that Lisp is relegated as just an elegant weapon
from a more civilized time, still mastered only by a few remaining
Jedi.

The poor frightened wretch won't admit that CL (COBOL Lisp) is
a flint knife and that Ruby is a samurai sword.

He fears and trembles at Ruby's overtowering superiority.

I've asked him to disgorge some feculent COBOL Lisp code here
so that we, while holding our noses, can demonstrate how Ruby
can perform the same task more elegantly and concisely,
and less malodorously.

He hasn't done so. He will never do so.

And he is so idiotic that he can't comprehend that COBOL Lisp
isn't the only Lisp---is, in fact, the worst of the lot.
He can't learn Clojure because to his fossilized brain
COBOL, COBOL-LISP, APL, and FORTRAN are new and radical languages.

But there is still hope!

This is perhaps the good that will come from these evils. A lot of
programmers are now exposed on the goodness of dynamic languages, and
they may notice (or if not by themselves, *I* will try to make them
notice in threads like this), that their fad language of the day, is
actually some incomplete subset of Lisp, and then why not use the full
and authentic thing? Common Lisp is this way!

The Way, The Truth, and The Light. He's a faithful disciple.

"Common Lisp" is cult jargon to conceal the True Name of their god:
Commode Lord.

 

[William James]

I don't think your flame-bait has helped

Calling it "flame-bait" is in itself flame-bait, proving that
you are devoid of integrity and possesed of overweening
conceit and arrogance.

 

[Eleanor McHugh]

A most fascinating thread, coming from a very distant universe, as I
do.

As for this use of "^", it is about as needless as yet another poem
about a flower. Don't we already have one, somewhere? I fully
realize that calculation (computer) languages are not poems, but
they ARE containers for thought, and in that they are brothers/
sisters to poems.

There seems to be a fairly clean divide between the folks who like
language for being language, and those who like language for the
specific things it can do. I'll admit that I'm one of the former and
some of my favourite programs have minimal value in the latter sense,
but the form of them makes my heart soar.

I'm with Eleanor in loving the exploration of different ways of
thinking/working with stuff (and in having an appreciation for the
elgance of RPN). A large part of the sheer burst of joy that grabbed
me and threw me into the Ruby world, on the occasion of my fifth
look at the language, was the delight I experienced upon finally
understanding that this language was "working" the notion that
everything could be an object, and have access to methods belonging
to the class of which it was a member. The sheer elegance of this
was new to me and is still a very major delight.

After years of battling with VB, C++ and Java the discovery of Ruby
was one of those doh! moments. I haven't looked back
Ruby and beauty are not always synonymous - it very much depends on
the writer - but it's a language that I find it hard to be ugly in and
that I think is a wonderful property.

But then again I've seen beautiful code in C and Assembler, even in
Pascal (see my favourite book, Programming Languages: An Interpreter-
based Approach for some wonderful examples) and perhaps one day I'll
see beautiful code in Nexus. That alone will be justification enough
for the love and effort its developers are pouring into it.

As for Common Lisp, it reminds me of Esperanto: those who are
attracted to it seem often to be those least suited to using it
gracefully and perhaps that says more about them than the language
itself.

So, I have to wonder, when meeting up with a new language, if maybe
I'm about to hear my first Stravinsky ballet, or perhaps run into
something like Spencer Brown's "Laws of form" (1972). Beauty is
found in strange places. If we're all lucky, the Nexus project will
come up with some we've not seen yet. That would be most excellent,
howsoever difficult it may be to achieve.

We abandon the quest for beauty at our peril as it is the keenest
guide to correctness that we possess. Unfortunately an age of
aesthetic relativism has given it a bum wrap by attributing its
quality to things which patently aren't beautiful and are far from
correct.

And once more RT has gone completely OT


Ellie

Eleanor McHugh
Games With Brains
http://slides.games-with-brains.net

 

[Eleanor McHugh]

<snip long rant>

Some of us know Lisp, we just don't like it. That's an aesthetic
choice, and if that bugs you I suggest you consider the relative
numbers of people worldwide employed programming in Lisp and Ruby -
it's pretty much zilch on both counts. Why? Because many many more
people choose to program in truly monstrous languages like Java lol


Ellie

Eleanor McHugh
Games With Brains
http://slides.games-with-brains.net
http://www.linkedin.com/in/eleanormchugh

 

[Jeff Moore]

One more link for you:

http://xkcd.com/224/

Too funny!

Which brings me to my point in this rather interesting exchange.

Having wandered the halls of Basic, Fortran, COBOL, C, C++, Pascal,
Forth, Java, etc, etc I have noted that each language introduced me
to new concepts and modes of thought.

I have enjoyed that tremendously but when I want to get something
done (these days) I reach for Ruby.

It suites the way I think, the way I write code and I rather enjoy
it's almost playful antagonism to burdensome formalisms.

I like my tools light, sharp and powerful. Today, that means Ruby.

Tomorrow, it may mean something else but I haven't seen it yet...

(And BTW, Java should have been smothered in it's crib)

Regards

 

[Clifford Heath]

If I ever design my own programming language, I'm going to use := for
assignment and == for equality, and let a single = be a syntax error,
just to avoid the whole confusion.

I used <- in a language I designed once.