                    Chapter 2 - Getting started in Modula-2


                         OUR FIRST MODULA-2 PROGRAM

             We are ready to look at our first instructional program
        in Modula-2.  Assuming that you have a full screen editor of
        some  type,  load the program PUPPYDOG.MOD and display it on
        your  screen.  It  is  an example of  the  minimum  Modula-2
        program.  There  is  nothing that can be left  out  of  this
        program and still have a compileable, executable program.

             The first word in the program,  "MODULE",  is the  name
        that  identifies a module,  and it must be written as  given
        here,  in all capital letters.  During the entire first part
        of  this tutorial,  we will use only this type of a  module.
        There  are  other types but we will not look at any of  them
        until  we  get  to part  III  of  this  tutorial.   Modula-2
        requires  us  to  name  our module so we  give  it  a  name,
        "PuppyDog".   We  could have used any name that qualifies as
        an identifier but we have chosen a name that has nothing  to
        do  with computers as an illustration that any name could be
        used.  In a practical program, you would probably use a name
        that was descriptive of the program in some way.

                             WHAT IS AN IDENTIFIER?

             An  identifier is a combination of letters and  numbers
        that  Modula-2  uses to identify a variable,  program  name,
        procedure name,  and several other quantities.  In Modula-2,
        an identifier is composed of any number of  characters.  The
        characters   may  be  any  mix  of  alphabetic  and  numeric
        characters,  but  the first character must be an  alphabetic
        character.    The   case  of  the  alphabetic  character  is
        significant  such that "IdentNumber1",  "IDENTNUMBER1",  and
        "IdEnTnUmBeR1" are all different identifiers.   No spaces or
        any other special characters are allowed.

                  BACK TO THE PROGRAM UNDER CONSIDERATION

             The  "header"  line  is  terminated  with  a  semicolon
        according to the formal definition of Modula-2.  A semicolon
        is  a  statement  separator and many will be used  in  large
        programs.   Following the semicolon,  we come to the program
        itself.  The program statements are enclosed between the two
        words  "BEGIN"  and  "END".   In  this  case  there  are  no
        statements,  but  if there were some,  they would be  placed
        between the two indicated words.   Finally,  the module name
        is repeated after the "END" and it is followed by a  period.
        The  module  name is repeated in order to make  the  program
        easier to understand by clearly marking its limits.  In this
        case  it  really doesn't add to the clarity of the  program,
        but  in a large program it can be of significant help.   The
        period marks the end of the listing and can be thought of as


                                   Page 8









                    Chapter 2 - Getting started in Modula-2


        the period that marks the end of a sentence.

             The three words,  MODULE,  BEGIN,  and END, are special
        words  in Modula-2.  They are "reserved words" because  they
        are  used for a specific purpose and cannot be used for  any
        other  purpose.  They are not available for your use in  any
        way except for the defined purpose.   The reserved words  in
        Modula-2  are  always capitalized or the compiler  will  not
        consider them as reserved words.   Remember that  alphabetic
        characters  must  have the correct case in  Modula-2.   Some
        other  languages,  most  notably Pascal,  allow you  to  use
        either case anywhere and it converts them internally so that
        they  are the same.   It would be permissible for you to use
        words  such as "Begin" or "End" as variables in  a  Modula-2
        program,  but it would be very poor programming practice and
        should be avoided.   We will come across many other reserved
        words  in  these  lessons.  There are 40 reserved  words  in
        Modula-2.

             You should have learned how to use your compiler by now
        so  you  can  compile and run  this  program.   It  will  do
        nothing,  but  that  is significant in  itself,  because  it
        should  at  least  return to the operating system  after  it
        finishes doing nothing.   That may sound a little silly, but
        it  does  take  a considerable amount  of  effort  to  load,
        transfer control to the program,  and set up linkage back to
        your Disk Operating System.

             It  should  be  noted at this time  that  the  Modula-2
        compiler  doesn't care about extra blanks or  linefeeds  and
        the   careful  programmer  will  insert  extra  blanks   and
        linefeeds  as desired in order to make the program easier to
        read.   As you continue to program in Modula-2,  you will no
        doubt  develop  a  style  of your  own  and  hopefully  your
        programs can be read easily by other programmers.

                       A PROGRAM THAT DOES SOMETHING

             Load  and display the program named WRITESM.MOD for  an
        example  of a Modula-2 program that does  something.   First
        you should notice that the elements of the first program are
        still  here as they will be in every Modula-2 program.   The
        same three reserved words are used here as before,  but  now
        there are some added statements.

             The  line  near  the beginning  that  begins  with  the
        reserved  word "FROM" is a special line that must be used in
        any program that accesses external procedures.   We will not
        try to define this line at this time.  We will only say that
        every  external  call in Modula-2 requires a  definition  of
        where to find the procedure.   The module named "InOut" is a


                                   Page 9









                    Chapter 2 - Getting started in Modula-2


        collection  of input and output routines that are  available
        for our use and this line in the program tells the system to
        look  in  the "InOut" collection for  the  procedures  named
        "WriteLn"  and WriteString".   When the program needs  these
        particular  functions to do what we ask it to do,  it  knows
        where to find them.  We will cover the IMPORT list in detail
        later in this tutorial.   Until then, simply use the example
        programs  as  a  guide  when you wish to  write  a  practice
        program.

                        OUR FIRST PROGRAM STATEMENTS

             Between the BEGIN and END statements,  which we defined
        previously as the place where the actual program is  placed,
        we  have a series of "WriteString" and WriteLn"  statements.
        These  statements are almost self explanatory,  but we  will
        say a few words about them anyway.  Each line is a call to a
        "procedure"  which is a very important feature of  Modula-2.
        A "procedure" is an external servant that does a certain job
        for  us  in  a  well  defined  way.   In  the  case  of  the
        "WriteString", it looks at the string of characters supplied
        to  it and displays the string of characters on the  monitor
        at the current cursor position. In the case of the "WriteLn"
        procedure,  it  serves us by moving the cursor down one line
        on the monitor and moving it to the left side of the screen.

             The  parentheses  are  required  for  the   WriteString
        because  it  has  data following it.   The data  within  the
        parentheses  is data supplied to our slave  or  helper.   It
        gets the string of characters between the quotation marks or
        the apostrophes and displays the string on the monitor.  You
        have  a  choice  of delimiters so that you  can  output  the
        delimiters  themselves.  If you desire to output a quotation
        mark to the monitor,  use apostrophes for delimiters, and if
        you wish to output apostrophes, use quotation marks.  If you
        wish  to  output  both,  break the line  up  and  output  it
        piecemeal as in the last example line.

             This program should be very clear to you by now.  First
        we tell the system where to get the procedures, then we list
        the procedures in the order required to produce the  desired
        results.   It  should  be  apparent that the  lines  of  the
        program  between the reserved words BEGIN and END are simply
        executed in order.   Compile and run the program and observe
        the output on your monitor.   It should be mentioned at this
        point  that  it is possible to redirect the  output  to  the
        printer  or to a disk file but we will not be doing that for
        quite  some  time.   We will stay with the basic  syntax  of
        Modula-2 for now.




                                   Page 10









                    Chapter 2 - Getting started in Modula-2


                             MODULA-2 COMMENTS

             No program is complete without a few comments  embedded
        in  the  program as notes to the programmer  describing  the
        reasons  for  doing some particular thing.   The  notes  are
        particularly  helpful  to another programmer  who  needs  to
        modify  the program some day.   It is not necessary for  the
        computer to understand the notes and in fact, you don't want
        the computer to try to understand the notes, so you tell the
        compiler to ignore the notes completely.  How to do this  is
        the  object of our next program named MODCOMS.MOD which  you
        should load and display on your monitor.

             In Modula-2,  comments are enclosed in pairs of  double
        characters.  The comment is started with the "(*", and ended
        with  the  "*)".   The program on your monitor  has  several
        examples of comments in it.  If the comments were completely
        removed,  the  program would be very similar to the last one
        but  a  lot shorter.   Notice that comments  can  go  nearly
        anywhere  in a program,  even before the header statement or
        after the ending period.   Comments can be used to remove  a
        section  of  program from consideration by the  compiler  so
        that  a  particularly  troublesome section of  code  can  be
        "commented  out" until you solve some of the other  problems
        in  program  debugging.   It is important to  remember  that
        comments  can  be "nested" in Modula-2 so that a section  of
        code  can  be  "commented out" even  if  it  contains  other
        comments.

             This  particular program is not meant to be an  example
        of  good commenting.  It is really a sloppy looking  program
        that would need some work to put it into a good  style,  but
        it does illustrate where it is possible to put comments.

                           GOOD PROGRAMMING STYLE

             Load  and display the program named GOODFORM.MOD for an
        example of a well formatted program.   Since Modula-2 allows
        you to use extra spaces and blank lines freely,  you  should
        use  them  in any way you can to make your programs easy  to
        understand, and therefore easy to debug and modify.  Special
        care  has been given to style in this program and  it  payed
        off  in a very easy to understand program.   Even with  your
        very  limited knowledge of Modula-2 programming you can very
        quickly decipher what it does.  It is so well formatted that
        comments are not needed and they would probably detract from
        its  readability.   No further comment is needed or will  be
        given.   Compile and run this program to see if it does what
        you think it will do.




                                   Page 11









                    Chapter 2 - Getting started in Modula-2


                           REALLY BAD FORMATTING

             Load and display UGLYFORM.MOD for an excellent  example
        of  bad  formatting.   If you can see at a glance what  this
        program  does you deserve the Nobel Prize for  understanding
        software  if  such  a thing exists.   The  syntax  for  this
        program  follows  all of the rules of  Modula-2  programming
        except for good style.   Without saying anything else  about
        this  mess,  I would suggest that you try to compile and run
        it.   You may be surprised to find that it does compile  and
        run,  and in fact it is identical to the last program.  Keep
        in mind that you can add extra blanks and linefeeds anyplace
        you desire in a program to improve its readability.

             Hopefully,  the last two programs will be an indication
        to you that good programming style is important and can be a
        tremendous  aid in understanding what a program is  supposed
        to do.   You will develop your own programming style as time
        goes by.   It is good for you to spend some effort in making
        your  program look good,  but don't get too excited about it
        yet.   Initially,  you should expend your effort in learning
        how to program in Modula-2 with reasonable style and  strive
        to improve your style as you go along.  It would be good for
        now  if  you simply tried to copy the style given  in  these
        lessons.

        PROGRAMMING EXERCISES

        1.   Write  a  program that will display your name  on  the
             monitor.

        2.   Write  a  program that will display your name  on  the
             monitor along  with your address, city and state  in 3
             separate lines.

        3.   Add a comment to the MODCOMS.MOD file between the words
             "IMPORT"  and  "WriteLn"  to see if the  compiler  will
             allow you to put a comment within a statement.















                                   Page 12
