Re: Would an *AdaScript* language be a good / bad idea?

[Wes Groleau <wesgroleau@despammed.com>]

> Errr, well, being used to scripting languages, I'd call both of these
> "difficult" compared to what you typically do with a scripting language.
> Obviously it's not impossible, or you wouldn't be able to write an OS in
> Ada, but it's certainly a lot easier to say something like
> 
>   source $name_of_file
> 
> or
> 
>   MyClass x = new CodeLoader("xyz.class");
> 
> or something like that than it is to write the support code it would
> take to find an arbitrary Ada source, compile it in a cross-platform
> way, write out all your state, invoke the compiled program, and then
> somehow clean up all that afterwards, taking care to catch any errors.

You listed five steps, but your examples
only do one of the steps--invoke.

And I don't see either example as being more difficult than

  Invoke (Name_Of_File);

Sure, someone had to write

  procedure Invoke (Command : String);
  pragma Import (C, Invoke, "exec");
  -- this won't work, it's merely illustrative

but as I said, many implementations are sold
with the equivalent already built-in.

What about the other steps?  Is either incredibly harder
than the other?

Building:

   print OUTPUT ("$Var = \$Var + \$Latest;\n");  # perl ?

   Put_Line (Output, "Var := Var + Latest;" );   # Ada

Compile and link:

   # scripts don't need it, so penalize compilers one point

   Invoke (Make_Command & " " & Source_File_Name);   # Ada
   -- not platform independent, so another one in favor of
   -- interpreters or JIT compilers.

Run:

   source New_Script_Name                       # csh

   Invoke (Exec_Name_Rule (Source_File_Name));  # Ada

Saving state:

   No example--it varies in difficulty according to
   the application, not the language.  Also, it's not
   necessary unless you are "modifying" the currently
   running program.

Cleaning up:

   rm $scratchpad

   Invoke ("rm Scratchpad_Name");

   (Actually, difficulty of--or need for--cleanup
   depends on the application, not the language.)

Error handling:

   No scripting example, because it's too much work to write
   the equivalent of

   exception

      when E : others =>

   Not to mention the code to detect the errors!


Summary (higher means harder):

Task                  Compiled Ada   Interpreted shell
------------------    ------------   -----------------
Building:                   1               1
Compile and link:           2               0
Run:                        1               1
Saving state:               *               *
Cleaning up:                *               *
Error handling:             1               2-5**
===============           ====            ========
TOTAL                       5               4-9

* neither a language issue nor a compiler/interpreter issue

** a language issue, but not a compiler/interpreter issue

So, I'm not saying one _should_ use Ada for stuff like this,
I'm just saying it's NOT difficult.  Long post for two lines, eh?


-- 
Wes Groleau
http://freepages.rootsweb.com/~wgroleau