






          This is the Scorpion System, Release 5.0, from  the  Univer-
          sity  of Arizona.  A brief overview of Scorpion follows some
          important administrative details.  We conclude with  a  list
          of the documentation available with Scorpion and some advice
          on what to read next.

          _1.  _A_d_m_i_n_i_s_t_r_i_v_i_a

               See the files installation.ps and installation.txt  for
          installation  instructions and a list of the targeted archi-
          tectures. The .ps file is a preformatted PostScript  version
          suitable  for  printing  on a LaserWriter or similar device;
          the .txt file is a preformatted textual version suitable for
          printing on a lineprinter.

               Scorpion comes from
               The Scorpion Project
               Department of Computer Science
               Gould-Simpson Building
               The University of Arizona
               Tucson, AZ 85721

               (602) 621-8448

               The Scorpion  Project  was  started  by  Prof.  Richard
          Snodgrass as an outgrowth of the SoftLab Project (which pro-
          duced the IDL Toolkit) that he started when he  was  at  the
          University  of  North  Carolina.   The  Scorpion  Project is
          directed by him at the University of Arizona  and  by  Karen
          Shannon at the University of North Carolina at Chapel Hill.

               We can be reached by electronic mail at:
               scorpion-project@cs.arizona.edu
                                       (Internet)
                ...    {uunet,    allegra,     noao}!arizona!scorpion-
               project    (uucp)

               You can join an electronic mailing list for discussions
          of Scorpion topics by sending your email address to
               info-scorpion-request@cs.arizona.edu
          We'll respond with information concerning the  use  of  this
          mailing list.

               Scorpion  is  a   medium-scale   software   development
          environment.  It  contains  some  20 tools that use a common
          representation (termed Candle).  Scorpion consists of  about
          110K source lines of code (the vast majority in C, with some
          Pascal, lex, yacc, and IDL code thrown in).   Scorpion  runs
          on the following machines (see the installation instructions
          for details of configurations supported): Sun-3, Sun-4,  DEC
          Vax, DEC 3100, NeXT, Sequent Symmetry, and HP 9000.

9

9                                       1










          _2.  _A_v_a_i_l_a_b_i_l_i_t_y

               Scorpion is available by mail on 1/2" magnetic tape  or
          1/4"  Sun cartridge at cost. Copies of the documentation are
          separately available (source for all of the documentation is
          provided  with  the system). For details and an order blank,
          contact the Scorpion Project at the address above.  Scorpion
          is also available via anonymous FTP from the "scorpion" sub-
          directory on cs.arizona.edu.  Directions may be found in the
          file  HowToFTP.   If  you get a copy of this material from a
          source other than the Scorpion Project, please let  us  know
          by email to the above address.  We will put you on our mail-
          ing list and inform you of corrections and updates.

               The Scorpion System is in the public domain and you may
          use  and  distribute  it as you wish. We ask that you retain
          credits referencing the University of Arizona and the  indi-
          vidual  authors  of  the  tools  and  that  you identify any
          changes you make.

               We can't provide a warranty with Scorpion; it is up  to
          you  to  determine  its suitability and reliability for your
          needs. We do intend to  continue  to  develop  and  maintain
          Scorpion  as resources permit, and would like to hear of any
          problems.

          _3.  _S_y_s_t_e_m _O_v_e_r_v_i_e_w

               The Scorpion System is a _m_e_t_a-_e_n_v_i_r_o_n_m_e_n_t, that  is,  a
          software  development environment (SDE) tailored to the pro-
          duction of target SDEs. Scorpion supports  communication  of
          fine-grained data between tools in the target SDE. We strive
          to  be  independent  of  the  data  specification  formalism
          (currently we use the Interface Description Language (IDL)),
          independent of the underlying coarse grained storage mechan-
          ism,  independent  of  the  target programming language, and
          independent of the machine architecture.

               IDL was defined at Carnegie Mellon University  in  1980
          by  John Nestor, William Wulf, and David Lamb.  The language
          allows graph structures containing attributed  nodes  to  be
          described.   It  provides  a class type system with multiple
          inheritance. IDL specifies only the data  component;  method
          components are supplied by multiple conventional programming
          languages.  IDL was designed to specify structures, such  as
          parse trees, symbol tables, and computation graphs, that are
          commonly passed between  tools  in  an  SDE.  As  such,  the
          language   can  be  characterized  as  expressing  a  static
          description of complex  data  containing  fine-grained  com-
          ponents.

               The active portions of an application are specified  as
          "processes"  that  have  typed I/O ports. These descriptions


                                       2










          get translated into target language data specifications  and
          library  routines,  so  that  the process can read and write
          instances of those port types.  Basic  type  generators  are
          sets  and  sequences,  from  which  iterators are generated.
          Since IDL's type model is more general that most programming
          language models, the IDL compiler has to map from IDL to the
          language type model. Multiple representations, e.g., of sets
          as linked lists or as arrays, are supported.

               The Scorpion System is an  outgrowth  of  our  previous
          system,  the  IDL  Toolkit.  The new system differs from the
          old one in two ways. First, we are investigating  techniques
          and approaches to tool integration that are independent of a
          particular data specification language such as IDL.  Second,
          the  system  is  an  _i_n_t_e_g_r_a_t_e_d  development environment, as
          opposed to a _t_o_o_l_k_i_t, in which the tools are fairly indepen-
          dent  of one another.  However, we strive to maintain compa-
          tibility with the old system, and have  been  successful  to
          date.

               Scorpion contains a fairly large collection of  closely
          interacting tools.  Some tools generate portions of the tar-
          get environment from the interface descriptions.  There  are
          auxiliary tools for displaying instances and specifications.
          Scorpion has been used to construct a variety of specialized
          programming   environments,  including  those  that  support
          change management (the Infuse System developed at Bell  Labs
          and  Columbia  University),  parallel  programming  (Georgia
          Tech), design  format  transformation  (Purdue  University),
          ECAD  (RECAL/REDAC), conventional compilation (University of
          New Hampshire), microcode optimization (University of  North
          Carolina),  silicon compilation (Columbia University), data-
          base query analysis (University of Arizona), and  of  course
          the Scorpion System itself.

               Future directions for Scorpion include  supporting  (a)
          _s_e_m_a_n_t_i_c  _c_l_u_s_t_e_r_i_n_g,  which  allows  portions of graph data
          structures to be very efficiently transmitted between  tools
          and persistent repositories, (b) _e_v_o_l_u_t_i_o_n _r_e_s_i_l_i_e_n_c_e, which
          is the ability to change the  specification  of  the  target
          environment  in some way and regenerate the environment very
          quickly, yet also retain the ability  to  later  generate  a
          highly  efficient  environment, (c) other data specification
          formalisms,  (d)  other  coarse-grained  storage  mechanisms
          (Scorpion  currently  supports Unix files and pipes, and SUN
          XDR/RPC  somewhat),  and  (e)   other   target   programming
          languages (Scorpion currently supports C and Pascal).

          _4.  _D_o_c_u_m_e_n_t_a_t_i_o_n

               Release 5.0 comes with the following documents  in  the
          doc  directory  of  the Scorpion System, comprising some 500
          pages of material.


                                       3










          o+ Read Me First (this document)

          o+ Installation Instructions for the Scorpion System

          o+ Scorpion Release Notes

          o+ Scorpion Tutorial

          o+ The IDL Book: Errata and Additions

          o+ Scorpion System Manual Pages

          o+ idlc User Manual

          o+ lister and errordb User Manual

          o+ idlview User Manual

          o+ treepr User Manual

          o+ idlview Implementation Manual

          o+ treepr Implementation Manual

          o+ Using IDL in a Heterogeneous Environment

          _5.  _W_h_a_t _T_o _R_e_a_d

               The Installation Instructions should be read  carefully
          and the installation performed before proceeding further. At
          that point, the examples in the  Scorpion  Tutorial  can  be
          tried;  this  will give you a good idea of what Scorpion was
          designed to do and the tools available within Scorpion. Most
          of  the tools in Scorpion are illustrated in the examples in
          the tutorial.

               The book, "The Interface Description Language:  Defini-
          tion  and  Use," by Richard Snodgrass, published by Computer
          Science Press in 1989 (ISBN 0-7167-8198-0, available through
          your  bookstore  or from the above address), is an essential
          introduction and reference text for using Scorpion. The book
          describes,  among other things, how to use some of the tools
          in the system.  It also provides several extensive  tutorial
          programs in Part I, precise descriptions of IDL and its map-
          pings to C and Pascal in Part  II,  an  even  more  detailed
          example  program in Part III, and implementation details for
          some of the major tools, including the IDL compiler, in Part
          IV.  The  appendices  provide  important reference material.
          "The IDL Book: Errata and Additions" lists  the  changes  to
          the  book  vis-a-vis  the current release of the system. Any
          serious user of the Scorpion System will need a copy of this
          book.
9

9                                       4










               The Release Notes will  be  of  interest  primarily  to
          those  who  have  used  previous  versions of the system. It
          enumerates  the  changes  and  additions  made  to  previous
          releases  to generate the current version.  The Manual Pages
          should at least be skimmed by new users to get a rough  idea
          of  what tools are available. The User Manuals are primarily
          for reference, though some include  tutorial  portions.  The
          Implementation  Manuals are for those who wish to modify the
          tools.  Finally, the document "Using IDL in a  Heterogeneous
          Environment"   gives   guidelines   for   interfacing  tools
          developed with Scorpion with tools developed  externally  to
          Scorpion, with examples from the Cornell Program Synthesizer
          Generator and Sun's Remote Procedure Call.

               Finally, all users should read the NOTES file  included
          with  the release.  This file details the fixes and existing
          bugs in the current release,  beyond  those  listed  in  the
          release notes.

          _6.  _S_h_o_r_t-_t_e_r_m _P_l_a_n_s

               Section 3 listed the primary  technical  directions  of
          the  Scorpion  Project.  Our current activity (no promises!)
          involves making three significant  enhancements.  First,  we
          are rewriting the readers and writers to be table-driven, to
          more easily support  binary  I/O  and  semantic  clustering,
          which will increase the I/O performance by one to three ord-
          ers of magnitude.  Second, we plan to replace  the  somewhat
          awkward  C  language  interface  with  a much less intrusive
          "language veneer", implemented using a C-to-C  preprocessor.
          Third,  we  are  working  on  a  tool  to  enable reading of
          instances at compile time. This tool translates an  instance
          into  an  object  code file that can be linked with programs
          that wish to read that instance.  All three  extensions  are
          well underway; prototypes currently exist, but they have not
          been  completed  nor  integrated  into  the  system.   These
          enhancements  will  substantially  increase both the perfor-
          mance and the ease of programming of  tools  developed  with
          the system, including the Scorpion System itself.


          _7.  _A_c_k_n_o_w_l_e_d_g_e_m_e_n_t_s

               We wish to acknowledge support through the  years  from
          the  following.   IBM  provided  partial  support  through a
          Junior Faculty Award to Richard  Snodgrass.  This  work  was
          supported in part by the National Science Foundation through
          grants DCR-8402339 and IRI-8902707,  and  through  CISE  IIP
          grants  CDA-8722752  (to the Department of Computer Science,
          the University of North Carolina) and  CDA-8822652  (to  the
          Department  of Computer Science, the University of Arizona),
          and by the Office of Naval Research under  contract  N00014-
          86-K-0680  to  the Department of Computer Science, UNC.  The


                                       5










          Software Engineering Institute at Carnegie Mellon University
          indirectly  provided  support.   The Departments of Computer
          Science at the University of Arizona and at  the  University
          of  North  Carolina  at  Chapel Hill have provided excellent
          research environments for the development  of  the  Scorpion
          System and the concepts encapsulated therein.














































9

9                                       6



