Trailing-Edge
-
PDP-10 Archives
-
decuslib10-04
-
43,50334/tops11.gno
There are no other files named tops11.gno in the archive.
%switch qz false
%if qz
%nocontrolc
%nextlesson pub("TOPQ");
%ifend qz
%text languages:
Programming languages.
=====================
This section contains some value judgments concerning
the qualities of various programming languages. These
value judgments are only valid when comparing different
languages on the DEC 10. They are n o t valid when
comparing languages on different computers.
Example: When I say that MACRO 10 gives bad readability,
I mean that MACRO 10 gives bad readability compared to
other programming languages on the DEC 10.
I do n o t mean that MACRO 10 gives bad readability
compared to other assemblers on other computers.
%text
Here are some of the programming languages on the DEC 10:
LANGUAGE Com- Inter- Num- Data Machine Notes
piler preter eri- struc- indepen-
cal tures dent
-----------------------------------------------------------------------
AID no yes yes few no Slow execution. For simple
desk calculator applications.
ALGOL yes no yes few somewhat Secure language giving readable
programs and efficient execution.
APL no yes yes yes yes Not very fast. Short powerful
commands. Not very readable.
BASIC yes no yes few yes Easy to learn. Not very fast.
%text
And here are some more programming languages on the DEC 10:
LANGUAGE Com- Inter- Num- Data Machine Notes
piler preter eri- struc- indepen-
cal tures dent
-----------------------------------------------------------------------
BLISS yes no yes many no Machine close. Efficient.
Readable. Bad security.
COBOL yes no some some yes Most suited for advanced
file handling.
FORTRAN yes no yes few somewhat Efficient execution. Bad
security and readability.
LISP yes yes yes many yes General purpose. Short clear
programs. Bad memory-efficiency.
MACRO 10 yes no yes no/all no! Assembler with macro processor.
Very bad security and readability.
PASCAL yes no yes yes yes Good readability and structuring
in spite of simplicity.
SIMULA yes no yes many verygood General purpose. Efficient.
Readable and secure programs.
SNOBOL yes yes some yes verygood For simple text-processing
applications.
%question comment yes or no: look at listing;
Do you want to look at the list of languages once more?
%extra
%neutral yes
%goto languages
%neutral yeah
%same
%neu y
%same
%wrong nej
I do not understand swedish.
%neutral no
%goto next
%neu n
%same
%wrong
Answer "yes" or "no".
%question
This lesson contains an automatic algorithm which will ask you some
questions and then recommend which programming language might suit you.
Do you want to use that algorithm?
%extra
%noorder
%neutral yes
%goto choice
%neutral yeah
%same
%neu y
%same
%neutral no
%goto next
%neu n
%same
%qend
%algol if false then choice:
begin
integer aid, algol, apl, basic, bliss, cobol, fortran, lisp, macro,
pascal, simula, snobol, max, now, i, number, blank, asterisk;
real merit,val;
integer array valu[1:12]; string array name[1:12];
procedure extratest;;
procedure add(language,addvalu);
value language, addvalu;
integer language, addvalu;
valu[language]:= valu[language]+addvalu;
blank:= " ".[1]; asterisk:= "*".[1];
AID:= 1; name[AID]:= "AID";
ALGOL:= 2; name[ALGOL]:= "ALGOL";
APL:= 3; name[APL]:= "APL";
BASIC:= 4; name[BASIC]:= "BASIC";
BLISS:= 5; name[BLISS]:= "BLISS";
COBOL:= 6; name[COBOL]:= "COBOL";
FORTRAN:= 7; name[FORTRAN]:= "FORTRAN";
LISP:= 8; name[LISP]:= "LISP";
MACRO:= 9; name[MACRO]:= "MACRO 10";
PASCAL:= 10; name[PASCAL]:= "PASCAL";
SIMULA:= 11; name[SIMULA]:= "SIMULA";
SNOBOL:= 12; name[SNOBOL]:= "SNOBOL";
for now:= 1 step 1 until 12 do valu[now]:= 0;
%text
The program will ask you a number of question about your
requirements on the programming language. Please do not answer
that all requirements are important to you. No language can
satisfy all different requirements. You have to make a choice
and only indicate that you need those properties of a language
which are especially important to you.
%question
Is it important for you to be able to transfer your programs easily
to another computer from another manufacturer, even if this restricts
the possibillity to choose the most suitable language for your needs?
Answer "very much", "somewhat" or "no".
%extra
%neutral very
%algol val:= 2; goto next;
%neutral somewhat
%algol val:= 1; goto next;
%neutral n
%algol val:= 0; goto next;
%wrong
Answer either "very" or "somewhat" or "no".
%qend
%algol
add(algol,val*2); add(apl,val); add(basic,val*2); add(cobol,val*2);
add(fortran,val*2); add(lisp,val); add(simula,val*2); add(snobol,val*3);
add(bliss,-2*val); add(macro,-2*val); add(pascal,val*2);
%question nopause:= true;
Is it important for you to be able to use large existing libraries of
subroutines for numerical applications?
Answer "very much", "somewhat" or "no".
%neutral very
%algol val:= 2; goto next;
%neutral somewhat
%algol val:= 1; goto next;
%neutral n
%algol val:= 0; goto next;
%wrong
Answer either "very" or "somewhat" or "no".
%qend
%algol
add(fortran,2*val); add(algol,val); add(simula,val); add(bliss,val);
add(macro,val);
%question nopause:= true;
Do you want good availability of system functions like timing routines,
job scheduling routines and other system managment functions, even
if this means a language which is more difficult to learn and use?
Answer "very much", "somewhat" or "no".
%neutral very
%algol val:= 2; goto next;
%neutral somewhat
%algol val:= 1; goto next;
%neutral n
%algol val:= 0; goto next;
%wrong
Answer either "very" or "somewhat" or "no".
%qend
%algol
add(macro,2*val); add(bliss,2*val); add(aid,-val); add(apl,-val);
add(basic,-val); add(pascal, -val);
%question nopause:= true;
Will your largest application programs be:
small(less than 100 lines),
medium(100-300 lines) or
large(longer than 300 lines?
Answer "small", "medium" or "large".
%neutral small
%algol
add(aid,2); add(apl,1); add(basic,1); add(snobol,1);
goto next;
%neutral large
%algol
add(apl,-1); add(basic,-2); add(snobol,-2);
add(pascal,2); add(bliss,3); add(fortran,1); add(simula,3);
goto next;
%neutral medium
%goto next
%question nopause:= true;
Will your applications include very much numerical calculations?
%neutral y
%algol
add(snobol,-2); add(lisp,-1); add(cobol,-2);
goto next;
%neutral yeah
%same
%neutral n
%goto next;
%wrong
Answer either "yes" or "no".
%question nopause:= true;
Will your applications include very much text string processing?
%neutral y
%algol
add(snobol,5); add(lisp,3); add(simula,3); add(apl,2);
add(pascal,1);
goto next;
%neutral yeah
%same
%neutral n
%goto next;
%wrong
Answer either "yes" or "no".
%question nopause:= true;
Will your applications include very much complex data structures?
%neutral y
%algol
add(apl,2); add(bliss,3); add(lisp,5);
add(pascal,4); add(simula,5);
goto next;
%neutral yeah
%same
%neutral n
%goto next;
%wrong
Answer either "yes" or "no".
%question nopause:= true;
Will your applications include very much file handling on secondary
storage mediums?
%neutral y
%algol
add(cobol,6); add(aid,-3); add(basic,-2); add(bliss,3);
add(macro,4); add(snobol,-1);
add(algol,-1); add(simula,3);
add(pascal,-2); goto next;
%neutral yeah
%same
%neutral n
%goto next;
%wrong
Answer either "yes" or "no".
%question nopause:= true;
Will your applications include very much simulation programs?
%neutral y
%algol
add(simula,4); add(bliss,1); add(pascal,1);
goto next;
%neutral yeah
%same
%neutral n
%goto next;
%wrong
Answer either "yes" or "no".
%question nopause:= true;
Will you very often use multidimensional matrices?
%neutral y
%algol
add(fortran,3); add(algol, 3); add(basic,3); add(apl,3);
goto next;
%neutral yeah
%same
%neutral n
%goto next
%wrong
Answer "yes" or "no".
%goto repeat
%question nopause:= true;
Do you want a general purpose language, suitable for many diverse
programming tasks using the same language, even if it will take
you more time to learn this language?
Answer "very much", "somewhat" or "no".
%neutral very
%algol
add(simula,3); add(bliss,3); add(macro,3); add(pascal,1); add(lisp,1);
goto next;
%neutral somewhat
%algol
add(basic,-1); add(aid,-3); add(lisp,1);
goto next;
%neutral n
%algol
add(aid,2); add(algol,2); add(fortran,2); add(basic,2);
goto next;
%wrong
Answer either "very" or "somewhat" or "no".
%question nopause:= true;
Do you want a language which is easy to learn, even if this
means that the language is less flexible?
Answer "very much", "somewhat" or "no".
%neutral very
%algol val:= 2; goto next;
%neutral somewhat
%algol val:= 1; goto next;
%neutral n
%algol val:= 0; goto next;
%wrong
Answer either "very" or "somewhat" or "no".
%qend
%algol
val:= val-1; add(aid,val*3); add(basic,val*2); add(lisp,-val*2);
add(simula,-val); add(macro,-val); add(bliss,-val);
%question nopause:= true;
Do you want a language in which it is easy to produce working programs,
even if this means lower machine efficiency?
Answer "very much", "somewhat" or "no".
%neutral very
%algol val:= 2; goto next;
%neutral somewhat
%algol val:= 1; goto next;
%neutral n
%algol val:= 0; goto next;
%wrong
Answer either "very" or "somewhat" or "no".
%qend
%algol
add(bliss,-3*val); add(macro,-6*val); add(fortran,-val);
add(lisp,2*val); add(simula,val); add(apl,val);
%question nopause:= true;
Do you want a language which can produce programs which utilize the
computer resources very efficiently, even if this means a considerable
increase in the necessary programming effort for you?
Answer "very much", "somewhat", or "no".
%neutral very
%algol
add(pascal,3); add(lisp,-1); add(aid,-2); add(bliss,4); add(macro,7);
goto next;
%neutral somewhat
%algol
add(bliss,2); add(macro,2); add(algol,2); add(cobol,2); add(fortran,2);
add(pascal,3); add(simula,2);
goto next;
%neutral n
%goto next;
%wrong
Answer "very", "somewhat" or "no".
%qend
%algol pause;
message:= true;
write("Here is a list of the most suitable languages[N]");
write("for you, with a merit value for each language.[N]");
write("Those with a high merit value are probably best[N]");
write("for you.[N]");
write("[N] VALUE LANGUAGE[N] ==============");
val:= 0; for now:= 1 step 1 until 12 do
val:= val+valu[now];
val:= val/12.0+1.3; if val < 0 then val:= 0;
newline;
for now:= 1 step 1 until 12 do
begin
merit:= valu[now] - val + 5;
if merit >= -6 then begin
merit:= entier(8 + (merit-8)/2);
number:= 25-merit; for i:= 1 step 1 until number do outsymbol(blank);
number:= merit; for i:= 1 step 1 until number do outsymbol(asterisk);
outsymbol(blank); write(name[now]); newline;
end;
end;
%question
Do you want to go through the questions once more, to see if
different answers would produce a different language recommendation?
%neutral y
%goto choice
%neu yes
%same
%neutral yeah
%same
%neutral n
%goto next
%neu no
%same
%wrong
Answer "yes" or "no".
%qend end; comment of the whole choice block;
%question languagelist:
If you want to know more about any of the languages, type the name
of it, or else type "NONE". You can thus type any of these words:
AID ALGOL APL BASIC BLISS COBOL FORTRAN LISP MACRO 10 PASCAL SIMULA SNOBOL NONE.
%algol nopause:= true;
%extra
%neutral AID
%goto AID
%neutral ALGOL
%goto ALGOL
%neutral APL
%goto APL
%neutral BASIC
%goto BASIC
%neutral BLISS
%goto BLISS
%neutral COBOL
%goto COBOL
%neutral FORTRAN
%goto FORTRAN
%neutral LISP
%goto LISP
%neutral MACRO 10
%goto MACRO
%neutral MACRO
%goto MACRO
%neutral 10
%goto MACRO
%neutral PASCAL
%goto PASCAL
%neutral SIMULA
%goto SIMULA
%neutral SNOBOL
%goto SNOBOL
%neutral NONE
%goto afterlanguages
%wrong
You gave none of the languages as answer, and you did not either
answer with "NONE".
%text goto languagelist; AID:
AID.
===
AID, also called JOSS, is a simple interpretive language with about
the same capabilities as an advanced desk calculator. It is mostly
suited for numerical applications. Execution is rather slow.
AID contains its own source program editor and file handler,
so that you do not have to learn TECO or SOS to use AID.
%text goto languagelist; ALGOL:
ALGOL.
=====
ALGOL is mostly suited for numerical applications, but the DEC imple-
mentation contains string-processing, though in a non-standardized
way. ALGOL gives readable and secure program and the compiler produces
efficient machine code.
%text goto languagelist; APL:
APL.
===
Each APL command is very powerful, and most of them is only one character
long. Thus APL programs are very compact, although somewhat cryptic.
The language is general-purpose with large capabilites. It is fast
for an interpreted language, but still slow compared to compiled
languages.
APL on DEC 10 is a commercial program product. APL is best suited
to terminals which have the special APL character set.
%text goto languagelist; BASIC:
BASIC.
=====
BASIC is a very simple language best suited to numerical applications.
BASIC is in many ways similar to FORTRAN, but includes commands
for manipulation of whole matrices.
BASIC uses its own line oriented editor, so that the BASIC user
does not have to learn to use a separate editor like SOS or TECO.
%text goto languagelist; BLISS:
BLISS.
=====
BLISS is especially designed for the production of large efficient
software products. BLISS is specially tailored to the DEC 10
computer architecture, and the intention is that programs in
BLISS will be almost as efficient with time and memory as the
best assembly programs.
BLISS has an ALGOL-like structure and is very much oriented to
highly blocked and highly procedured programs.
The BLISS compiler requires between 45K and 60K of core(depending
on the size of the BLISS program being compiled) and this means
that BLISS cannot be used on some small memory installations.
%text goto languagelist; COBOL:
COBOL
=====
COBOL is a language for such business applications, where you
are mostly doing input/output to files, tapes and other
i/o devices.
COBOL contains a system for on-line debugging.
%text goto languagelist; FORTRAN:
FORTRAN.
=======
FORTRAN is the most widely used language for numerical applications.
FORTRAN has many disadvantages:
Bad security(that is error checking capability),
Bad readability of programs,
No dynamic memory allocation,
Very few data structuring facilities.
FORTRAN has a system for dividing a program into separately compiled
modules, which is not very secure or flexible, but which works better
than in many more advanced languages, and this is one reason for
the popularity of FORTRAN.
%text
FORTRAN is also available on more computers than any other programming
language. FORTRAN is standardized, but the standard is a so-called
permissive standard. This means that there is no checking in most
FORTRAN systems that a program really uses only standard FORTRAN.
And since many FORTRAN compilers accept a language including
much more features than standard FORTRAN, the compatibility will be an
illusion except with rigorous programming discipline.
There is an online debugging systems, called FORDDT,
for FORTRAN programs.
%text goto languagelist; LISP:
LISP.
====
LISP programs are divided into many small procedures, which call
each other recursively. This way of writing a program will often
give simple and clear programs, once you have got used to it.
LISP is based on one very flexible kind of data structure, a kind
of linear list in which each element can itself be a list of
the same kind. This data structure can be adapted to most practical
application needs. LISP programs are themselves stored in the same
kind of data structure. This means that a LISP program can easily
manipulate or create or interpret programs in LISP or other languages.
%text
LISP programs can be executed both interpretively and compiled.
An execution can also contain a mixture of compiled and interpreted
parts.
This makes it easy in LISP to program applications where the
borderline between data and program is not very sharp.
LISP systems often do not use the memory in the computer very
efficiently.
There are two LISP systems available on the DEC 10, the
STANFORD and the BBN system. The BBN system is regarded as
the most advanced, especially for large programs requiring
virtual memory.
%text goto languagelist; MACRO:
MACRO 10.
========
MACRO 10 is a conventional assembly language with a MACRO facility.
Such languages should be avoided, since they give very high
programming cost and very bad readability of programs.
If you desire high efficiency, you will probably get better results
by first programming in an advanced high-level language like
SIMULA or LISP, and then rewriting central parts of the program
only in BLISS or MACRO 10.
There is an on-line debugging system DDT for MACRO 10 programs.
%text goto languagelist; PASCAL:
PASCAL.
======
PASCAL is a simple language, rather easy to learn and use. In spite
of this, the language has good data structuring facilities and is
well suited to readable, well structured programs. The compiler
produces efficient code, and can produce shareable, reentrant
code.
The main restrictions of PASCAL is in the area of file handling.
Also, the security and structuring facilities are not as good
as in SIMULA, but on the other hand the language is smaller and
simpler and more efficient than SIMULA.
%text goto languagelist; SIMULA:
SIMULA.
======
SIMULA is a general-purpose high-level language. Data can be
structured according to the user's wishes, including list structures
and text strings. The program can be structured into routines
executed in parallel. Data and program can be combined into a SIMULA
CLASS which is a basic element in both program and data structuring.
SIMULA contains ALGOL as a subset. Compared to most other languages,
SIMULA gives very high security. By this is meant the ability of the
system to find programmer errors and the non-existent possibillity
that the program should de-rail out of the SIMULA framework.
%text
The DEC 10 SIMULA compiler produces efficient object code
and requires a 30K memory area during compilation.
The SIMULA system for the DEC 10 contains a system for separate
compilation which is much more flexible than in FORTRAN and which,
in contrast to FORTRAN, will give full security. The DEC compiler
also contains an advanced on-line debugging system, SIMDDT.
%text goto languagelist; SNOBOL:
SNOBOL.
======
SNOBOL is especially suited for text handling applications, e.g.
- Scanning a text to find certain patterns and do something there.
- Translation between not to dissimilar languages.
- Scanning a text for correctness.
- Preparing data for input.
- Prpearing data for good-looking output.
SNOBOL is not so well suited for such very advanced text-processing,
which in reality is mostly symbol and data structure manipulation.
There, LISP or SIMULA is better suited.
There are two SNOBOL systems on the DEC 10. The official system
is slow and requires much memory. The SPTBOL system is much faster
and requires less memory, but it is a commercial program product.
%text goto languagelist; afterlanguages:
Monitor commands for compiling and loading.
==========================================
Programs in languages like FORTRAN, ALGOL or SIMULA are first compiled
and then linked using the LINK 10 or LOAD 10 loaders.
Programs in AID, APL, BASIC, LISP or SNOBOL are not handled in this
way, since those languages are either not compiled, or else use their
own linking loader. To learn how to execute programs in those languages,
you will have to look at the manual for that language.
Here is described the process using the standard DEC LINK or LOAD programs,
which is what you do with languages in ALGOL, BLISS, COBOL, FORTRAN,
MACRO 10 or SIMULA.
%text
With those languages, the source program file should have an extension
indicating the language:
.ALG for ALGOL programs,
.BLI for BLISS programs,
.CBL for COBOL programs,
.FOR for FORTRAN programs,
.MAC for MACRO 10 programs or
.SIM for SIMULA programs.
These extensions tells the system which compiler to use when compiling
your program.
%text compileload:
When you have created a source program with TECO or SOS, you want to
compile it, then load it, and then execute it. This can be done
respectively with the COMPILE monitor command,
LOAD monitor command and
START or RUN monitor command.
The COMPILE command will take a source program as input, and output
a relocatable object program with the extension .REL.
The LOAD command will take a relocatable object program with
the extension .REL as input, and will output an absolute object
program, ready to execute. This absolute object file will reside in
your core area, not on your disk area, and thus has no extension.
The START command will start the execution of the absolute program
in your core area.
%text
Example: If you have a source program in SIMULA called PROG.SIM,
then
.COMPILE PROG.SIM will compile it, and produce a relocatable object
code file called PROG.REL.
.LOAD PROG.REL will thereafter load this relocatable object code
file into an absolute program in core.
.START will start the execution of that absolute program in
core.
%question page; comment compile command;
Assume that you have an ALGOL program SORT whose source program
file is called SORT.ALG. What do you do to get it compiled?
Write the command string that you should write to the monitor
in response to the prompter "." from the monitor.
%noextra
%right COMPILE SORT.ALG
%RIGHT COMPILE SORT
%RIGHT COM SORT.ALG
%RIGHT COM SORT
%RIGHT COMP SORT.ALG
%RIGHT COMP SORT
%extra
%wrong compilesort
You forgot a space after the command name.
%wrong compsort
%same
%wrong comsort
%same
%wrong COMPILE SORT
You were right except for some extra text. Try to shorten
your text to find the correct answer.
%algol extratest;
%wrong COM SORT
%same
%wrong compile
After "COMPILE" you write a space and then the source program
file name.
%wrong ex
I didn't ask you to execute the program, only to run it.
%wrong
Use the COMPILE monitor command.
%wrong
%same
%wrong
%question comment relocatable object code;
And after this compilation of the source program file SORT.ALG,
what new kind of file is produced?
a) What kind of data does the new file contain?
%extra
%right relocatable object code
%right relocatable code
%right relocatable
%right rel
%wrong alg
The output after compilation is not source Algol any more.
%wrong source
%same
%wrong load
Are you thinking about the concept of a "LOAD MODULE"? This is IBM
terminology, and the structure of the DEC 10 is such that "LOADING"
in the IBM sense is not necessary, since the adress space of a
user program does not depend on the real core he gets as on many
IBM computers. Therefore, on the DEC 10, you can save and load
absolute core images.
%wrong sort
Do not answer with the file name, but with a description of
the character of the data in the produced file.
%wrong .rel
%same
%wrong absolut
No, the code is not yet absolute, before
loading it is relocatable.
%neutral object
Yes, but what kind of object code?
Is it relocatable or absolute?
%goto repeat
%neutral compiled
%same
%neutral binary
Yes, but try to be more precise.
What kind of binary?
%goto repeat
%lack reloc
Is the produced code relocatable or absolute?
%wrong reloc
Yes, "relocatable" is a very difficult word to spell.
%wrong
A hint: The file contains code which must be linked and loaded
before it can be executed.
%wrong
%same
%wrong
Time for some repetition.
%goto compileload
%question comment the filename of .REL files;
When the compiler has compiled your ALGOL source program SORT.ALG,
it will produce a file on disk containing the relocatable object
code for the program SORT. What will be the filename, including
extension, of that file produced by the compiler?
%noextra
%right SORT.REL
%extra
%wrong SORT.REL
Your answer was right except for the extra characters.
%algol extratest;
%wrong .REL
The extension is ".REL" as you wrote, but the filename before
the extension should be "SORT".
%wrong REL
You forgot the dot (".") in front of the extension "REL".
%wrong SORT
The extension on relocatable object code files is ".REL".
%wrong
%same
%wrong
The filename part before the extension is "SORT".
%same
%wrong
%same
%wrong
Time for some repetition.
%goto compileload
%question comment monitor knows which compiler to use;
When you write a "COMPILE" monitor command, how can the monitor
know which programming language your program is written in,
and thus which compiler to use?
%extra
%right extension
%right .alg
%neutral file name
Yes, but what part of the file name?
%goto repeat
%neutral dot
Yes, but what is it called, the part after the dot?
%goto repeat
%neutral second
%same
%neutral "."
%same
%wrong ext
"EXTENSION" is a difficult word to spell.
%wrong
Which part of the filename is it that tells the monitor which
compiler to use?
%wrong
Example: If the filename is "SORT.ALG" the monitor knows to
use the ALGOL compiler. What is the part of the filename
called which tells the monitor this?
%wrong
What is the part of the filename after the dot (".") called?
%wrong
The part after the dot, which tells the monitor which compiler
to use, is called the "extension".
%goto next
%question comment load command;
Now your source program SORT.ALG has been compiled into the relocatable
object code file SORT.REL. What do you write to LOAD that file into
an absolute program in core?
%noextra
%right LOAD SORT.REL
%right LOA SORT.REL
%right LOAD SORT
%right loa sort
%extra
%wrong loasort
Did you forget a space after the command name?
%wrong loadsort
%same
%wrong LOAD SORT
Your answer was right except for extra characters which should be removed.
%algol extratest;
%wrong LOAD
After "LOAD" you write the name of the file with the relocatable object
program to be loaded.
%wrong start
START is used to execute a program which is already loaded into
core. Your problem now is how to load it.
%wrong
Use the LOAD command.
%wrong
%same
%wrong
Time for some repetition.
%goto compileload
%question comment start command;
When your source program has been loaded into an executable object
program in core by the "LOAD" monitor command, what do you write to
start the execution of that program?
%noextra
%right START
%right sta
%right st
%extra
%wrong START
You only write "START" and nothing else to the monitor.
%wrong RUN
The "RUN" command is used to start the execution of a program which
must first be loaded from disk. But since your program was already
left in core by the loader, you do not have to get it from disk.
%wrong ex
The EXECUTE command is used when the program should be loaded
and possibly even compiled. Your program is already loaded.
%wrong
%wrong
You use the "START" monitor command to start the execution of
a program which already is in core.
%goto next
%text moreaboutload:
Shortcuts.
=========
In practice, you do not have to write out all the three commands
COMPILE, LOAD and START.
You can write LOAD without first writing COMPILE. If you write
LOAD, then the system will automatically recompile your source
program. This automatic recompilation is done if there is no
relocatable object file to LOAD, and also if the source program
file is newer than the relocatable object file. Only if there
is a relocatable object file which is newer than the source
program file LOAD will load that object file.
There is also a command called "EXECUTE" which combines the
LOAD and START commands into one single command.
This means that the single command "EXECUTE" is enough to
compile, load and start execution of a source program.
%text omitext:
It is also not nescessary to type the extensions unless you have
several program files with the same name. The system will look
at all files with the given name, and decide what needs to be done.
%question comment execute command;
If you have a source program "SORT.ALG", how can you with
one single command compile it, load it and start the execution
of the loaded program? What do you write?
%noextra
%right EXECUTE SORT.ALG
%right EX SORT.ALG
%right exe sort.alg
%right exec sort.alg
%right EXECUTE SORT
%right EX SORT
%right exe sort
%right exec sort
%extra
%wrong esort
You should use a space after the command name.
%wrong xsort
%same
%wrong SORT
In front of the filename, you write "EXECUTE".
%wrong EXECUTE
After "EXECUTE" you write a space and then the filename of
the source program file which you want to compile.
%wrong ex
%same
%wrong
A hint: Use the "EXECUTE" monitor command.
%wrong
%Same
%wrong
%text
Saving absolute core images of programs.
=======================================
The "LOAD" command will make the loader put the executable
absolute object code into your core image area. You
can however also save it on disk for later execution
with the "RUN" command. To do this, you use the SAVE monitor
command.
You write "SAVE" followed by the filename under which you want
to save the program.
Example: You have a source program file "PROG.SIM" which you
want to compile and load and then save the executable object
program on disk. You then first write "LOAD PROG.SIM", and
then you write "SAVE PROG". The program will then be saved
in a disk file called "PROG.EXE". The extension ".EXE" indicates
that this is an absolute executable object program which can
be executed directly without either compilation or loading.
%question if false then savequestion: nopause:= true;
Write the commands to first compile and load in one step with
a single command, and then save on disk the absolute object
code, for the source program "SORT.ALG", under the
name "SORT.EXE".
%noextra
%neutral LOAD SORT.ALG
Now your program will be compiled and loaded.
What do you write next?
%algol if skip then begin skip:=false; goto nextques1 end;
%goto next
%neutral LOAD SORT
%same
%neu loa sort
%same
%neu loa sort.alg
%extra
%wrong loadsort
Did you forget a space?
%wrong loasort
%same
%wrong save
You must push RETURN before typing in the "SAVE" command.
%wrong COMPILE
You do not have to use the "COMPILE" monitor command, since
the "LOAD" monitor command will automatically compile your program.
%wrong LOAD
After "LOAD" you write a space and then the filename of the source
program file.
%wrong ex
You cannot use the "EXECUTE" command since that command will
start execution of your program, and you want to save it in the
state it was immediately before the start of the execution.
%wrong
First use the "LOAD" monitor command to compile and load the
program.
%wrong
%same
%wrong
Time for some repetition.
%goto moreaboutload
%question nopause:= true; comment second half of savequestion;
%noextra
%right SAVE SORT
%right SAVE SORT.EXE
%right SSAVE SORT
%right SSAVE SORT.EXE
%right SAVE
%right SSAVE
%right sav SORT
%right sav SORT.EXE
%right Ssav SORT
%right Ssav SORT.EXE
%right sav
%right Ssav
%extra
%wrong savsort
Did you forget a space?
%wrong savesort
%same
%wrong SAV
After "SAVE" you just write the filename under which you
want to save the absolute executable object program, that is
"SORT".
%goto savequestion
%wrong SORT
In front of the filename, you write "SAVE" to save the core image
on disk.
%goto savequestion
%wrong
A hint: Use the "SAVE" monitor command.
%goto savequestion
%wrong
%same
%wrong
Time for some repetition.
%goto moreaboutload
%text nextques1:
Program listings and cross-reference listings.
=============================================
There are many switches which you can write on the monitor
commands COMPILE, LOAD and EXECUTE.
Two important ones are:
LIST to get a line printer listing of your source program.
CREF to prepare data for a cross-reference listing of the
identifiers in your source program.
Example: To compile "PROG.SIM" and also get a source program
listing on the line printer, you write "COMPILE PROG.SIM/LIST".
%text summary:
Summary
=======
The type of program files are indicated by their extensions:
.ALG for ALGOL programs,
.BLI for BLISS programs,
.CBL for COBOL programs,
.FOR for FORTRAN programs,
.LSP for LISP programs,
.MAC for MACRO 10 programs or
.SIM for SIMULA programs.
Command Effect
------- ------
COMPILE Compile a program
LOAD Load a program into core
EXECUTE Compile, load and start a program
SAVE Save the core image in a file.
Switches to COMPILE, LOAD and EXECUTE are:
/LIST Print the listing on the line printer
/CREF Make a cross reference.
%algol pause;
%end