-
Notifications
You must be signed in to change notification settings - Fork 5
/
languages.info
1907 lines (1587 loc) · 81.8 KB
/
languages.info
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
-*-text-*-
Slightly updated (CPR) 4:18pm Thursday, 26 June 1980
Major editing (JAF) winter 1982.
(note that this is all just a comment now. JAF 11/22/81)
File: Languages, Node: Top, Up: (DIR)
This file describes the languages that have implementations that can
run on a DECSYSTEM-20 (also referred to herein as "Twenex", which is
jargon ["TENEX on the Twenty", or "Twenty TENEX"]). The menu lists
the languages. If a language has only one dialect, then the node for
that language will give general information about it and then provide
a menu of specific information (how to use the compiler, how to use
the debugger if any, etc.) and possibly pointers to more information.
If a language has more than one dialect, then its node has a menu that
lists the dialects.
Several points of information are given about each language: where it
comes from (i.e., who mostly produced it, or who last maintained it),
how to invoke it (what command string to give to the Exec), what
system it is oriented towards (either the -10 or the -20, or a few
other odd operating systems), what file extension is considered the
'default' for that language (i.e., if you use it, you're more likely to
have the right things happen by default), and a general 'title page'
description of the language.
One point of jargon: when a language, or the programs it produces, is
said to 'run native', this means that it is TOPS-20 oriented and thus
uses only the TOPS-20 monitor calls; otherwise, it is TOPS-10 oriented
and has to run under PA1050, the "compatibility package" (which tries
to fool programs into thinking they're running under a TOPS-10
monitor). (Programs that were written for Tenex also run native, but
there may be slight inconsistencies of style. Programs that were
written under ITS at MIT have mostly been converted to run native on
TOPS-20.
When DEC manuals have been cited as reference material, it should be
understood that there may be newer versions or updates to the cited
version.
The ensuing language summaries were written, except where otherwise
indicated, by Frank da Cruz and Chris Ryland of the Columbia
University Center for Computing Activities (Chris is now at MIT), who
should be held responsible for any omissions or misrepresentations,
and all opinions, therein, and who invite your comments. Please note
that this file is under constant development. If you have additions
or corrections, please send them to:
Frank da Cruz
Columbia University Computer Center
New York, NY 10027
or
Chris Ryland
MIT, room 38-374
Cambridge, MA 02139
Or, if you're on the Arpanet, to g.daCruz@SU-SCORE and CPR@MIT-AI.
This file contains many INFO pointers at files which may live on
different directories on different sites. Your site will have to
update these pointers to point at the right places. The pointers in
the file assume a logical device name for each language, which is the
same (in most cases) as the default filename extension (file type) of
the language, e.g. SIM: for Simula. All of the file pointers that
don't refer to DOC: or HLP: refer to these logical names.
File: Languages, Node: Top, Up: (Dir)
This section describes the programming languages we support here
at MIT-EECS. These nodes are in the process of being revised, so please
forgive us if some of this is untrue. Bugs can be sent to <JAF>, also
if your interested in writing about your favorite language, or if you
have some neat routines you'd like included in a library, send mail
to <jaf>.
* Menu: The following languages exist on DEC-20's:
* Assemblers:: Several assembly-language processors.
* Algol-60:: ALGOrithmic Language-1960.
* Algol-68:: ALGOrithmic Language-1968.
* Simula:: SIMULAtion Language.
* Fortran:: FORmula TRANslation language.
* Sail:: Stanford Artificial Intelligence Labs language.
* Mainsail:: MAchine INdependent Sail
* Pascal:: Named after Blaise, a modern, fully-typed language,
with additions for systems programming on the -20.
* Lisp:: List-Processing Language: 2 implementations for the -20.
* Bliss:: Several versions of DEC's "implementation language".
* PPL:: Polymorphic Programming Language, a pedagogic,
extensible language.
* ECL:: Harvard's extensible programming system (EClectic
Language).
* C:: Bell Lab's portable, high-level "implementation language".
* BCPL:: A relative of C from BBN.
* CPL:: A "toy" PL/I from DEC.
* PL/I:: The real PL/I, also from DEC.
* Basic:: Beginner's All-purpose Symbolic Instruction Code.
* APLSF:: A Programming Language with Shared Files.
* Snobol:: StriNg-Oriented symBOlic Language.
* Cobol:: COmmon Business-Oriented Language.
* PCL:: Programmable Command Language for TOPS-20.
* Utilities:: Language-related utilities.
File: Languages, Node: Assemblers, Up: Top, Next: Algol-60
An assembler allows you to write programs consisting of actual machine
instructions. This is thought to be desirable for at least two
reasons: 1. only in assembly language can you write a program that
can take advantage of all the features of the machine, and 2. you
have maximum control over every aspect of the operation of your program,
including storage allocation, efficiency, etc.
In order to use an assembler, you must first be familiar with the
machine's instruction set. The definitive source for this information
is the:
DECsystem-10/DECSYSTEM-20 Hardware Reference Manual, Volume I:
Central Processor, EK-10/20-HR-001 (1978).
You will notice that this manual actually describes three different
machines: the KA10, the KI10, and the KL10. You should be aware that
DEC-20's are KL10's, except for 2020's which are KS-10's. There is
also a PDP-10 Reference card (DEC-10-XSRCA-B-D) which is out of date
(a new one is expected some day), and an article that traces the
development of the PDP-6/PDP-10 36-bit family of computers:
Bell, et al., "The Evolution of the DECsystem-10", CACM (Jan 1978)
also found in
Bell, et al., "Computer Engineering", Digital Press (1978).
Another thing that assembly-language programmers need to know about is
monitor calls. There are many things that you cannot do even in
assembly language on a time-shared machine, such as issue i/o
instructions; only the monitor can do these things. You can ask the
monitor to perform services for you by issuing a monitor call (a
DEC-20 monitor call is called a 'JSYS' (Jump to SYStem)). Information
about DEC-20 monitor calls is to be found in the following DEC
manuals:
1. Monitor Calls User's Guide, DEC-20-OMUGA-A-D (1976).
This is a rather informal introduction to DEC-20 monitor calls,
with detailed information about some of the most common ones.
2. TOPS-20 Monitor Calls Reference Manual, AA-4166D-TM (1980).
The definitive source for information about DEC-20 monitor calls
(Release 4 of TOPS-20).
In addition, an excellent introduction to assembly language
programming will soon be available (and is in circulation at some
sites in draft form):
Gorin, Ralph E., "Introduction to DECsystem-20 Assembly
Language Programming", Stanford University Computer
Science Department, 1980. Soon to be published by
Digital Press.
There are several assemblers suitable for use on the DEC-20.
* Menu: They include:
* Macro:: The standard DEC assembler
* Midas:: MIT's alternative for Macro
* Fail:: A very fast one-pass assembler from Stanford
Only Macro is supported by DEC, but the other two have certain
distinct advantages.
In addition, the following general information is available on line:
* Instruction set: (MAC:ASM.DOC)*
A document put together at Columbia in June 1979 that combines
portions of various DEC manuals and other materials in an attempt
to provide a single reference on opcodes, jsys's, macro, style,
etc. Somewhat superfluous with the appearance of Ralph Gorin's
book. The chapters (OPCODE, JSYS, MACRO, etc), are also available
seperately with their own tables of contents and indexes.
File: Languages, Node: Macro, Up: Assemblers, Next: Midas
Macro: Assembler
> Comes from: DEC
> Invoke via: 'Macro' or load-class command. Extension: .MAC
> System orientation: -20
> Description: Free-format, statement-oriented, 2-pass assembler with
macro processor. Capable of searching external 'universal' files at
assembly time. Fully supported by DEC. Most system programs,
including the monitor and the Exec, are written in Macro.
> Debugging: DDT interactive symbolic debugger.
> References:
1. Macro Assember Reference Manual, DEC, AA-4159C-TM (1978).
You won't learn how to program in Macro from this manual;
it is strictly for reference.
2. Macro Assembler User's Guide, DEC (forthcoming).
3. DECsystem-10 Assembly Language Handbook, DEC, DEC-10-NRZB-D (1972).
This is out of print, and strictly -10ish, but it is of a better
instructional nature than any of the currently available DEC manuals.
It also includes a DDT manual.
4. Singer, "Introduction to DECsystem-10 Assembler Language",
John Wiley & Sons (1978). Strictly for the -10, but it's a textbook.
Also covers Teco and DDT. Ignore the description of TOPS-10 monitor
calls. TOPS-20 monitor calls are described in the references cited
under the general topic 'assemblers' (up).
5. Gorin, Ralph E., "Introduction to DECsystem-20 Assembly Language
Programming", Stanford University Computer Science Department
(1980). Soon to be published by Digital Press. The only introductory
textbook especially for TOPS-20, and the best one we're likely to see.
Discusses opcodes, MACRO, JSYS's, and programming techniques.
* Menu: On-line information:
* Help: (HLP:MACRO.HLP)*
* Manual: (MAC:MACRO.DOC)*
* Hints: (MAC:HINTS.TXT)*
* Debugging: (HLP:DDT.HLP)*
* DDT Manual: (MAC:DDT.DOC)*
File: Languages, Node: Midas, Up: Assemblers, Next: Fail
Midas: Assembler
> Comes from: MIT, distributed with EMACS.
> Invoke via: 'midas'. Extension: .MID
> System orientation: ITS (MIT's Incompatible Timesharing System) and TOPS-20.
> Description: Midas is a 2-pass assembler several times as fast as
Macro. In addition, it has better error messages, and more powerful
macro facilities. Most software that comes from MIT that is not
written in Teco or Lisp is written in Midas, for instance Teco itself.
If you want to use TOPS-20 monitor symbols, you must use the statement
".insrt sys:twxbts.mid". Midas can produces executable code directly,
allowing you to bypass LINK, if you include the .DECSAV directive.
This is a great performance win for assembly language students.
> Debugging: DDT interactive symbolic debugger.
* Menu: Online information:
* Help: (HLP:MIDAS.HLP)*
* Debugger: (HLP:DDT.HLP)*
* DDT Manual: (MAC:DDT.DOC)*
* Manual: (INFO:MIDAS)Top
This is the INFO-structured manual.
File: Languages, Node: Fail, Up: Assemblers
Fail: Assembler
> Comes from: Stanford Artificial Intelligence Laboratory (SAIL),
but is usually distributed with MM or other programs that are
written in Fail.
> Invoke via: 'Fail', or load-class command. Extension: .FAI
> System orientation: -20
> Description: Fast, one-pass, block-structured assembler written by
Ralph Gorin at Stanford. DEC-20 monitor calls are built in, but
symbols have to obtained by searching monsym (.FUN, not .UNV).
Extremely close to Macro (except block structure, which need not be
used, and small syntactic differences) but about 5 times faster.
Programs can be written such that they will assemble under either
Macro or Fail; MM is a good example.
> Debugging: DDT (but if you use block structure, watch out!)
> Reference:
Wright & Gorin, "Fail", SAIL Operating Note 75B (Jan 1977).
No online documentation, but command string is like Macro's.
It understands full -20 file names, but doesn't do recognition on
them.
File: Languages, Node: Algol-60, Up: Top, Previous: Assemblers, Next: Algol-68
Algol-60 (ALGOrithmic Language 1960): compiler
> Comes from: DEC
> Invoke via: 'Algol' or load-class command. Extension: .ALG
> System orientation: strictly -10. DEC has no plans to 20ize.
> Description:
Block structured, recursive, statement-oriented language best suited
for clear, structured exposition of algorithms. Various data types
are available. This is the original common language of computer
scientists and is the basis of many other languages, such as Sail,
Simula, Pascal, Bliss, etc. Can be linked with external routines in
Algol, Fortran, and Macro. DEC still distributes Algol-60, but no
longer develops it. There are no plans to make it 20ish.
> Debugging: ALGDDT, an interactive source-level debugger.
> References (only a few of many):
1. DECSYSTEM-10/20 Algol Programmer's Guide, AA-0196C-TK (1977).
2. Backus et al., "Revised Report on the Algorithmic Language ALGOL-60",
CACM vol.6, no.1 (1963).
3. Dijkstra, "A Primer of Algol-60 Programming", Academic Press, 1962.
4. "Collected Algorithms for CACM and ACM TOMS (1966 ff.).
5. "Modified Report on the Algorithmic Language Algol 1960",
Computer Journal, v.19, Nov 1976.
* Menu: On-line information about Algol-60
* Help: (HLP:ALGOL.HLP)*
* Debugger: (HLP:ALGDDT.HLP)*
File: Languages, Node: Algol-68, Up: Top, Previous: Algol-60, Next: Simula
Algol-68 (Algorithmic Language 1968): compiler
> Comes from: University of Essex, U.K.
> Invoke via: A68. Extension: .A68. Logical name: A68:.
> System orientation: TOPS-20 (native) (but since it produces .REL
files that must be LINKed, TOPS-10 conventions should still be
observed in naming your Algol-68 programs).
> Description:
A very powerful language which includes extensible language facilities
and employs a new grammatical method of language definition.
Developed under IFIP auspices by Working Group 2.1 (Algol). Not a
compatible extension of Algol-60 although it retains the atmosphere of
the earlier language. Algol-68 was originally defined in 1968; it has
recently been revised by WG 2.1 in light of implementation experience.
Versions exists for IBM 360/370 as well as PDP-10, PDP-11, and other
computers.
> References:
1. Van Wijngaarden et al., "Revised Report on the Algorithmic Language
Algol 68", ACM Sigplan Notices, v.12 (May 1977), or in hardcover
(Springer Verlag).
2. Bourne, S.R., "ALGOL68C Reference Manual", University of Cambridge
Computer Laboratory (refers specifically to our version).
3. Tanenbaum, "A Tutorial on Algol-68", ACM Computing Surveys, v.8
(June 1976).
4. Lindsey & van der Meulen, "Informal Introduction to Algol-68",
Revised edition, North-Holland Publ. Co. (1977).
* Menu: See also:
* Help: (HLP:A68.HLP)*
* Users Guide: (A68:A68.MAN)*
* Bugs: (A68:A68.DOC)*
* i/o system: (A68:CHAPT8.MAN)*
* Formatting: (A68:PSF.MAN)*
* Updates: (A68:UPDATE.MAN)*
File: Languages, Node: Simula, Up: Top, Previous: Algol-68, Next: Fortran
Simula-67 (Simulation Language 1967), compiler.
> Comes from: Norwegian and Swedish governments
> Invoke via: 'simula' or load-class command. Extension: .SIM
> System orientation: TOPS-10 (a native version is on the way)
> Description:
A powerful general-purpose language that contains Algol-60 as a
subset. Simula has built-in capabilities for list-processing,
text-handling, abstract data types, quasi-parallel processing
(coroutines), formatted i/o, limited extensibility, and discrete event
simulation. Distinct from its predecessor, known as Simula-I, which
was primarily a simulation language. Implemented on most large
computers, including IBM 360/370. Simula is one of the languages that
fulfills the role on the DEC-20 that PL/I plays on IBM systems, but
Simula differs from PL/I in that it is fully defined (i.e. there is no
risk that the language specification does not say what will happen
when a certain construct is used). Simula programs are fully portable
except where the machines involved have differing character codes, in
which case conversion programs are supplied. A codasyl-type database
management system, SIMDBM, is available.
Unfortunately, Simula combines its abstract data types with strong
(compile-time) type checking, which eliminates most of the potential
advantage of abstract data types.
> Debugging: SIMDDT, interactive source-level bebugger.
> References:
1. Dahl et al., "Common Base Language", Norwegian Computing Center,
Oslo.
2. Birwistle et al., "Simula begin", Auerbach, Phila (1973).
3. "Simula Newsletter", Norwegian Computer Center.
4. "DECsystem-10/20 Simula Gazette", Swedish Nat'l Defense Research
Institute, Stockholm.
5. A list of Simula reports & papers appears in ACM SIGPLAN Notices,
vol 15 #5, May 1980, pp 12-18.
* Menu: See also:
* help: (HLP:SIMULA.HLP)*
General help about Simula.
* compile: (SIM:SIMCOM.HLP)*
How to use the Simula compiler.
* debug: (SIM:SIMDDT.HLP)*
How to use the Simula debugger.
* directory: (SIM:SIMDIR.HLP)*
How to use the Simula module maintenance facility.
* editor: (SIM:SIMED.HLP)*
How to use the source-file formatter and implementation
conversion program.
* runtime: (SIM:SIMRTS.HLP)*
Information about the runtime system, especially file access.
* general: (SIM:SIMULA.HLP)*
General info about Simula, known bugs, etc.
* man1: (SIM:SIMLH1.MAN)*
Part I of the language handbook: the language definition.
* man2: (SIM:SIMLH2.MAN)*
Part II of the language handbook: TOPS-10 dependencies.
* man3: (SIM:SIMLH3.MAN)*
Part III of the language handbook: The Simula library.
File: Languages, Node: Fortran, Up: Top, Previous: Simula, Next: Sail
Fortran is the common language of engineers and many scientists; it
is best suited for numerical applications, and it can be found on
almost every computer. However, it is also a very early language and
lacks most of the features which are thought to be essential to a
modern programming language (the 'do while' and 'if-then-else'
constructions, statement bracketing, scoping of variables, a standard
way of dealing with character-string data, adequate means of error
recovery, etc.), and therefore a great deal of discipline is required
to write clear, readable, correct, transportable programs.
> References:
1. American National Standard, FORTRAN, ANS X3.9-1966.
2. American National Standard Basic FORTRAN, ANS X3.10-1966.
3. "Clarification of FORTRAN Standards -- Second Report", CACM v.14
(Oct 1971).
By the way, there is a new ANSI standard for Fortran called
Fortran-77, which corrects a couple of the most outstanding
deficiencies (noted above) of Fortran-IV. It replaces the 1966
standard. See:
1. American National Standard, FORTRAN, ANS X3.9-1978.
2. Brainerd, "Fortran 77", CACM v.21 (Oct 78).
We don't expect to see Fortran-77 on the DEC-20 for several years
(except for SITGO, see below).
The following dialects of Fortran-IV exist (on the DEC-20):
* Menu:
* Fortran-20:: Fortran-20:
The principle Fortran compiler for the DEC-20.
Capable of producing well-optimized code.
* Sitgo:: This is a fast compile-and-go
system mainly useful for instruction and
program development. Includes Fortran-77 features.
* Ratfor:: "Rational Fortran". This is a preprocessor
that allows structured programming, string
manipulation, etc., in Fortran programs.
File: Languages, Node: Fortran-20, Up: Fortran, Next: Sitgo
Fortran-20 (Fortran for the -20): compiler
> Comes from: DEC
> Invoke via: 'fortran' or load-class command. Extension: .FOR
> System orientation: -10, but upgrade to -20 will happen some day.
> Description: Full ANSI 1966 standard Fortran IV with useful
extensions. Global optimization as an integral (but optional) part of
the system. Has a large library of built-in functions, and allows
access to various packages, such as the IMSL scientific subroutine
library and DBMS, and to external routines in Fortran, assembly
language, and Cobol. Also, Fortran routines can be called from other
languages such as Algol and Sail.
> Debugging: FORDDT, an interactive source-level debugger.
> Reference:
FORTRAN Reference Manual, DEC, AA-4158B-TM (1977)
* Menu: On-line information:
* Help: (HLP:FORTRA.HLP)*
* Debugger: (HLP:FORDDT.HLP)*
* Hints: (FOR:HINTS.TXT)*
* Document: (DOC:FORTRAN.DOC)*
This contains details of how to use Fortran on the DEC-20,
and comparison of DEC-20 Fortran with IBM Fortran and
standard Fortran.
File: Languages, Node: Sitgo, Up: Fortran, Next: Ratfor, Previous: Fortran-20
Sitgo (Stevens Institute of Technology 'go'): compiler/loader
> Comes from: DEC via Stevens Institute of Technology, Hoboken, NJ.
> Invoke via: 'Sitgo' or load-class command, Extension: .STG
> System orientation: Strictly -10
> Description:
A very fast fortran compiler designed especially for people learning
Fortran. It has very good compile-time diagnostics. Includes most of
the Fortran-77 features. Can be run interactively, or it can manage
its own batch stream. Requires modifications to PA1050. Since it
does no optimization and bypasses LINK, it can be a big performance
win on systems with big introductory Fortran courses.
* Menu:
* Help: (HLP:SITGO.HLP)*
* Manual: (DOC:SITGO-USERS-GUIDE.DOC)*
File: Languages, Node: Ratfor, Previous: Sitgo, Up: Fortran
Ratfor (Rational Fortran): Preprocessor
> Comes from: Bell Labs via BBN
There are many other versions, but this is the one we happen to have.
> Invoke via: 'ratfor'. Extension: .RAT
> System orientation: TOPS-20 (but see below)
> Description:
Developed at Bell Laboratories by Kernighan and Plauger. A
preprocessor for Fortran which gives it modern control structures,
string data, text substitution, etc., without leaving the language
entirely. The flavor of Ratfor is like C, and the language is
becoming very popular because it meets minimal requirements for
structuredness and utility, and it generates a Fortran source program,
which can be compiled on almost any computer. Since Ratfor itself is
written in Ratfor, the compiler can be moved to new computers very
easily. The compiler runs native; you can give it TOPS-20
file specifications for input and output, but it produces a Fortran
program, and Fortran currently runs under compatibility. However, a
number of routines can be found in RAT: that allow TOPS-20 i/o from
Ratfor and hence from Fortran. The compiler and other sources are on
line in RAT:; users are invited to make fixes and improvements. No
comprehensive document about this version exists; users are invited to
write one.
> Debugging: ForDDT interactive Fortran source-level debugger.
> References:
Kernighan & Plauger, "Software Tools", Prentice-Hall (1976).
* Menu: See also
* help: (HLP:RATFOR.HLP)Top
* history: (RAT:RATFOR.INFO)*
This is a mail file; use Rmail or MM to read it. Contains valuable
information about how Ratfor was developed at BBN and how the BBN
version differs from K & P's.
* cucca: (RAT:CUCCA-RATFOR-NOTES.TXT)*
File: Languages, Node: Sail, Up: Top, Previous: Fortran, Next: Mainsail
Sail stands for Stanford Artificial Intelligence Language. Sail is based
on Algol but also has fairly extensive list processing capability. Sail
allows one to include inline assembly code, and call most jyses directly.
Sail's i/o handling is awesome, but a bit tricky at first. Overall, sail
is a good language to hack in, but probably shouldn't be tackled by
someone unfamiliar with block structured languages.
* Menu: On-line information about Sail:
* Help: (HLP:SAIL.HLP)*
The directions for compiling sail programs.
* Debugger: (HLP:BAIL.HLP)*
The directions for bail, the sail debugger.
* Libraries: (SAIL-LIBS)*
The many varied and useful Sail library routines.
* Manual: (SAI:SAIL.MAN)*
The 1976 version of the sail manual.
* New Stuff: (SAI:SAIL.DOC)*
Updates for the 1976 version of the sail manual.
* Source:: Where sail comes from, and a more technical description.
* Hints: (SAI:HINTS.TXT)*
Valuable tips from Sail users. You can append
your own tidbits to this file.
* Tutorial: (DOC:SAIL-BEGINNERS-GUIDE.DOC)*
It's quite long, but if you want to teach yourself Sail
it beats the reference manual, especially if you come from
a Fortran background.
File: Languages, Node: Source, Up: Sail, Next: Manual
Sail (Stanford Artificial Intelligence Labs language): compiler
> Comes from: Stanford Artificial Intelligence Laboratory.
Distributed by:
Charles Hedrick (Hedrick@RUTGERS)
Director,
Laboratory for Computer Science Research
Hill Center, Busch Campus
Rutgers University
New Brunswick, NJ 08903
> Invoke via: 'sail' or load-class command. Extension: .SAI
> System orientation: Mostly Tenex, some -20 (but no -10!).
> Description:
A superset of Algol-60. Additional features include dynamic strings,
records, additional control structures, in-line assembly code,
built-in access to monitor calls (JSYS's), a complete set of
compile-time arithmetic and logic as well as a macro processor,
conditional compilation and compile-time i/o, sets and lists,
interrupt facilities, plus just about every other feature that could
be imagined. Also included is another language called LEAP, which
allows manipulation of associative data structures. Sail can be
linked with external routines in Sail, Fortran, and assembly language.
Sail is not entirely free of idiosyncrasies and bugs - it was written
by many different people over a long period. But it is quite usable.
Sail only runs on DEC-10's and -20's, but a machine-independent Sail
(Mainsail) is available; it's not the same language, but it's very
close in spirit.
> Debugging: Bail, a source-level interactive debugger.
> References:
Shapiro, Marvin, "A Beginner's Guide to Sail",
Division of Computer Research and Technology,
National Institutes of Health, Bethesda MD 20014 (July 1976).
Also on line as DOC:SAIL-BEGINNERS-GUIDE.DOC.
Reiser, "SAIL", Stanford Artificial Intelligence Laboratory Memo
AIM-289, Computer Science Department Report No. STAN-CS-76-574.
This reference manual is indispensible for Sail users.
Smith, "Sail Tutorial", Sail Memo AIM-290,
C.S. Dept Report STAN-CS-76-575.
Feldman, "An Algol-Based Associative Language", CACM Aug 1969.
(This is about Leap).
File: Languages, Node: Mainsail, Up: Top, Previous: Sail, Next: Pascal
Mainsail (MAchine-INdependent Sail): Compiler
> Comes from: Stanford University Medical Center
The contact is:
Clark R. Wilcox (Wilcox@SUMEX-AIM)
SUMEX Computer Project
Department of Genetics, Room TB105
Stanford University Medical Center
Stanford CA 94305
The Mainsail project is about to go commercial, as XIDAK Inc. (Cheap
for educational institutions).
> Invoke via: 'mainsail'. Extension: .MSA (or null).
> System orientation: TENEX
> Description:
Under development at SUMEX by Clark R. Wilcox et al., this language
may well be the long-awaited native-mode general-purpose programming
language for the DEC-20. It is a generalization of Sail, designed
from scratch with portability and consistency as principle criteria.
It is a serious effort, fully supported by the Biotechnology Resources
Program of the National Institutes of Health. All the power of Sail
is there, but the hacks are gone and many of Sail's features have been
extended, especially strings and records. In addition, certain
concepts have been adapted from other languages, such as the modules
of Simula. A wide variety of data types and control structures are
supported. Mainsail programs cannot be linked with programs written
in other languages, but it is possible to write in-line assembler code
or assembly-language modules. In fact, Mainsail cannot be used with
LINK; Mainsail provides its own combined dynamic linker and operating
environment. Since Mainsail programs are intended to look the same on
any machine, some special features of TOPS-20 like filename
recognition are not available. Versions currently exist for TENEX
(and therefore with very slight modification for TOPS-20), TOPS-10,
UNIX, RSX-11M, and RT-11. There are also versions under development
(perhaps completed by the time you read this) for the VAX, MC68000,
and IBM 370/30xx/43xx CMS.
> Debugging: An interactive source-level debugger is expected.
> References:
1. Wilcox et al., "Mainsail Language Manual", Stanford University
Medical Center (also available on line, see menu).
2. Wilcox, "The Mainsail Project: Developing Tools for Software
Portability", Proc. 1st Annual Symposium on Computer Application
in Medical Care, Washington DC (Oct 77).
3. Wilcox (in Lederberg & Feigenbaum, [?]), "Comparison of Mainsail
and Pascal".
* Menu:
* Help: (HLP:MAINSAIL.HLP)*
* Hints: (MSA:HINTS.TXT)*
* PDP-10: (MSA:PDP10.DOC)*
* Manual: (MSA:MAINSAIL.MANUAL)*
File: Languages, Node: Pascal, Up: Top, Previous: Mainsail, Next: Lisp
Pascal: Compiler
> Comes from: Rutgers University. Converted from Hamburg DECsystem-10
version by Charles Hedrick, and given systems programming orientation
in the doing.
> Invoke via: 'pascal' or load-class command, Extension: .PAS
> System orientation: TOPS-20. The compiler command string is in
TOPS-10 format to allow it to be hooked into the load-class
commands. Otherwise, the compiler runs native on the -20, as do
the programs it generates.
> Description:
Loosely based on Algol-60; includes a variety of data-structuring
facilities (records, sets, lists). Intended as both a convenient
basis to teach programming and as an efficient tool to write large
programs; emphasis is on keeping the number of fundamental concepts
reasonably small. Pascal-20 was developed for use as a systems
programming language, and includes a JSYS interface and the ability to
write external Pascal and assembly language procedures, but is
otherwise very close to the original language definition. Active
development of Pascal-20 continues; current projects are to make it
closer to UCSD Pascal, to add a preprocessor, and to make a compatible
compile-and-go version (an incompatible compile-and-go version has
been done at Stanford, called PASSGO, but it's not quite ready for
widespread distribution).
> Debugging: PASDDT, interactive source-level debugger.
> References:
1. Jensen & Wirth, "Pascal User Manual and Report", 2nd Ed.,
Springer-Verlag (1974).
2. Wirth, "The Programming Language Pascal", Acta Informatica 1 (1971).
3. Wirth, "Systematic Programming: An Introduction", Prentice-Hall (1973).
4. Conway, Gries, & Zimmerman, "A Primer on Pascal", Winthrop (1976).
5. Mickel (editor), "PASCAL Newsletter", Computer Center, University
of Minnesota.
* Menu:
* Help: (HLP:PASCAL.HLP)
* Pas-Critique::
An objective evaluation of Pascal-20 by its author.
* Manual: (PAS:PASCAL.DOC)*
This document describes only the system-dependent aspects of Pascal-20.
It is not a language manual; for this see reference 1.
* Full-Manual: (DOC:PASCAL-FULL-MANUAL.DOC)*
This is a complete guide to the extensions that are built into
the on-line Pascal implementation. It is not a language manual.
File: Languages, Node: Pas-Critique, Up: Pascal
The following words were written by Charles L. Hedrick at Rutgers:
[PASCAL] is based on the PASREL compiler from the University of
Hamburg, which was submitted to DECUS about two years ago. Since then
Hamburg has submitted an updated version, the most useful pieces of
which we have also used. (In general there seem to have been more
bugs in the updates than in the original implementation.) I have made
the following sorts of changes to their system:
- The TOPS-20 I/O system is completely new.
- The runtime structure has been changed to allocate core
automatically as needed.
- The compiler has had many bug fixes made.
- The compiler has been modified in a number of minor ways to be
closer to a full implementation of the PASCAL language.
- Certain added I/O and runtime procedures required modification of
the compiler in order to be compiled properly.
The goals of these changes were as follows:
- To give the user access to all the facilities of the underlying
operating system if he desires, supplying reasonable defaults when he
does not.
- To make use of the system "smoother" (e.g. provide output for CREF,
fix problems that caused every program to begin by typing "*" and to
always create a file called OUTPUT).
The "non-goals" (to use DEC's terminology) were
- To make an optimizing compiler (not practical in the time available,
and maybe not even desirable for installations using this for
students).
- To extend the PASCAL language (as distinguished from adding new I/O
procedures). While there are serious limitations to PASCAL, solving
them would make it a "bigger", more complex language, thus possibly
reducing its attractiveness for teaching purposes. Anyway, there are
other languages available that have all the features that would be
added (e.g. SAIL). However I have not removed the extensions present
in the original PASREL compiler.
I consider that [PASCAL] has the following major strengths [in the
DECSYSTEM-20 environment]:
- Its syntax is based on Algol. This is the major source of its
reputed "cleanness". (I cannot understand why PASCAL is taking the
world by fire and Algol never got anywhere.)
- It has very good data structuring facilities. The record structures
are very general and easy to use. Packed records make it possible to
define the various wierd argument blocks used by UUO's and JSYS's.
- This implementation gives very good access to the functions of the
operating system. It is possible to do odd kinds of I/O, and to
insert UUO's and JSYS's into the program without needing to set up
arguments using assembly language.
These advantages make it useful for teaching and system programming.
However when one attempts to use it for general applications
programming, the following problems in the design of the language show
up.
- It is not possible to write procedures that take arrays of arbitrary
size as arguments. E.g. one can write a procedure to invert 5 by 5
matrices, but not to invert arbitrary size matrices.
- There is no double precision arithmetic.
- There are no character strings. Instead one has only arrays of
characters. Thus one is constantly writing loops that deal with each
character in the array. None of the usual string operations are
available (or even definable, because of the limitation on variable
length arrays). This implementation allows you to treat a character
array as a file, which makes some operations a bit easier. But
character handling is dramatically clumsier than SAIL, or even DEC
Algol.
- Records are not garbage collected nor is their any way to return
records to the heap.
The first two problems mean that the language cannot be considered for
serious numerical work. The lack of character strings means that it
takes considerable ingenuity to write interactive programs that
conduct dialogs with the user. The fact that records cannot be
returned means that non-trivial use of pointers requires the user to
supply his own memory management. Because of strong typechecking, it
is not possible for the user to write a good memory management system.
The best one can do without abusing the language is to keep separate
free lists for each record type.
I think most users would find SAIL a better choice for general
applications programming. PASCAL would be better only in the
following rather special circumstances:
- Records and pointers are very important to the application. Packed
records and strong type checking make PASCAL an excellent choice in
this case. (This implementation checks for attempts to follow NIL or
0 pointers, and it is possible to force all uninitialized variables to
be 0.) SAIL's record syntax is somewhat clumsy, and it does not
provide a clean way to have records with components smaller than a
word. However macros can be used to solve these problems in SAIL if
necessary.
- The program contains many JSYS's. In SAIL one would have to use the
facility for inserting assembly language in line. In PASCAL monitor
calls can be done very nicely in a high level way, using the data
structures built into the language.
- The program is intended to be transportable. In this case one should
consider Simula as an alternative, however, as there are a number of
other Simula implementations. Simula is not my first choice because
the programs that have been done locally using it seem to be big and
slow. (I.e. when translated into SAIL they get smaller and and
faster.)
There are, of course, a number of languages other than SAIL which
would be suggested by my various colleagues. (The most interesting of
these seems to be ECL, which combines a good interactive environment,
such as Lisp and APL provide, with the advantages of a syntax and
semantics of roughly the same power as Algol 68.)
- Charles L. Hedrick, Rutgers University, October 1978
File: Languages, Node: Lisp, Up: Top, Previous: Pascal, Next: Bliss
Lisp - various Lisp implementations for the -20
Columbia has tried various implementations of LISP - Rutgers/UCI
(originally Stanford) 1.6 Lisp, InterLisp, and UCI Tenex/Tops20 Lisp
(called ILisp), and has settled - for now at least - on MIT MacLisp
because of the current choices, it's the easiest on the system
(Interlisp practically needs a dedicated machine), and it's most at
home in the TOPS-20 environment. There is also a totally new LISP
system under development at Rutgers which we'll be watching.
If you don't know much about Lisp, you should look at the Lisp Culture
section, as selectable in the Menu below. Also see the Lisp Tutor
section, and the tutorial referenced below.
* Menu: the Lisps we have on the -20
* Lisp Culture:: Some ramblings about Lisp
* Lisp Tutor:: A Lisp CAI (Computer Assisted Instruction) system
* MacLisp:: MIT project MAC LISP.
* RUCI Lisp:: Rutgers/UCI/Stanford Lisp 1.6
* Interlisp:: BBN/XEROX PARC Interlisp
* ILisp:: IMSSS' UCI Tenex/Tops20 Lisp
File: Languages, Node: Lisp Culture, Up: Lisp, Next: Lisp Tutor
Some Cultural Information about Lisp
Lisp is a language that has probably generated most of the important
seminal ideas in language theory and practice (Algol fans' opinions
notwithstanding), and which has carried most of the burden of
symbol-manipulation tasks in the computer science community for many
years. It has been a particularly important tool in the development
of artificial intelligence and related disciplines, and still lives on
strong in many of these circles. It is a language that can't be beat
for simplicity and power in its intended application of symbol
manipulation (which encompasses tasks such as natural language
understanding, goal-oriented programming, theorem-proving, etc.), and
it is even a decent programming language in its own right in other
areas (it is used as a systems programming language at some notorious
places, most notable the M.I.T. Artificial Intelligence Labs). Its
simultaneous simplicity and power make it an attractive language for
many tasks.
Honeywell now sells an EMACS written in Maclisp, for their Multics
system. The author said that using Lisp resulted in code that was
more concise, faster, and smaller in core than he would have got using
PL/1, the standard Multics system programming language. With luck,
there may be an EMACS written in Lisp for DEC systems to replace the
current one.
Lisp is also the only truly extensible language. Because a Lisp
interpreter is available when the compiler is used, the user can
define syntactic extensions which run arbitrary Lisp programs to
compute the code they expand into. It is easy to define new control
constructs.
This is not to say that it couldn't be better; it has many rough edges
that have been smoothed in later attempts at sophisticated
programming languages, but it still has a good deal of popularity in
many computer science circles.
Lisp was first conceived and developed by John McCarthy of (then)
M.I.T., who's now at Stanford (and has been for many years). McCarthy
first defined a 'pure' Lisp which was theoretically very interesting,
but not very practical. He, and several other people elsewhere, added
standard-programming-language features to it, and the result was
several versions of impure Lisp, which have diverged even further
since then. Still, the basic concepts are the same, and
implementations have a surprising closeness, differing mostly in the
'sugar' added later to sweeten the particular programming environment.
There is a very good article on the history of Lisp, by McCarthy, in
the History of Programming Languages Conference Proceedings (Sigplan
Notices, Volume 13, Number 8, August 1978). McCarthy, it should be
mentioned, is often considered one of the fathers of the time-sharing
concept, as he was the key figure on the development of CTSS at
M.I.T., back in the one-programmer-at-a-time-on-the-computer days.
To throw in a little controversy, I would venture to say that any
computer scientist that doesn't know and appreciate Lisp is missing
quite a bit, due to its singular importance in the development of this
science.
For more reading, there are several good places to look: Pat Winston,
the director of the Artificial Intelligence Labs at M.I.T., and a
very good teacher, has just written a introduction to the field of
artificial intelligence which includes a Lisp primer ("Artificial
Intelligence," Addison-Wesley; 1977). He has also written, with
Berthold Horn, a complete text ("Lisp," Addison-Wesley; 1977).
The old standby, somewhat babyish, but certainly a good beginner's
book, is the Weissman "Lisp 1.5 Primer" (Dickenson Publishing Co.; 1967).
There's also a fairly new book, called "Let's Talk Lisp", written by
Laurent Siklossy (Prentice-Hall; 1976); I don't know if it's that good,
but Winston recommends it.
For a very tasteful overview of how one segment of the computer
science community 'lives in' Interlisp, see the article "Programming
in the Interactive Environment: the LISP Experience", by E. Sandewall,
ACM Computing Surveys, Volume 10, Number 1 (March 1978).
Lisp has many spiritual children; some of the most prominent are
Planner, a goal-oriented programming language developed at M.I.T.;
Conniver, an alternative to Planner (there were a couple of papers
written of the sort "why Conniving is better than Planning"); QLisp,
an attempt at modernizing Lisp; QA4, a theorem-proving-oriented
language; POPL, a British language that emphasized a more ordinary
syntax; ECL, an extensible language developed at Harvard that owes
much to Lisp and has a kinship to Algol-68; MDL (or Muddle), a
considerably unusual dialect of Lisp developed at M.I.T. for use as a
modelling language; and many more which I probably don't know about.
(Of course, this paragraph does great injustice by trying to summarize
many man-years of intellectual striving in a single phrase.)
One reason that Lisp and her offspring have fared so well, and are so
important for research is that implementations have two big advantages
over other languages: (a) the programs themselves are just Lisp (or
language X) data structures, and are thus manipulable in wonderful
ways, and, as a consequence, (b) these implementations are usually
completely self-contained and full environments (as the Sandewall
article mentioned above points out). This means that one can live
totally in the world of the language, editing, compiling, running,
debugging, all at the language level. Further, since most of these
systems are thus self-extensible, customization for personal tastes is
quite common, and encouraged; contrast this to the usual situation of
a language that is frozen forever (usually in its wrongness).
File: Languages, Node: Lisp Tutor, Up: Lisp, Previous: Lisp Culture,
Next: MacLisp
Lisp Tutor: Lisp teaching system