Re: How to get Ada to ?cross the chasm??

["Randy Brukardt" <randy@rrsoftware.com>]

"Paul Rubin" <no.email@nospam.invalid> wrote in message 
news:87zi1gz3kl.fsf@nightsong.com...
> "Randy Brukardt" <randy@rrsoftware.com> writes:
>> I don't see anything "cyclic" or "self-referential" here. This is just a 
>> set
>> of lists, and there is nothing particularly interesting about them (in
>> partcular, there are *no* references involved in a list unless you need 
>> to
>> keep a reference to a particular element, certainly doesn't happen here).
>
> This list contains a reference to itself:
>
>    x = 1 : 2 : 3 : x

And is illegal in any reasonable programming language... ;-)

> If you try to print it, you'll see "1,2,3,1,2,3,1,2,3,1,2,3..." ad
> infinitum until you interrupt the program.  It is infinitely long, but
> occupies a finite amount of memory.

If you say so. I can't see any sensible way to implement such a thing; 
indeed I would have said it was impossible to implement but apparently you 
have an example to the contrary.

...
>> Ergo, the underlying implementation of the Haskell code has to do
>> something like that in order to figure out the answers. (There's no
>> free lunch. :-)
>
> Yes, that's exactly right: the burden is moved from the application
> programmer to the language implementation.

True, but only if the problem actually matches the language implementation. 
A language like Ada that is built around readability and reuse allows one to 
build things once and use them forever. You're not stuck to just what the 
implementation can do.

> But that Hamming number code isn't particularly mysterious.

Says you. Lists of numbers are not a technique I would think of to do 
anything (partly because it would be so horribly inefficient).

>  Back in the day,
> programmers would learn techniques like hash tables, recursion, etc.;
> and then when given a problem they would either 1) see a solution from
> techniques they knew; or 2) not immediately see a solution and have to
> spend more time thinking, studying new techniques or whatever.

What day was this? I've been programming 40+ years and don't remember any 
time when the average programmer thought about anything. Generally, they 
just started throwing code at the problem until it was solved or the boss 
gave it to someone else. ;-)

That minority of us that engineer software do think about our code before we 
start, but the effort is put on abstraction and organization - the actual 
solution is almost irrelevant to that. Real problems are much larger and 
complex than any simple technique could be used to solve anyway.

...
> The picture I'm trying to convey is that functional programming brings
> some new techniques that (like hash tables) let you easily solve certain
> problems once you know the tricks, that would be hard to solve
> otherwise.

I agree with this, but the problem is the majority of such problems aren't 
realistic in the first place. (Who cares about Hamming numbers?) And most of 
the other techniques can be used just as well in Ada (recursion, for 
instance; the map containers provide hash tables, etc.). Once you get the 
stuff where you need lambdas with closures, you're just writing tricky code 
that only a few (if any) will understand. (Ada is all about building 
long-lived programs; I haven't started a new program in quite a few years, 
just improving existing ones.)

...
> If you like a tool and see a problem you can use it on, why
> would you look for ways to *not* use it?

...but you also have to figure how that fits in with the entire system. 
Pretty much no one is solving simple stand-alone problems. It's a lot harder 
to debug a program that uses a whole bunch of different languages that 
barely work together. You might have one problem that actually would solve 
well in Haskell, but the entire system has dozens of problems and many of 
them aren't likely to be functional in nature (like the GUI to talk to the 
system).

In any case, this is an Ada forum and there isn't point about talking about 
other languages here, other than to point out how Ada is better. ;-)

                          Randy.