home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 200-299 / ff239.lzh / JGoodies / About_JForth < prev    next >
Text File  |  1989-08-21  |  9KB  |  216 lines
  1.  
  2.  
  3.  
  4.  
  5.  
  6.     About JForth Professional V2.0 
  7.  
  8.     Vital Statistics: 
  9.  
  10.             32 bit Forth based on the '83 standard.
  11.             Full Amiga Access
  12.             Fast, Small Standalone Royalty Free Applications
  13.             Compiles directly to 68000 machine code for fast execution
  14.             Hashed Dictionary for fast compilation
  15.  
  16.     JForth Professional 2.0 is a programming language that allows
  17.     you to create standalone applications that are roughly
  18.     equivalent in size and speed to those written in 'C'.  Unlike
  19.     'C', however, JForth provides an interactive programming
  20.     environment that speeds up your development.  When you work in
  21.     JForth, you are in an interactive command line environment that
  22.     allows you to call any routine or examine any data structure.
  23.     You can compile routines right from the keyboard or from a
  24.     file.  Small programs can be compiled in a few seconds which
  25.     means you spend more time creating and less time waiting.  
  26.  
  27.     JForth is a little different from traditional Forths, eg.
  28.     MultiForth, since JForth compiles directly to 68000 machine
  29.     code.  We also cache the "top of stack" in a data register.
  30.     These two features mean that your programs will execute about 2
  31.     to 3 times faster then with a traditional Forth.  If you are
  32.     writing games, word processors, music programs, or any program
  33.     where speed is important, JForth has an advantage.  (MultiForth
  34.     is a trademark of Creative Solutions.) 
  35.  
  36.     JForth has a complete and easy interface to the Amiga's
  37.     toolbox.  JForth allows you to call any Amiga library routine by
  38.     name.  It automatically takes care of the 68000 register
  39.     assignments and library offsets (unlike some languages).  Since
  40.     the Amiga uses structure addresses as parameters for almost all
  41.     of its routines, we have simplified the use of structures.  In
  42.     JForth, structures can be referenced with automatic sizing and
  43.     sign extension as in 'C'.  You don't have to remember whether a
  44.     structure member is 8, 16, or 32 bits, or signed, like you do
  45.     with MultiForth.  We also have some tools that give you on-line
  46.     documentation and help with debugging.  The ARGS command will
  47.     show you the parameters for any Amiga function.  The DST command
  48.     will dump the contents of a structure and show the names of all
  49.     of its members.  
  50.  
  51.     We have also added some toolboxes to further simplify Amiga
  52.     programming.  An example is the EZMenu system which makes it
  53.     easy to add text based pull down menus to your applications.  An
  54.     example of using EZMenus can be found in the December, 1988
  55.     issue of Amazing Computing on page 79.  
  56.  
  57.  
  58.     Programs can be written using either normal text files or
  59.     traditional BLOCK files.  We use Emacs in our development but
  60.     you can use your favorite editor.  We have a word called FILE?
  61.     that will tell you what file a word was compiled from.  If you
  62.     like, it will then show you the source code for that word if the
  63.     source is available.  We provide source code for all of JForth
  64.     except the assembly language kernel.  
  65.  
  66.     Delta Research recently released a new version of JForth called
  67.     JForth Professional 2.0.  The most significant new feature of
  68.     JForth 2.0 is Clone, the "Optimizing Target Compiler".  Clone
  69.     can be used to create royalty free applications as small as 3K.
  70.     Clone works by examining a compiled Forth application, and then
  71.     building a new executable image containing only the code and
  72.     data needed.  This makes it easy for you to create new CLI
  73.     commands, games, or other applications, that you can sell or
  74.     give away.  
  75.  
  76.     Other new features include: 
  77.  
  78.       Source Level Debugger with breakpoints, and single step.  You
  79.       can step through your code as it executes and see what is on
  80.       the stacks, examine data structures, dump memory, etc.  
  81.  
  82.       Precompiled, dynamically linkable modules for 'include' files,
  83.       and the Assembler and Disassembler.  Now structure definitions
  84.       and the Assembler won't take up space in your dictionary.
  85.       They are simply attached to the side when needed.  
  86.  
  87.       Hashed Dictionary for 2-8 times faster compilation.  Small
  88.       programs compile in a few seconds so your productivity is
  89.       improved.  
  90.  
  91.       Command Line History like the Amiga DOS Shell (built in so
  92.       that the Forth word KEY works properly).  
  93.  
  94.       User Assignable Function Keys.  
  95.  
  96.       IFF Support for read and write, plus simple bitmap animation
  97.       system with blits, wipes, and fades. This makes it easy to use
  98.       images from paint programs in your applications.  
  99.  
  100.       New Forth Vendor Group Standard 32 bit FFP and 64 bit IEEE
  101.       Floating Point using Amiga libraries.  Support for
  102.       transcendental functions, enhanced number formatting, plus
  103.       many optional extensions.  
  104.  
  105.       ODE is an Object Oriented Development Environment similar to
  106.       SmallTalk that can be loaded on top of JForth if you like.
  107.       Object Oriented programming is a technique that simplifies
  108.       programming through the use of "intelligent data structures".
  109.       ODE supports class definitions, inheritance, late binding, and
  110.       dynamic instantiation.  ODE now allows nested objects as
  111.       "instance variables".  
  112.  
  113.       Numerous new tools and utilities including Serial I/O, sample
  114.       applications and new graphics demos, documentation generator,
  115.       etc.  
  116.  
  117.       The new manual includes many new tutorials and an expanded
  118.       reference section.  We have a complete Forth tutorial at the
  119.       beginning of the manual.  We do recommend, however, that you
  120.       get one of the many execllent Forth textbooks, and the Amiga
  121.       ROM Kernel and Intuition Manuals.  
  122.  
  123.     JForth Professional 2.0 is available from retailers at a
  124.     suggested list price of $179.95.  Registered JForth 1.2 users
  125.     can receive a full upgrade to 2.0 for $50.00 plus the ORIGINAL
  126.     "EXTRAS" disk (the one with the executable JForth image).  A
  127.     "Clone Only" upgrade is also available for $10.00 for one disk
  128.     with documentation on disk.  We strongly recommend, however,
  129.     that people get the full $50 upgrade because of the other new
  130.     features.  (A new HMSL disk that uses the new JForth features is
  131.     available to registered HMSL users for $10.  HMSL is an
  132.     experimental music language based on JForth.) CA residents add
  133.     6% sales tax.  
  134.  
  135.     Inquiries and upgrade requests can be sent to: 
  136.  
  137.         Delta Research 
  138.         Box 1051 
  139.         San Rafael, CA 
  140.         94915 
  141.  
  142.     or call:   (415) 461-1442 
  143.  
  144.     ------------------------------------- 
  145.  
  146.     How to Read The Example Programs.  
  147.  
  148.     Use the Textra editor to view the source code files or TYPE them
  149.     from the CLI. To print them you can copy them to the printer,
  150.     for example: 
  151.  
  152.             CD JGOODIES_1:JustBeeps 
  153.             TYPE JustBeeps.f 
  154.             COPY JustBeeps.f PRT: 
  155.  
  156.     If you are not familiar with Forth, this may help you understand
  157.     what you are reading.  This is a very brief description of
  158.     Forth.  I cannot teach Forth in one page but this will get you
  159.     started.  
  160.  
  161.     Forth uses a simple syntax; words with spaces between them.  The
  162.     words are executed in the order they appear.  Parameters, like
  163.     numbers and addresses, are placed on a stack that all the words
  164.     can use.  
  165.  
  166.     Forth uses a ':' to begin the definition of a subroutine.  Here
  167.     is a Forth definition that will print "Hello World!".  
  168.  
  169.             : HI  ( -- , print message ) 
  170.                 ." Hello World!" CR 
  171.             ; 
  172.             HI 
  173.  
  174.     The word immediately after the ':' is the name of the routine,
  175.     in this case "HI".  The text between parentheses is a comment
  176.     for people reading the code and is ignored by the compiler. A
  177.     backslash '\' can also be used to comment out the rest of a
  178.     line.  The ." is a word that says to print the following text.
  179.     The CR outputs a carriage return.  The ';' ends the definition.
  180.     This program would take less then a second to compile and link.
  181.     The bottom line calls the new routine to test it.  
  182.  
  183.     Here is another definition: 
  184.  
  185.             : CHECK.ALTITUDE  ( altitude -- , too high? ) 
  186.                 10,000 > 
  187.                 IF ." Help! We are going too high!" CR 
  188.                 ELSE ." Everything's OK." CR 
  189.                 THEN 
  190.             ; 
  191.             7,000 check.altitude  ( test our new word ) 
  192.             14,000 check.altitude 
  193.  
  194.     The comment in this definition contains a "stack diagram".
  195.     Stack diagrams tell the person reading the code what is passed
  196.     on the stack as input and what is returned as output.  The
  197.     parameters before the "--" are input.  In this case the altitude
  198.     is expected to be on the stack when the word is executed.  After
  199.     the "--" and before the "," there is nothing, which means it
  200.     does not return a stack value.  The first line of the definition
  201.     compares the input to 10,000.  IF the value on the stack is
  202.     greater, it will print "Too high!", or ELSE it will says things
  203.     are OK.  The THEN terminates the conditional statement.  When a
  204.     number is entered, its value is left on the stack.  This makes
  205.     it easy to test a word as you can see.  
  206.  
  207.     If you want to learn more about Forth, call us, or get "Starting
  208.     Forth" by Leo Brodie, or "Forth: A Text and Reference" by Kelly
  209.     and Spies. Both texts are excellent.  
  210.  
  211.     Happy Hacking, 
  212.  
  213.     Phil Burk 
  214.  
  215.  
  216.