Re: general-purpose vs. domain-specific programming languages

Re: general-purpose vs. domain-specific programming languages

[Brian Rogoff]

On 31 Dec 1997, Terry J. Westley wrote:
> Are you aware of any serious programming language research which
> addresses the issues of
> 
> 1) what makes one language more suited to a particular domain than
>    another, and
> 2) how does one decide when to abandon the general-purpose language
>    in favor of the domain-focused language?

These seem more like opinion/experience questions than serious programming
language research. 

> Here are the sorts of questions I would like such research to address:
>    Why do people use Perl so much for CGI programming?

Because much of what you want to do is already done, and there is a module 
available on CPAN or wherever to do it. 

>    Why can't I write some libraries so that Ada is just as easy to
>       use to search and replace data in text files as Perl?

Because you don't know how to write a regexp matcher in Ada? ;-)

Seriously, you can write more general pattern matchers as Ada libraries, 
or link with existing C/Fortran/Cobol ones if you are using Ada 95, but 
it takes work. And Perl has certain notational conveniences which Ada 
doesn't. But for the most part, I think its almost as easy to use an 
Ada library, and I find that the type safety is a huge benefit. 

(Note: If you use GNAT 3.10 or greater, you can use the Gnat.Spitbol 
library which uses SNOBOL4 style patterns. Be warned, it is GNAT specific. 
Makes you wish Ada had downward closures and out mode functions ;-)

>    Why is string and list handling so much easier in Tcl and Perl
>       than in Ada?

Lots of built in notation in the language for handling string primitives, 
and a rich set of basic operations. But the operations can be added 
easily, so I question your assertion that string and list handling is 
*so* much easier. 

IMO, list and string handling is far easier in Icon than either Perl or 
Tcl, and handling complicated data structures is easier in OCaml. But I
still prefer Ada as a general purpose, high performance, mostly type safe 
language.

-- Brian

Re: general-purpose vs. domain-specific programming languages

[Marin David Condic, 561.796.8997, M/S 731-96]

"Terry J. Westley" <westley@CALSPAN.COM> writes:
>Here are the sorts of questions I would like such research to address:
>   Why do people use Perl so much for CGI programming?
>   Why can't I write some libraries so that Ada is just as easy to
>      use to search and replace data in text files as Perl?
>   Why is string and list handling so much easier in Tcl and Perl
>      than in Ada?
>
    I don't know Perl, so I can't speak to specific features. It would
    seem that even in a 'string friendly' language like Perl, you'd
    still need to specify certain things like the source file, the
    object file, the string (or meta-string?) to search for and the
    string with which to replace it. In Ada, you might build a package
    like this:

    package Perl_Like_Utilities is

        procedure Search_And_Replace (
            Source_File     : in     String ;   --  OS dependent filename.
            Object_File     : in     String ;   --  OS dependent filename.
            Search          : in     String ;
            Replace         : in     String) ;

        --  And whatever else you think you need.

    end Perl_Like_Utilities ;

    Then using Text_IO or Stream_IO and the various string
    manipulation packages, you could build up the procedures you need.
    Of course, at this point, you are acting in the same capacity as
    the Perl-primitive-implementor. The guy who had to code up the
    behavior of the Search_And_Replace primitive (whatever it is in
    Perl) had to operate by reading the file and laboriously comparing
    characters - probably in assembler. But its a job you only do
    once.

    I'll agree that the string handling packages in Ada (See "Strings
    - A.4.1" in the ARM for the description of Ada.Strings,
    Ada.Strings.Maps, Ada.Strings.Fixed, Ada.Strings.Bounded,
    Ada.Strings.Unbounded) can be confusing. They don't provide the
    utilities that *I* would have written (everybody has their own
    favorite way of doing things) but they are fairly "regular"
    ("orthogonal" is also a favorite term) and they will usually get
    the job done. As with anything else, you've got to spend the time
    to learn "The Ada Way" of doing it and not try to write Perl (or
    Snobol, or Lisp, or Basic) only with Ada syntax.

    I'd suspect that if you could come up with a list of your favorite
    Perl primitives and a description of their semantics, it would be
    possible to build an Ada package that provided equivalent
    features, perhaps by utilizing the Ada.Strings... packages as the
    underlying implementation. (Maybe you'd like to e-mail me some
    examples and we could investigate how difficult the job might be.)
    A decent specification might even gain some wider acceptance as a
    defacto standard if it was circulated widely.

    MDC

Marin David Condic, Senior Computer Engineer     Voice:     561.796.8997
Pratt & Whitney GESP, M/S 731-96, P.O.B. 109600  Fax:       561.796.4669
West Palm Beach, FL, 33410-9600                  Internet:  CONDICMA@PWFL.COM
=============================================================================
    "Outside of a dog, a book is man's best friend; inside a dog,
    it's too dark to read..."
        --  Groucho Marx
=============================================================================

Re: general-purpose vs. domain-specific programming languages

[Joe Gwinn]

In article <98010512040396@psavax.pwfl.com>, "Marin David Condic,
561.796.8997, M/S 731-96" <condicma@PWFL.COM> wrote:

> "Terry J. Westley" <westley@CALSPAN.COM> writes:
> >Here are the sorts of questions I would like such research to address:
> >   Why do people use Perl so much for CGI programming?
> >   Why can't I write some libraries so that Ada is just as easy to
> >      use to search and replace data in text files as Perl?
> >   Why is string and list handling so much easier in Tcl and Perl
> >      than in Ada?
> >
[snip]
>     I'd suspect that if you could come up with a list of your favorite
>     Perl primitives and a description of their semantics, it would be
>     possible to build an Ada package that provided equivalent
>     features, perhaps by utilizing the Ada.Strings... packages as the
>     underlying implementation. (Maybe you'd like to e-mail me some
>     examples and we could investigate how difficult the job might be.)
>     A decent specification might even gain some wider acceptance as a
>     defacto standard if it was circulated widely.

The preface/introduction to the Perl manual gives the game away.  Perl is
intentionally designed to allow the violation of the majority of the usual
good-programming practices and restrictions, such as the strict type
safety that Ada is so famous for.

Why did they do such a thing?  For expediency.  Perl was intended to ease
the writing of small one-shot programs, not the implementation of large
and critical systems.  So, perl has essentially no type checking, has lots
of string handling and pattern-matching features, et al, while in Ada one
would have to invent all that.  

The CGI stuff is mostly used for web pages, which change fast, so the
things we value Ada for in fact just get in the way in such applications,
because the programmer-proof safety of Ada makes changes much slower to
implement than less fussy languages, and perl is by design the least fussy
of all.

Does this make perl more error prone?  Yes, absolutely.  Will webmasters
therefore convert to Ada?  No, because they value speed over safety, and
nobody dies if a webpage fails.  The only price is a flood of annoyed
emails.

Joe Gwinn

Re: general-purpose vs. domain-specific programming languages

[Robert Dewar]

Joe said

<<Why did they do such a thing?  For expediency.  Perl was intended to ease
the writing of small one-shot programs, not the implementation of large
and critical systems.  So, perl has essentially no type checking, has lots
of string handling and pattern-matching features, et al, while in Ada one
would have to invent all that.>>

Unless of course you are using GNAT, which comes with a full SNOBOL4
compatible pattern matching library that is much *more* powerful than what
is in Perl!

Robert Dewar
Ada Core Technologies

Re: general-purpose vs. domain-specific programming languages

[Brian Rogoff]

On Mon, 5 Jan 1998, Marin David Condic, 561.796.8997, M/S 731-96 wrote:
> ... snip ...
>
>     I don't know Perl, so I can't speak to specific features. It would
>     seem that even in a 'string friendly' language like Perl, you'd
>     still need to specify certain things like the source file, the
>     object file, the string (or meta-string?) to search for and the
>     string with which to replace it. In Ada, you might build a package
>     like this:
>
> ... snip ... 

I think that an interesting approach might be to embed an entire family 
of different domain specific languages as a set of Ada packages
implementing interpreters for these languages. I was working on something
like that for a while, based on Kamin's interpreters, but lost a lot of
free time when I changed jobs. Kamin's book (whose title escapes me) has 
a bunch of interpreters for Scheme, APL, Prolog, and others, all with a
Lispish surface syntax. 

-- Brian

Re: general-purpose vs. domain-specific programming languages

[Michael F Brenner]

   > I'd suspect that if you could come up with a list of your favorite
   > Perl primitives and a description of their semantics, 

The one you suggested is PRECISELY my favorite  Perl primitive, where
the search string is an awk regular expression:

   >  package Perl_Like_Utilities is
   > 
   >     procedure Search_And_Replace (
   >         Source_File     : in     String ;   --  OS dependent filename.
   >         Object_File     : in     String ;   --  OS dependent filename.
   >         Search          : in     String ;
   >         Replace         : in     String) ;

        --  And whatever else you think you need.

The other thing we need is for the implementations to work. 
Make get-immediate, stream_io, packed bit strings, file rename,
executing OS commands, port input output, absolute memory addreses,
lighting up pixels, getting mouse coordinates, all work
THE SAME WAY IN ADA on DOS, Linux, Sparc, Mips, and NT. If it
works on HP, Macintosh, DEC, etc., etc., that will be even better!

Right now backwards compatibility has to be maintained with Ada-83
because Ada-83 compilers are the only ones that have correct
implementations on DOS, such as Alsys. If gnat could be fixed
on DOS, just to the point where it does what Alsys did, then
the backwards compatibility issue goes away. That is a big
drag on the free development community.

I am not referrring to the community that can afford the large
per-seat and per-organization charges for ACT support. That is
a very respectable community, but they mostly use mouse systems
instead of command driven systems like DOS.

Developers of Free code, and users of legacy code that does not
run under NT (like Alsys Ada, Knowledgeman, Oracle 5.0, 
code that depends on instant-response hardward-mapped pixels,   
instant-response hardware mapped text characters, 
interrupt driven keys or ports, large packed bit strings like
super VGA screens, etc.)
need DOS. 

And in order to do these things and interface to these products
in DOS we need to use Ada-83 at this time, because of the
bugs / and or / not-fully-implemented features of the
non-tasking code-generation and runtime-libray of gnat 3.07.

The highest priority the Free Ada Code community needs is a 
gnat 3.07 with an upgraded code generator that does the packed
arrays correctly, with an upgraded runtime library that
fixes keyboard, stream_io, absolute memory mapping, and 
with the gnatmake that did not get repaired fully until gnat 3.10.
          
This is not as tall an order asasking for gnat 3.10 under DOS,
nor is it any where near as tall an order as asking for a working
tasking library under DOS. A non-tasking DOS or a semi-tasking
DOS (say only two tasks active at a time and text_io is permitted
to block) would meet 99 percent of the DOS requirements. 

Right now, the implementation problems do not meet enough of the
DOS requirements to prevent maintaining backwards Ada-83 compatibility.

Mike Brenner

Re: general-purpose vs. domain-specific programming languages

[Robert Munck]

On Wed, 07 Jan 1998 15:43:51 -0500, gwinn@res.ray.com (Joe Gwinn)
wrote:

>....  Perl is
>intentionally designed to allow the violation of the majority of the usual
>good-programming practices and restrictions, such as the strict type
>safety that Ada is so famous for.
>
>Why did they do such a thing?  For expediency. 

Perl also has the interesting characteristic that novices tend
to write fairly straightforward, easy-to-read code, but 
experienced programmers use various syntatic and semantic
constructs that make their code completely unreadable.
It's the perfect hack language.

Bob Munck
Mill Creek Systems LC

Re: general-purpose vs. domain-specific programming languages

[nabbasi]

In article <34b4e5f8.997361@news.mindspring.com>, munck@Mill-Creek-Systems.com
says...

>
>Perl also has the interesting characteristic that novices tend
>to write fairly straightforward, easy-to-read code, 

this is the first time I've seen "easy-to-read" and "perl" in the
same sentence :)

Pepole nowadays are all so busy, they just want to write something that does
the current and immediate task only without looking ahead, very few care 
about long term reusability, about maintainance, about software design, 
about intergation, etc.., it is a world of hacking, and short time-to-market, 
and quick fixes and bug releases. That is why they are so busy, busy 
fixing buggy software and trying to understand what the previous 
programmers were trying to write, and here comes a language like Perl 
to help us out from the software crisis we are in.

Nasser

Re: general-purpose vs. domain-specific programming languages

[nabbasi]

In article <692v45$cpi@top.mitre.org>, mfb@mbunix.mitre.org says...

>Right now backwards compatibility has to be maintained with Ada-83
>because Ada-83 compilers are the only ones that have correct
>implementations on DOS, such as Alsys. If gnat could be fixed
>on DOS, just to the point where it does what Alsys did, then
>the backwards compatibility issue goes away. That is a big
>drag on the free development community.

Why is it only around Ada language folks that I keep hearing about this
DOS thing?
who cares about DOS? DOS is dead, lets get on with it, dealing with 
anything to do with DOS is a waste of time. does anybody actually develop
for DOS nowadays? if someone does not have $100 to buy a modern OS to work
on, then they don't need the software anyways, and they don't need Ada either.

Nasser

Re: general-purpose vs. domain-specific programming languages

[David Wheeler]

Joe Gwinn (gwinn@res.ray.com) wrote:
: In article <98010512040396@psavax.pwfl.com>, "Marin David Condic,
: 561.796.8997, M/S 731-96" <condicma@PWFL.COM> wrote:

: > "Terry J. Westley" <westley@CALSPAN.COM> writes:
: > >Here are the sorts of questions I would like such research to address:
: > >   Why do people use Perl so much for CGI programming?
: > >   Why can't I write some libraries so that Ada is just as easy to
: > >      use to search and replace data in text files as Perl?
: > >   Why is string and list handling so much easier in Tcl and Perl
: > >      than in Ada?
: > >
: [snip]
: >     I'd suspect that if you could come up with a list of your favorite
: >     Perl primitives and a description of their semantics, it would be
: >     possible to build an Ada package that provided equivalent
: >     features, perhaps by utilizing the Ada.Strings... packages as the
: >     underlying implementation. (Maybe you'd like to e-mail me some
: >     examples and we could investigate how difficult the job might be.)
: >     A decent specification might even gain some wider acceptance as a
: >     defacto standard if it was circulated widely.


I use both Perl and Ada.  As a programming language, I think Perl
is terrible; it's designed to make mistakes and be unreadable.

So, why do I use Perl when I choose to do so?  The answer is
listed above: it includes a large number of built-in capabilities in its
libraries.  In particular, it has a rich regular expression system
that I find very useful (for matching, substituting with great control,
and splitting).  It also has capabilities for handling lists
of files & option flags in the command line, associative arrays,
and growable arrays.  Yes, I could implement that in Ada, but
it's faster to use a poorer language with already-implemented,
already-tested components than a better language without them.

Feel free to come up with a list of primitives and semantics, I'd love
to see it.  Implementing them is doable, but nontrivial.

And as others have noted, each language has different strengths.
Perl is usually used for short trivial programs (say <1K lines), where Ada's
readability and programming-in-the-large capabilities are not as obvious.
Use the tool appropriate to the job; the choice of programming language for
a given task is an engineering decision.

--- David A. Wheeler
    dwheeler@ida.org

Re: general-purpose vs. domain-specific programming languages

[Philip R Ventura]

In article <6956pq$mnu@drn.zippo.com>,  <nabbasi@earthlink.net> wrote:
>
>Pepole nowadays are all so busy, they just want to write something that does
>the current and immediate task only without looking ahead, very few care 
>about long term reusability, about maintainance, about software design, 
>about intergation, etc.., it is a world of hacking, and short time-to-market, 
>and quick fixes and bug releases. That is why they are so busy, busy 
>fixing buggy software and trying to understand what the previous 
>programmers were trying to write, and here comes a language like Perl 
>to help us out from the software crisis we are in.

Perl is ten years old.  Besides one of the stated design goals is as a
"glue" language for quickly hacking together ad hoc scripts.  As far
as readability Perl does have its quirks.  Hardly the panacea you
propose.  But then again one can write crappy code in any language,
even Ada ;)

Just Another Perl Hacker

-- 
Phil Ventura			  phone:  645-3772
Teaching Assistant CS305	  email:  pventura@cs.buffalo.edu
Dept. Computer Science		  office: Trailer B
SUNY at Buffalo			  http://www.cs.buffalo.edu/~pventura

Re: general-purpose vs. domain-specific programming languages

[Philip R Ventura]

In article <695dja$qdc@news.ida.org>, David Wheeler <dwheeler@ida.org> wrote:
>I use both Perl and Ada.  As a programming language, I think Perl
>is terrible; it's designed to make mistakes and be unreadable.

Oh come on can you really say that with a straight face?  Perl has its
lineage in UNIX utils like sed, and awk, UNIX shells and even C.  Part
of the desing goals were as I mentioned previously, to replace these.
As Larry Wall points out in Programming Perl, "Perl is desinged to
make the easy jobs easy, without making the hard jobs impossible."

Certainly I agree it can at times look cryptic, but that is a function
of how regular expressions tend to be written particularly in UNIX.

>
>So, why do I use Perl when I choose to do so?  The answer is
>listed above: it includes a large number of built-in capabilities in its
>libraries.  In particular, it has a rich regular expression system
>that I find very useful (for matching, substituting with great control,
>and splitting).  It also has capabilities for handling lists
>of files & option flags in the command line, associative arrays,
>and growable arrays.  Yes, I could implement that in Ada, but
>it's faster to use a poorer language with already-implemented,
>already-tested components than a better language without them.

Again "poorer language?"  I much prefer to compare the merit of a
language based on how well it meets the stated design goals.  After
all, one could say Ada is poor because it lacks the expressiveness and
power of Perl.  Besides, you are free to be as disciplined as you want
when you program Perl.

>
>Feel free to come up with a list of primitives and semantics, I'd love
>to see it.  Implementing them is doable, but nontrivial.
>
>And as others have noted, each language has different strengths.
>Perl is usually used for short trivial programs (say <1K lines), where Ada's
>readability and programming-in-the-large capabilities are not as obvious.
>Use the tool appropriate to the job; the choice of programming language for
>a given task is an engineering decision.

Perl is used for lots, so are Ada, C/C++, Lisp, etc.  As you say each
has strengths and weaknesses, although your prior comments seem to
ignore this.

I decided to learn Perl because I was using lots of combinations of
shell scripts with sed and awk along with other stuff all to help
automate some of the grading process.  But in many cases I was coming
up against restraints in sed/awk or other things.  I could have
switched to C or Ada or something else, but why?  The interface to the
system isn't as clean or easy.  The text-processing isn't there.

At the same time I have been suitably impressed by Perl, and could see
it used for full-scale applications.  Perhaps not critical systems,
which is where I would definitely want Ada.

Blanket value judgements of languages are seldom useful or
interesting.  I much prefer to accept the uniqueness of them, and be
eclectic.  After all programming languages are there just to make it
easy for us programmers to do the jobs we need to do and do it in an
efficient way for the machine.  So don't curse the hammer because its
hard to chop down a tree with it.



-- 
Phil Ventura			  phone:  645-3772
Teaching Assistant CS305	  email:  pventura@cs.buffalo.edu
Dept. Computer Science		  office: Trailer B
SUNY at Buffalo			  http://www.cs.buffalo.edu/~pventura

Re: general-purpose vs. domain-specific programming languages

[Robert Dewar]

Mike says

<<Right now backwards compatibility has to be maintained with Ada-83
because Ada-83 compilers are the only ones that have correct
implementations on DOS, such as Alsys. If gnat could be fixed
on DOS, just to the point where it does what Alsys did, then
the backwards compatibility issue goes away. That is a big
drag on the free development community.
>>

We see a vanishing demand for DOS, virtually everyone is switching
to Win95. Yes, I quite understand that Mike blows this trumpet loudly,
but few answer the call at this stage.

Mike, if you think it is so important to bring the DOS port up to 
date, why not do it.

I find the allegation that it is worth maintaining Ada 83 compatibility
JUST because of DOS very weak, not at all convincing.

Actually I find it telling that no one has bothered to bring the DOS
port up to date. It is certainly not that difficult and would not take
that much time (here at ACT, we don't find it worth spending even a little
time on, since there is just zero interest in this port).

Re: general-purpose vs. domain-specific programming languages

[Robert Dewar]

Nasser says

<<Why is it only around Ada language folks that I keep hearing about this
DOS thing?
who cares about DOS? DOS is dead, lets get on with it, dealing with
anything to do with DOS is a waste of time. does anybody actually develop
for DOS nowadays? if someone does not have $100 to buy a modern OS to work
on, then they don't need the software anyways, and they don't need Ada either.
>>

Listen more carefully, you don't hear the "Ada language folks" talking
about the importance of DOS, you hear a very small (but quite insistent)
minority. It is clear to me that the majority of the Ada community
agrees with your (perfectly reasonable) observation above!

Re: general-purpose vs. domain-specific programming languages

[Nick Roberts]

Perl Has Its Limits?

Re: general-purpose vs. domain-specific programming languages

[Marin David Condic, 561.796.8997, M/S 731-96]

David Wheeler <wheeler@IDA.ORG> writes:
>So, why do I use Perl when I choose to do so?  The answer is
>listed above: it includes a large number of built-in capabilities in its
>libraries.  In particular, it has a rich regular expression system
>that I find very useful (for matching, substituting with great control,
>and splitting).  It also has capabilities for handling lists
>of files & option flags in the command line, associative arrays,
>and growable arrays.  Yes, I could implement that in Ada, but
>it's faster to use a poorer language with already-implemented,
>already-tested components than a better language without them.
>
    I have no problem using some esoteric language for quickie hacks
    instead of writing it out in Ada. I still do some things with DCL
    jobs - not all things worth doing are worth doing well.

    I think my point was that if there were some specific useful
    features of Perl that could be functionally duplicated in Ada, it
    might be worth having a collection like this around. I think the
    original example was to search & replace a string in a text file.
    Without implementing anything more than this, you would have a
    useful tool for Ada programmers.

    I'd hate to try to duplicate all of the functionality of Perl, or
    any other language in Ada - you'd end up trying to do some serious
    tough work which probably would satisfy no one. But individual
    capabilities might not pose this big a problem as long as one was
    not trying to duplicate the entire flavor of the language. (Ex: I
    recall some version of Basic that allowed you to do matrix math
    operations - without duplicating all of Basic, wouldn't it seem
    useful to build a package that provided this capability?
    Certainly, the Information Systems annex of the ARM was a
    reasonable attempt to steal from Cobol something Cobol did very
    well.)

>Feel free to come up with a list of primitives and semantics, I'd love
>to see it.  Implementing them is doable, but nontrivial.
>
    I don't speak Perl - I was trying to be helpful in response to
    someone else's complaint that Ada lacked features found in Perl.
    You are probably right about it being a non-trivial body of work,
    but there may be peices still worth doing.

>And as others have noted, each language has different strengths.
>Perl is usually used for short trivial programs (say <1K lines), where Ada's
>readability and programming-in-the-large capabilities are not as obvious.
>Use the tool appropriate to the job; the choice of programming language for
>a given task is an engineering decision.
>
    Dittos. But I still like to "extend" Ada by building utility
    software that does useful stuff - sometimes stealing from other
    languages things they do well. Sure, Lisp can do slick things with
    lists much better than off-the-shelf Ada - but you can build list
    tools in Ada and keep them in the bag of tricks, possibly avoiding
    the headaches of mixed-language programming.

    MDC

Marin David Condic, Senior Computer Engineer     Voice:     561.796.8997
Pratt & Whitney GESP, M/S 731-95, P.O.B. 109600  Fax:       561.796.4669
West Palm Beach, FL, 33410-9600                  Internet:  CONDICMA@PWFL.COM
=============================================================================
    "I filled out an application that said, 'In Case Of Emergency
    Notify'. I wrote 'Doctor'... What's my mother going to do?"
        --  Steven Wright
=============================================================================

Re: general-purpose vs. domain-specific programming languages

[Thornton]

Robert Dewar wrote:
>
> Nasser says
>
> <<Why is it only around Ada language folks that I keep hearing about this
> DOS thing?
> who cares about DOS? DOS is dead, lets get on with it, dealing with
> anything to do with DOS is a waste of time. does anybody actually develop
> for DOS nowadays? if someone does not have $100 to buy a modern OS to work
> on, then they don't need the software anyways, and they don't need Ada either.

Minority yes, but there's still a need that can be met.

Re: general-purpose vs. domain-specific programming languages

[Robert Dewar]

Thornton said

<<zero interest?  Admit it, there is some interest.  Probably more so with
new users and students like myself.
>>

I mean zero interest from our customers. 

There are also people who are enthusiastic about the Amiga, and would
no doubt like us to do an Amiga port, or ....

But interest to us means commercial interest, it is the people who pay
who keep the GNAT project steaming along :-)

Robert Dewar
Ada Core Technologies

P.S. Maybe there are students around who use DOS, none of my students
are using DOS, they are all using Win95, Linux or NT.

Re: general-purpose vs. domain-specific programming languages

[Brian Rogoff]

On 13 Jan 1998, Robert Dewar wrote:
> But it is reasonable to have the primitives from which this is easily
> constructed, and certainly using the pattern matching support in GNAT,
> you can easily program this function (and indeed tuck it in a library
> if you really think it is something you will often want to do).

Part of the attraction of Perl is that its pattern matching functionality
is derived from the Unix utilities (grep, awk, sed, tr, ....) so Unix 
programmers feel somewhat comfortable (i.e., they don't have to learn
anything new) using it. Another part, separate from the pattern matching 
functionality, is that there is a pretty convenient socket programming
interface, also familiar to Unix people. And a third is that since Perl
has an interactive mode, you can learn by typing in examples rather than
reading the Perl manual. (OK, I'm ducking and running for cover ;-)

> A useful thing would be for someone to propose a spec for a Perl interface

Probably just an Ada-fied version of  POSIX regex matching would suffice 
to emulate a suitable subset of Perl pattern matching. 

-- Brian

Re: general-purpose vs. domain-specific programming languages

[Robert Dewar]

Marin said

    <<I think my point was that if there were some specific useful
    features of Perl that could be functionally duplicated in Ada, it
    might be worth having a collection like this around. I think the
    original example was to search & replace a string in a text file.
    Without implementing anything more than this, you would have a
    useful tool for Ada programmers.>>

I doubt it is worth having such specific features. I must say I have 
NEVER needed this *exact* function in anything I have written.

But it is reasonable to have the primitives from which this is easily
constructed, and certainly using the pattern matching support in GNAT,
you can easily program this function (and indeed tuck it in a library
if you really think it is something you will often want to do).

    <<I'd hate to try to duplicate all of the functionality of Perl, or
    any other language in Ada - you'd end up trying to do some serious
    tough work which probably would satisfy no one. But individual>>

GNAT implements all the important functionality of SNOBOL-4 (with SPITBOL
extensions), and it was serious tough work, but a lot of people, including
the GNAT project itself, has found it very useful. 

Of course not all of PERL is in SNOBOL4 (and vice versa), but actually I
think a GNAT.Perl library unit that contained useful functionality along
these lines would make very good sense. We are certainly planning some
units of this kind (the spec for GNAT.COBOL is already completed, but who
knows when the implementation will get done?)

A useful thing would be for someone to propose a spec for a Perl interface
....

Re: general-purpose vs. domain-specific programming languages

[Thornton]

Robert Dewar wrote:
> Actually I find it telling that no one has bothered to bring the DOS
> port up to date. It is certainly not that difficult and would not take
> that much time (here at ACT, we don't find it worth spending even a little
> time on, since there is just zero interest in this port).

zero interest?  Admit it, there is some interest.  Probably more so with
new users and students like myself.

Re: general-purpose vs. domain-specific programming languages

[Michael F Brenner]

Thornton> zero interest?  Admit it, there is some interest.  
Dewar>    I mean zero interest from our customers. 
Dewar>    There are also people who are enthusiastic about the Amiga, 
     >    and would no doubt like us to do an Amiga port, or ....


Why would the DOS version of gnat not work on the Amiga?

Dewar>    But interest to us means commercial interest, 
     >    it is the people who pay who keep the GNAT project 
     >     steaming along :-)

I agree. But I also agree that a working DOS version of gnat would
be helpful to the Ada community, and this is the place for us
gnat-lovers to sit in a circle of gnat-love and visualize the
arrival of gnat3.11(DOS). Let us all have a moment of silence,
and then entone the mantra OOOOOOOOOOMMMMMMMMMMMM.

Re: general-purpose vs. domain-specific programming languages

[Robert Dewar]

<<Why would the DOS version of gnat not work on the Amiga?>>

You mean in simulation mode? Well that would be pretty unsatisfactory, and
indeed I believe that there is already a 3.09 for the Amiga somewhere (Amiga
folks seem to spend less time writing messages about what they want someone
else to do, and more time getting it done, than DOS folks :-)

P.S. the guy who works on the Amiga port also works at Mitre!

Robert Dewar
Ada Core Technologies

Re: general-purpose vs. domain-specific programming languages

[Stephen Leake]

Brian Rogoff wrote:
> 
> Part of the attraction of Perl is that its pattern matching functionality
> is derived from the Unix utilities (grep, awk, sed, tr, ....) so Unix
> programmers feel somewhat comfortable (i.e., they don't have to learn
> anything new) using it. 

I've never met anyone who could write regular expressions from memory; I
know I always have to look in the manual. I much prefer reading an Ada
spec! In addition, the Gnat.Snobol syntax is reminiscent of DEC's TPU
pattern matching, which I learned before I learned Unix/emacs regexp.

>                       Another part, separate from the pattern matching
> functionality, is that there is a pretty convenient socket programming
> interface, also familiar to Unix people. 

No reason we can't have an Ada Berkely sockets binding (although I never
did like the Berkely abstraction).

>                                      And a third is that since Perl
> has an interactive mode, you can learn by typing in examples rather than
> reading the Perl manual. (OK, I'm ducking and running for cover ;-)

Yep, that's a biggie. I think that's the main reason people like (used
to like?) Forth, Lisp, and all the other interpreted/user interactive
languages.

> -- Brian

-- 
- Stephe

Re: general-purpose vs. domain-specific programming languages

[Randal Schwartz]

>>>>> "Robert" == Robert Munck <munck@Mill-Creek-Systems.com> writes:

Robert> Perl also has the interesting characteristic that novices tend
Robert> to write fairly straightforward, easy-to-read code, but 
Robert> experienced programmers use various syntatic and semantic
Robert> constructs that make their code completely unreadable.

That's only when we're in "code to impress" mode.  When I'm being paid
by a client to write stuff that has to be maintained long after I'm
gone, I stick with the basics.

Robert> It's the perfect hack language.

This, I must agree.

print "Just another Perl hacker,"

-- 
Name: Randal L. Schwartz / Stonehenge Consulting Services (503)777-0095
Keywords: Perl training, UNIX[tm] consulting, video production, skiing, flying
Email: <merlyn@stonehenge.com> Snail: (Call) PGP-Key: (finger merlyn@teleport.com)
Web: <A HREF="http://www.stonehenge.com/merlyn/">My Home Page!</A>
Quote: "I'm telling you, if I could have five lines in my .sig, I would!" -- me

Re: general-purpose vs. domain-specific programming languages

[Randal Schwartz]

>>>>> "Stephen" == Stephen Leake <Stephen.Leake@gsfc.nasa.gov> writes:

Stephen> I've never met anyone who could write regular expressions
Stephen> from memory; [...]

Stephen, I'm Randal Schwartz.  Nice to meet you.

Now you can't say that any more.

:-)

Really, regex are not that hard.  If you can remember the 425 keywords
of Ada, you can certainly remember the 10 operations of a regex. :-)

I have a series of columns online that go into that very topic... see

	http://www.stonehenge.com/merlyn/UnixReview/

print "Just another Perl hacker,"
-- 
Name: Randal L. Schwartz / Stonehenge Consulting Services (503)777-0095
Keywords: Perl training, UNIX[tm] consulting, video production, skiing, flying
Email: <merlyn@stonehenge.com> Snail: (Call) PGP-Key: (finger merlyn@teleport.com)
Web: <A HREF="http://www.stonehenge.com/merlyn/">My Home Page!</A>
Quote: "I'm telling you, if I could have five lines in my .sig, I would!" -- me

Re: general-purpose vs. domain-specific programming languages

[Robert Dewar]

Randal said

<<That's only when we're in "code to impress" mode.  When I'm being paid
by a client to write stuff that has to be maintained long after I'm
gone, I stick with the basics.
>>

What an amazing idea, that one could impress someone by writing
unreadable code!

I always tell my students that if you ever write a bit of code, and
look at it and think "how clever", then that is a big red flag!

Good programmers impress with simple, easy to understand code.

Ok, OK, I realize that the original should probably have had a smiley,
but the principle that clever code is dangerous code is an important one :-)

Re: general-purpose vs. domain-specific programming languages

[Robert Dewar]

Randal says

<<Really, regex are not that hard.  If you can remember the 425 keywords
of Ada, you can certainly remember the 10 operations of a regex. :-)
>>

Well of course *nearly* all the readership of this group knows how
silly that statement is, but just for the benefit of those listening in,
we sure hope that Randal is better at making regex's than counting
reserved words in Ada (there are less than 70). I assume that keywords
does mean reserved words, there is no such thing per se as a keyword in Ada
terminology.

P.S. For my taste the pattern matching semantics of SNOBOL4 (and hence
of the pattern matching routines provided with GNAT) is far more flexible,
far more powerful, and far easier to use than regexp's.