Yet Another Spinoza Challenge

S

spinoza1111

...
 > > 1)  Riff-raff is certainly not from Dutch origin.  It is (in the form
 > >      rif-raf) a fairly recent addition to the language as used by some.
 > > 2)  "Neewe Yorke" was not the name in the 17th century, in the first
 > >     place is the spelling wrong (even according to 17th century
 > >     vagaries), the name was, until the English took it over, "Nieuw
 > >     Amsterdam".
 >
 > My my aren't we having our leg pulled.

Ah, now you *do* admit you are trolling.

Mr. Winter, in a gentle and collegial environment, humor is always
welcome as leavening a discussion. However, too many people over time
have "made this happy earth their hell" here, with the result of an
almost Satanic lack of laughter here.

The "troll" under the definition trolls globally: he maintains the
irony at all cost. I have the capability to shift registers, and the
intelligent reader is aware of this. I was having a laugh about the
Dutch loss of New York, as I hope you are now aware.
 > men spelled the way they wanted two, and the double ee is
 > characteristic of Dutch.

Right.  And it is pronounced as "ay" as in "fay".

Got it. Thanks for the tuition.
 
S

spinoza1111

 > "Troll" is a racist word, its origin being in Nordic legends
 > justifying the ethnic cleansing of indigenous European peoples: as
 > such it is akin to "gypsy" or "siegourner" in that it is a name given
 > from outside which mischaracterises a group of people: here that group
 > is the dissidents at this site.

"A dwarf or giant in Scandinavian folklore inhabiting caves or hills."

In what way is that "racist"?

Scandinavian "folklore" as we know it today was a written record, like
the Germanic folklore of the Brothers Grimm, created self-consciously
in the 19th century to construct distinct national identities in a
region only recently emerging from Danish yoke, in which "Swedes" and
"Norwegians" could not have told you, perhaps as late as the 18th
century, what there country was.

The "trolls" are clearly the indigenous (or more indigenous given
waves of population displacement) non-Ayran folk simultaneously given
magical powers and deprived of humanity in, in fact, the way the
modern anti-Semite gives the "Jew" power over banking while mocking
him for being powerless. They are clearly the older, darker, smaller
peoples pushed out of the best lands by people who we now think of as
Nordic into waste lands and forests.

This injustice was accomodated by telling children, who naturally
identify with the weak and powerless because of their own position in
society and the family, romantic stories of trolls in the north of
Europe and Siegourner/Tzigane/Gitane/Gypsies/Roma in the south.

You would do very well to read a world history such as Chris Harman's
A PEOPLE'S HISTORY OF THE WORLD to learn that just like Americans,
albeit in a longer time frame, German, Dutch and other Nordic peoples
have not lived in their regions since time out of mind, and that like
Americans they slaughtered and displaced people...in 300 AD, not the
19th century, to be sure.

And, since the midlevel of computing is so dominated by non-Jewish
white and Nordic males both in Europe and in America, it would be very
surprising if computing's subconscious was not populated by "trolls".
The popularity of Nordic myths such as The Lord of the Rings amongst
computer folk shows this.
"A lure or line with its lure and hook used in trolling."

In what way is that "racist"?

In no way, of course, although "Nero is an angler in the lake of
darkness" as Shakespeare's Mad Tom says.
 
S

spinoza1111

...
 > It does not, and I regret the implication. To clarify, a language with
 > subroutine call is best implemented with a runtime stack: a context
 > free language can only be compiled with a stack, but that point isn't
 > relevant to Schildt's point. If it also has recursive subroutine call,
 > it can ONLY be implemented with a stack.

I wonder.  Somewhere in my archives I have the transcript of a discussion
between van Wijngaarden and somebody else where van Wijngaarden did show
that labels were not needed.  (I do not have it nearby, my archive is a
bit scattered around.)  The first step in the transformation of a program
with labels was to a program without subroutines, replacing nearly every
subroutine by a label.  So apparently, every program containing recursive
subroutine calls could be transformed to a program without recursive
subroutine calls.  (The next step was replacing every label by a subroutine.)

I don't this would have worked. It appears to me that it would
transform a recursive factorial program into one with N procedures for
each level of calculation, bounding the maximum N and creating an
absurd number of procedures. But I could be wrong. Sounds like early
art before the lads had mastered everything.
 > And note something very interesting in this regard. A language which
 > has subroutine call, but no recursion, is dead on arrival. This is
 > because the language compiler cannot detect indirect recursion where a
 > calls b calls c ... calls x calls a if there are library routines
 > whose source code is not available to the compiler.

Right, that was why Fortran was dead on arrival.

OK, Fortran II wouldn't be useful today! And as it happened, very few
recursive descent parsers were written in Fortran in the early days,
and those that were, used stacks represented as arrays with fixed
bounds, creating a limit on the number of parenthesis levels. I do
recall a recursive descent parser being described in a Cambridge
University Press book on non-numeric Fortran (from which I learned how
to create bar charts on line printers) but it was a toy.

Fortran was used for "primitive recursive" calculations at best, or
worst if you please.

Furthermore, the limitations of early Fortran (and Jovial) have
probably caused over time any number of genocidal cockups in Western
militaries. We don't know what they are and we hold the apparatus
harmless because of official secrecy.

 > This means that if indirect recursion occurs by accident, a hard to
 > detect bug will probably occur when control returns to the first
 > subroutine called by a (b) and it tries to return to a's first
 > activation.

I indeed have seen this happen with Fortran programs, resulting in infinite
loops.  Not the only problem with Fortran that could not be detected by
either the compiler or the runtime.

Excuse me, but compilers did NOT detect circular calls at that time.

And how do you detect circularity at runtime? With modern software
it's easy. Back then it required an unbounded table, and the machines
of that era didn't have the storage.

No, back then, if you wanted to do recursion, you used Algol: period.
And if you didn't want it to run slowly and interpretively on an IBM
mainframe (assuming you could persuade IBM to stop messing around and
support Algol), you went to Burroughs...which supplied machines with a
stack.

Indeed, I just happen to have all these years a ruin of a book which
has survived black rainstorms in Hong Kong and floods in Fiji. Let's
get it off the bookshelf, shall we?

Ah yes. "Computer Structures: Readings and Examples". Copyright 1971,
McGraw Hill. Ah: memories, if of machines I did not for the most part
program. Perhaps they will evoke memories in you, Mr. Winter, of
Justice Shallow's "Chimes at Midnight" i' th' old play.

The DEC 338 Display Computer. One Level Storage System. The Pilot Ace
("it was based on an earlier design by Dr. A. M. Turing"). The
Olivetta Programma 101 Desk Calculator: buddy of mine flogged them in
the Loop in 1966. The Illiac IV Computer. System Design of a Fortran
Machine. Parallel Operation in the Control Data 6600. The SDS 910-9300
Series. The DEC PDP-8. The IBM 1401, my first machine.

Design of the B 5000 System: "The Stack":

"The problem is attacked directly in the B 5000 by the incorporation
of a 'pushdown' stack, which completely eliminates the need for
instructions coded (or compiled) to store or recall intermediate
results."

There was a Burroughs B 5000 in the window of a Burroughs show room at
the corner of Michigan and Van Buren streets when I was working one
block to the south. The programmers in that shop seemed far more
intelligent and relaxed than the IBM systems engineers I worked with,
perhaps because they were not as hag-ridden by the almost theological
need to "save" dem registers.

Burroughs, in the USA at any rate, fulfilled a need banks had back
then for computing trustworthiness. Although the torch was then passed
to Tandem and its fault-tolerant (and equally stack-based) machine by
the mid 1970s, the deregulation of the financial industry which
started with Reagan, and which destroyed savings and loans by 1989,
meant that banking computing could be less concerned with reliability.
The long-term result was today's depression.



 
S

spinoza1111

spinoza1111wrote:

Oh, news to me. Program structure mapping has been a regular part of
compilers and linkers for about 30 years.

Potentially but not in common practice.
 
S

Seebs

I've written an assembly language myself. Since it is not publicly
available, it is impossible for you to know it. Therefore I know that
your claim that you know all assembly languages is false.

Me too, actually. I assume this is a widespread "hey, how would we..."
practice.

-s
 
U

user923005

Me too, actually.  I assume this is a widespread "hey, how would we..."
practice.

When I was in the military, there was a vacuum tube computer called
the Saturn for satellite telemetry data. It was full of decodes and
hot as a two dollar pistol.

It did not even have an assembler. It had little switches on the back
you used to put in octal codes.

I made a little card that had the mneumonics on it. I considered
writing an assember for it to run on the IBM mainframe, until I
realized that there was no way to get the information into the Saturn
(no input streams other than the switches).

I wrote an assembler for 6510 when I had a Commodore 64. I also wrote
a tiny language (I called it 'jingle') that output in my assembler
format. It had extensions to use the BASIC ROM to do floating point
(there were these fake 10 byte registers {actually not registers at
all, but just memory areas} called the FAC and AFAC that you could do
floating point math with). It was long before Andrew Wiles had proven
FLT, so one jingle program I wrote tried to search for counter-
examples to FLT. After running a few days, it found some so-called
answers, but they were incorrect because the precision was not high
enough (when I computed the solution values by hand, they were only
'real close').

I try to avoid assembly now. It's tedious. I still have a fondness
for MIX, though. I have several MIX compilers.
Not sure how C factors into this discussion. I've never written a C
compiler, though it might be fun to try it.
 
N

Nick Keighley

"user923005" <[email protected]> ha scritto nel messaggio

I try to avoid assembly now.  It's tedious.

#it is not tedious, it has only *the necessary* precision
#for to be one programming language

it *is* tedious. It is low level. If you think in terms
of if and for and while then hand assembling is just *dull*.
I still have a fondness
for MIX, though.  I have several MIX compilers.
Not sure how C factors into this discussion.  I've never written a C
compiler, though it might be fun to try it.

#what is MIX? To what it is like? Does someone want to show some examples?

http://en.wikipedia.org/wiki/MIX
 
T

Tim Rentsch

How can being a context-free language - which is a property of
the program grammar, not its semantics - possibly imply anything
about run-time implementation?

<OT>
A language being context-free depends only on the set of
strings that belong to the language, not on what grammar
is used to defined it. It's always possible to define
a context-free language with a context-free grammar,
but we could define the same language with a general-rewrite
grammar and it would still be a context-free language.
</OT>

Besides which, C is not a context-free language, because
of typedef (and I believe other Syntax rules as well).
 
T

Tim Rentsch

Phil Carmody said:
Many thanks, Keith. In some ways I wish it wasn't so, though, as
just getting all preprocessor issues out of the way is such a
simple concept. However, it's usually the way that the standard
permits flexibility in situations where it doesn't really matter
in the long run.

A note on this issue --

The discussion in 5.1.1.1p1 makes it clear that translation
can occur separately from execution.

If all we're asking the implementation to do is translation,
then there is no execution, hence no execution-time undefined
behavior. So, unless the implementation is being asked to
compile /and run/ a program, there is no run-time undefined
behavior, and the #error must be processed.
 
R

Richard Tobin

How can being a context-free language - which is a property of
the program grammar, not its semantics - possibly imply anything
about run-time implementation?
[/QUOTE]
A language being context-free depends only on the set of
strings that belong to the language, not on what grammar
is used to defined it.

I didn't expect to have to wait so long for a pedant to point that out.

-- Richard
 
T

Tim Rentsch

A language being context-free depends only on the set of
strings that belong to the language, not on what grammar
is used to defined it.

I didn't expect to have to wait so long for a pedant to point that out.[/QUOTE]

Oh, you're still waiting for that. ;)
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

No members online now.

Forum statistics

Threads
473,769
Messages
2,569,582
Members
45,067
Latest member
HunterTere

Latest Threads

Top