•
`
`•
`
`A Friendly Programming Environment
`for the ALTO Mini-Computer
`
`Uri Shani
`Computer Science Department
`University of Rochester
`Rochester, NY, 14627
`
`TR54
`
`May 198~
`
`This work was supported in part by the Alfred P. Sloan
`Foundation under Grant 74-12-5.
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 1
`
`

`

`page 2
`
`•
`
`•
`
`Table of Contents
`
`1.
`
`Introduction
`
`2. Underlying Concepts and Incentives
`
`3. programming Activities and Tools
`
`4. The User-Profile
`
`Example
`
`5.
`
`Implementation
`
`No Changes
`
`Minimizing Time Overhead
`
`Human Engineering
`
`File Name parsing
`
`Remembering File Names
`
`
`6. Discussion
`
`Conclusions
`
`Appendix: Actual Practice and Experience
`
`References
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 2
`
`

`

`..
`
`•
`
`Page 3
`
`Abstract
`
`Personal minicomputers sophisticated enough
`to
`work under
`a disk operating system are considered in
`light
`of
`their
`convenience
`as
`a
`programming
`environment.
`
`Programming activities are classified as editing,
`compiling,
`loading,
`and so forth. Each such activity
`is carried out by one or more programs,
`called
`(programming)
`tools.
`The
`files processed by those
`tools are referenced via names entered by
`the user.
`Names of files
`involved
`in programming activities
`should be chosen
`to
`reflect file ~ information.
`Like variables
`in
`a
`programmrng language, a type of
`file
`defines what
`activities
`(operations)
`are
`applicable to it.
`
`Guided by this idea, file naming convention should
`be defined by
`the user and stored in a ~ profile
`structure.
`This definition
`is
`then used by
`the
`computer's command-interpreter
`(executive)
`to decide
`what programming tool to activate in order to carry out
`a requested activity on a file.
`
`for
`An extension to an .existing executive program
`a minicomputer
`(16 bit, 64KW with 3Mb disk and raster
`CRT display) that makes use of such a user profile
`is
`described
`in
`this paper.
`The
`system utilizes good
`human engineering and, with minimum overhead,
`improves
`significantly
`the usefulness of
`the computer as a
`programming vehicle.
`
`ACKNOWLEDGMENTS:
`
`for his
`Rashid
`thank Richard F.
`to
`I wish
`and helpful
`suggestions during
`the
`encouragement,
`design and implementation of the system. Keith Knox at
`Xerox Research Center in Webster, New York, suggested
`the "commented load command." Thanks are also due
`to
`Keith A.
`Lantz, Anil Nigam
`and Mark W. Kahrs for
`their useful comments during the preparation of
`this
`paper.
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 3
`
`

`

`•
`
`
`Page 4
`
`1.9
`
`INTRODUCTION
`
`A very important part of a computing system is its
`user interface -
`the collection of rules and mechanisms
`by which a user gains access to services provided by
`the machine.
`This is the responsibility of a program
`usually called the executive or command-interpreter. A
`user communicates with
`the executive by use of a
`The executive will perform file
`command language.
`maintenance functions and the like.
`In particular, the
`executive will
`invoke other programs
`(also called
`subsystems).
`If
`the machine is used for programming,
`it wlll include subsystems for text editing, compiling,
`and loading of user written programs. These subsystems
`are termed programming tools.
`
`and
`Each of these tools operates on input file(s)
`produces output file(s).
`Input and output files may
`have different properties depending on
`their purpose.
`For example,
`an input file to a Fortran compiler will
`not work for an Algol compiler.
`An executive, which
`invokes
`a
`programming
`tool
`irrespectively of
`the
`program, will allow the user
`to mistakenly
`feed
`the
`wrong file to the wrong tool.
`In an active programming
`site, where these tools are extensively used,
`special
`commands
`for performing programming activities should
`be provided by the executive
`so
`that
`the user will
`avoid such mistakes.
`
`This need was recognized by many system designers
`computer users.
`It
`led
`to
`the development of
`and
`compile-class-commands in the TOP8l9 operating
`system
`for
`the DEC PDP19 computer [1] and the development of
`the Rapid Program Generator
`RPG
`[2].
`In
`these
`systems,
`a distinguished logical part of the file name
`is the extension, used
`to decide which
`tool will
`perform
`a particular compile class command. A set of
`conventions for file extensions was set by
`the
`system
`designers.
`The 8D8949 [3] is a time sharing system in
`which file types are encoded internally
`in
`the files
`(*)
`in a limited variety for use by the system.
`
`the· ALTO
`use
`At Rochester, we extensively
`minicomputer
`[4] for programming.
`It is a 16 bit 64KW
`machine with a keyboard,
`raster CRT display and
`3M
`bytes
`removable disk storage (Fig. 1);
`it runs under
`a disk operating
`system
`(D08)
`that
`is similar
`in
`capabilities to 086 [5,6].
`
`* A user can not tell the file's type by looking at its
`name.
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 4
`
`

`

`Page 5
`
`•
`
`
`Fig. 1: ALTO machine configuration.
`
`is simple and
`The executive program on the ALTO
`does not have any bias towards programming activities.
`File names do have extensions
`that are used by
`the
`executive when
`invoking a subsystem (a subsystem name
`is expected to have
`the extension "run").
`I
`have
`extended
`the executive capabilities
`to
`include the
`commands Edit, Compile and Load.
`These
`commands use
`file extensions as
`file-types
`to decide what tool
`should be
`invoked
`for
`a
`particula.r
`programming
`activity. The notion of file type was expanded so that
`it is defined by the user in a user profile.
`In
`it,
`associations
`between
`file extensions, programming
`activities and programming tools are defined and can be
`easily changed.
`As our
`system is dynamic, when new
`tools are added they can
`immediately be
`incorporated
`into
`the
`existing programming env~ronment.
`Some
`varieties of user pr.ofile exist in many
`systems
`(the
`"switch.ini" file in the TOPS19, a profile structure in
`TSO [7], and the "user.cm" file in the Alto), but
`they
`are not used for defining file types.
`
`fully
`be
`to
`File extension does not have
`specified;
`a partially specified extension is matched
`against all possible extensions of existing files with
`the same name, in a priority order defined by the user,
`and the best match is chosen.
`If no file name is given
`in
`the
`command
`line,
`then the name used in the last
`command invocation is taken (i.e. ellipsis).
`
`involve
`These additions to the executiv~ do not
`any changes
`to existing programming
`tools or
`the
`executive itself. They are simple, easy to
`implement,
`and are suitable
`to any other personal computer of a
`configuration similar
`to
`that of
`the Alto.
`This
`extension
`is
`considered
`the
`friendly programming
`environment.
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 5
`
`

`

`.,
`
`
`Page 6
`
`2.0 UNDERLYING CONCEPTS AND INCENTIVES:
`
`a
`A central concept in personal computers is that
`Single user has total control of the system. Once the
`user "plugs in" a personal disk-pack
`and boots,
`the
`machine will
`load the available operating system from
`the disk. Files on the disk will now comprise the file
`system available. User's name, password, choice of
`files and any other idiosyncrasies are
`"stamped" over
`the machine.
`It is very unlikely that every user will
`have a special operating system, but
`file population,
`machine usage, and so forth are individual features.
`
`same
`the
`that all users have
`assume
`If we
`and
`executive,
`their personal
`system
`operating
`preferences must be defined
`in
`some data structure
`stored on
`the disk. This is called the user profile.
`As already mentioned in the introduction, I address
`in
`this paper the subproblem of this issue:
`how does the
`machine
`interact with
`the
`user
`in
`regard
`to
`programming.
`
`When dealing with operations done at the executive
`command
`level, operands are usually files, referenced
`via their names.
`In sophisticated executives like
`the
`UNIX Shell
`[8],
`the
`command
`language is so rich in
`control constructs
`that
`it makes
`it close
`to an
`ordinary
`programming
`language.
`This
`tendency of
`command language design inspires the idea of assigning
`types
`to
`files,
`and using
`these
`types in standard
`operations to make decisions as to what tools should be
`used
`to carry
`them out.
`This
`is analogous to the
`dependency of arithmetic operations
`in programming
`languages on variable types, e.g.
`real or integer. An
`even better analogy is
`the strong
`typed programming
`language SIMULA
`[9].
`In SIMULA, variable types are
`defined by the programmer as classes. This definition
`specifies the applicable operations, type and structure
`of contents, and so forth.
`
`File names and some other file descriptors are
`stored
`in
`the directory. As part of the file system
`design, the directory structure is not intended
`to be
`modified/changed by
`the ordinary user.
`It turns out
`that the file name itself can be the source of the file
`type
`information;
`and it is apparent and handy to the
`user.
`
`is
`type
`The role of file name as a hint to file
`explicitly stated by
`the designers of TENEX
`[10]
`(though not as "file types" per se).
`File names are
`made of
`two
`logical parts: <name> and <extension>.
`The <extension> part means various processed
`forms of
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 6
`
`

`

`Page 7
`
`Type-<extension> associations are
`same file.
`the
`defined by
`the
`system designers as
`a
`file naming
`convention.
`
`a personal file
`A user must be allowed to have
`naming convention by defining it in the user profile.
`This definition will then be used by the executive as a
`file type in certain operations, i.e.
`those concerning
`programming activities.
`A file, whose name has
`a
`certain
`<extension>,
`is automatically declared as
`having a certain type. Type meaning is defined in
`the
`..!:!!!!. profile.
`
`•
`
`3.0 PROGRAMMING ACTIVITIES AND TOOLS:
`
`in most other programming
`system, as
`In our
`systems, we can distinguish four different programming
`activities:
`
`1) Edit: Prepare and correct the textual form of the
`program
`in accordance with
`the
`syntax of some
`programming language, thereby yielding the
`source
`code.
`
`the
`2) Compile: Verify the syntactic correctness of
`source code and
`(if correct) convert it into a
`load module
`in accordance with
`the
`language
`semantics.
`A
`load module· consists mainly of
`machine code.
`
`load
`together one or more
`Patch
`3) Link/Load:
`modules
`into
`a
`run-module and resolve external
`definitions in the individual modules.
`The
`load
`modules may be compiled from source codes in more
`than one programming language, and may have been
`written
`by more
`than one programer
`(i.e.,
`libraries,
`software-packages,
`etc.).
`The
`run-module is mostly machine code.
`
`program,
`the
`Execute
`4) Run/Debug:
`correctness, and pinpoint the "bugs."
`
`test
`
`its
`
`that
`programming. tools are programs in the system
`are used to perform these programming activities. They
`are text-editors, compilers and linkage-loaders.
`Once
`the program is a run module, it can be invoked and run
`like any other program in the system (activity 4).
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 7
`
`

`

`sequence of operations performed
`Analyzing the
`du'r ing program wri ting, I have found that they can be
`described as the nondeterministic automaton depicted in
`Fig. 2.
`
`Page 8
`
`..
`
`Fig.
`
`Programming
`2:
`writing.
`
`activities
`
`during
`
`program
`
`It appears that the same activity with
`same
`the
`file operand may repeat itself several times. Coupl ing
`the edit and compile activities gives
`rise
`to
`the
`following ellipsis:
`
`the
`Remember the operand last used by either
`compile or edit commands, so that the next
`time any of these commands is invoked without
`an operand, 'the currently remembered operand
`is taken. The same is done with the load and
`debug commands.
`
`the
`for each of
`(which also exists
`This ellipsis
`compile class commands in the TOPS10) require, at most,
`a single file operand
`for any of
`the programming
`activities.
`The
`load
`activity
`is usually more
`complicated
`then
`the edit and compile activities.
`Loading
`a
`subsystem
`from
`a
`set of load modules may
`involve a complicat~d command
`line
`for
`a nontrivial
`subsystem (if overlays are required, for example). For
`the purpose of aiding
`the
`user
`in
`specifying
`complicated
`command
`lines,
`some kind of
`a macro
`expansion mechanism
`is provided by
`the executive.
`Examples are
`the "catalogued procedure" in JCL [11],
`the ".exec" file in TSO [7], or
`the ".mic"
`file
`in
`TOPS10 [1]. The Alto executive provides for the use of
`a command file that
`is a
`similar mechanism
`to
`the
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 8
`
`

`

`file are
`command
`a
`the contents of
`file;
`".mic"
`inserted in the command line where it is mentioned.
`
`Page 9
`
`For example, the command line,
`
`> Bldr Foo @FooUtils
`
`a
`
`is equivalent to
`
`> Bldr Foo Fooutill Foouti12
`
`if the contents of the file FooUtils are:
`
`"FooUtill FooUti12"
`
`The use of command files can, however, overflow
`the file
`system with numerous small files.
`In SAIL
`[12], the compile time construct,
`
`require "<file name>" load!module
`
`later by
`is encoded into the load module and is used
`the
`load command to build the appropriate command line
`for loading the subsystem, beginning with the main load
`module.
`This
`requires the load command to access ALL
`load modules used by
`the
`loaded
`subsystem,
`just-ro
`prepare
`the
`command
`line
`for
`the
`loading tool. A
`similar effect can be achieved by adding
`comments at
`the beginning of the main source file that, of course,
`are ignored by the compiler, but will be examined by
`the executive.
`This method is called the "commented
`load command." These comments will contain the desired
`load
`command line for the subsystem. Besides avoiding
`the need for a separate command
`file we establish a
`good programming methodology by maintaining a list of
`the files, used to build a subsystem, at the beginning
`of
`the main
`source file. The load command takes, in'
`this case, a single file as operand,
`like
`the other
`commands for programming activities do.
`
`4.0 THE USER-PROFILE
`
`the "user profile" we define associations
`In
`between programming
`tools, programming activities and
`file types (in our case, the file extensions).
`This
`can be done in a
`two dimensional array in which columns
`correspond to programming activities,
`rows
`to file
`types,
`and entries to programming tools. All entries
`are character strings and are stored
`in
`a
`file.
`In
`addition to the associations, we also provide a list of
`legal
`file extensions.
`The order
`in which
`legal
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 9
`
`

`

`listed defines a priority in matching
`extensions are
`partial extensions.
`Fig.
`3 describes-
`the
`user
`prof ile:
`
`Page 10
`
`Lega.ITy>as: -<typel>-' • • • ,-<t'::JP8.>­
`<ty>a 1>: -<Edi tor 1>-, -<Co.pi Ierl>-, -<Loadert>­
`<t y>ai>': -<Edi tor 2> -, -<COIIpi leI" 2> - -<Loader 2> •
`•
`
`I
`
`•
`
`for defining- file
`Fig. 3: User Profile structure
`types,
`programming activities and programming
`tools associations. Note that m>-n.
`
`The programming activities have been explicitly
`enumerated
`so
`that columns correspond positionally to
`activities. An empty entry means that the activity
`is
`undefined
`for
`the corresponding file
`type.
`The
`"Default" row defines tools for all other file
`types
`(that do not possess a row for themselves).
`
`Example:
`
`that our
`Let us assume
`following programming tools:
`
`system
`
`includes
`
`the
`
`"FORT", "ASM" and "LISP" for Fortran,
`The compilers:
`Assembly and Lisp programs, respectively.
`
`A general purpose text editor:
`oriented editor:
`"LISPE".
`
`"TEX"
`
`and
`
`a Lisp
`
`A loader:
`
`"LDR".
`
`The user profile is:
`
`LegalTypes: "ASM", "LSP", "FORT"
`
`ASM: "TEX", "ASM", "LDR"
`
`LSP: "LISPE", "LISP", "LDR"
`
`FORT: "TEX", "FORT", "LDR"
`
`De f a ul t: "TEX", "", .. "
`
`
`for
`The file Foo.ASM contains a "comment load command"
`4,
`loading
`the files
`"Foo"
`and
`"Boloney".
`Fig.
`presents
`a
`sequence of commands
`for
`programming
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 10
`
`

`

`the
`activities,
`operand used.
`
`invoked programming tool and the file
`
`Page 11
`
`•
`
`
`• rrna co.MO.nd:
`
`1
`2
`3
`4
`S
`
`Edi t Foo.ASM
`~il.
`Edi
`801 oney. LSP
`Co.pi I.
`Loo.d F 00. ASM
`
`Hi II invoke: on the fi lot:
`lEX
`ASH
`LISPE
`LISP
`LOR
`
`Foo.ASM
`Foo.ASn
`Bol oney. LSP
`Boloney.LSP
`Foo, BOI oney
`
`Fig.
`
`Command
`4:
`activities.
`
`interpretation
`
`for
`
`programming
`
`5.0
`
`IMPLEMENTATION
`
`The executive in the Alto accepts commands in a
`similar to that of the TOPS10 monitor:
`
`syntax
`
`<command>::=
`<command verb>[<global switches>]
`{,<parameter>[<local switches>] ••• }
`
`Where: tokens in [J are optional,
`
`tokens in { ••• } are optional, but
`
`may repeat more then once.
`
`
`an existing
`name of
`If the <command verb> is a
`subsystem
`then it is invoked and is able to access the
`rest of the command line. Otherwise, it is considered
`a
`command
`to be carried out by the executive itself
`(e.g. copy file).
`
`friendly
`the
`implementing
`In
`prog~amming
`environment, The following goals were put forward:
`
`the existing programs and
`1. No changes to any of
`the executive or programming
`subsystems,
`i.e.,
`tools.
`2. Low execution-time overhead.
`3. Good human engineering_
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 11
`
`

`

`Page 12
`
`No changes:
`
`the programming
`By writing programs for each of
`activities
`that
`took
`over
`the executive duties
`momentarily and invoked the appropriate
`tool,
`I
`have
`avoided changing the executive itself. These programs
`deserve to be called command-executives. As discussed
`in Section 3,
`I did not
`find it necessary to make
`changes to any of the programming tools.
`
`I wrote the programs Edit, Compile, Load
`and Run
`that command lines to invoke them appear as if they
`so
`are being carried out by
`the executive
`itself.
`The
`programs
`are written
`in
`the
`system programming
`language, BCPL [13].
`
`..
`
`Minimizing time overhead:
`
`is mainly achieved by
`Minimizing time overhead
`minimizing
`the number of files accessed.
`In the ALTO,
`as it is likely to be true in other minicomputers,
`the
`first access to a file is lengthy (file ."opening") (*).
`Several files in
`the ALTO are easy
`to open.
`The
`directory file and the user.cm file are two such files.
`
`The "user profile" is stored in the user.cm file,
`while
`the directory contains all the file-names and
`their physical disk addresses. When
`a
`file name
`is
`given to a programming command, it is "parsed" (cf.
`to
`Section 5.3.1. below) by use of both the user profile
`and
`the list of file names in the directory. Any file
`that is needed is then opened through its physical disk
`address as
`found
`in
`the directory.
`This way of
`"boosting" the opening of a file serves
`to open
`the
`subsystem for the programming tool itself.
`In the case
`of the load command, the main source file is opened
`in
`this way too (for the extraction of the ucommented load
`command") •
`a
`the use of
`A programming tool is invoked by
`special operating system routine (cf. OS6 [5]). When
`receive
`a
`the tool subsystem starts running, it will
`the
`prepared by
`"command
`line
`complete
`command
`
`* This is not true for large and expensive machines (at
`least
`it should not be) like the DECl~. There, a
`compile class
`command may access numerous
`files,
`create
`temporary
`files
`and
`take care of
`their
`deletion subsequently.
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 12
`
`

`

`Page 13
`
`executive." If the operand file does not exist,
`command is terminated at this stage.
`
`the
`
`command
`the
`to
`Any <switch> passed by the user
`will be carried over to the tool without changes.
`In
`the case of the load command, the <global switches>
`in
`the
`"commented
`command
`line" are merged with
`the
`switches given by the user for a particular
`invocation
`instance.
`
`Human engineering:
`
`Good human engineering is achieved by:
`
`and
`1. Intelligent file name parsing;
`2. Remembering file names across commands and across
`computer sessions, i.e. ellipsis.
`
`File ~ parsing
`
`in an anticipatory
`The ALTO executive interacts
`manner with
`the user.
`An
`incomplete file name is
`completed by the executive up
`to
`the next ambiguity
`point
`(cf.
`the SDS94~ system [3] and NLS [14, page
`36]). This interaction method may generate a file name
`and part of its extension (it usually does)
`though the,
`so expanded, name may still be
`incomplete.
`Fig.
`5
`presents
`a Pidgin-Algol algorithm for parameter file
`name parsing.
`It uses both the user profile and
`the
`list of file names in the directory. File name parsing
`can be avoided by ending the parameter file name with a
`period;
`this
`is useful in creating new text files by
`editing a nonexistent file.
`
`Remembering file names
`
`two
`As discussed in Section 3 (refer to Fig. 2),
`file names must be remembered, the edit-compile name,
`and the load-debug name. This is done by writing these
`names
`into available slots
`in
`the user.cm file (by
`really including them in the "user profile" part of
`. it) •
`In
`this way,
`file names are remembered across
`commands and across machine accessing periods •
`
`•
`
`•
`
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 13
`
`

`

`Page 14
`
`strin~ procedure ParseName (string PfileName);
`begln
`string Pname, Pextension,
`
`ofileName, oname, oextension,
`
`UPextension;
`
`Pname := MainNameOf (PfileName);
`Pextension := ExtensionOf (PfileName);
`for (all extensions in the "user profile"
`---
`let UPextension be the next one)
`do
`if Pextension is a prefix of UPextension
`-- for (all file names in the directory
`---
`let ofileName be the next one)
`oname := MainNameOf (ofileName);
`oextension := ExtensionOf (ofileName);
`if (oname = Pname)
`and
`-- (oextension = UPextension) then
`return (ofileName)
`
`do
`
`then
`
`•
`
`
`Fig. 5: pidgin Algol routine for parsing a parameter
`fIle name.
`
`6.0 DISCUSSION:
`
`to
`referred
`have
`I
`this paper
`Throug'hout
`the
`large machines.
`As
`time-sharing
`systems
`on
`the
`underlying concept of time-sharing is
`to provide
`user with the illusion that s/he is using the computer
`all alone, the correlation between
`these systems and
`minicomputers is obvious.
`
`in other
`The assignment of types to files exists
`systems
`such as
`the SOS940 [3], TOPS10 [1], and TSO
`[7], to name a few. The file extension, as described
`in
`this paper, is referred to by TSO as a "descriptive
`qualifier" of a data set
`(=file).
`Like
`the compile
`class
`commands
`in
`the TOPS10,
`the SCAN
`and RUN
`subcommands of
`the EDIT
`command
`in T50 use
`this
`information
`to
`decide what
`tool
`to use.
`Those
`descriptions are statically defined by the system.
`In
`the 505940, however, not file names are used for this
`purpose, but some internal encoding.
`
`in
`form or another
`User profiles exist in some
`In TOP5l0 it is a text
`almost any time-sharing system.
`a
`structure
`that
`is
`file (switch.ini) I
`in TSO it is
`accessed
`through a special command (i.e., PROFILE) and
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 14
`
`

`

`Page 15
`
`terminal operational
`(only on
`has a limited effect
`parameters) •
`None of
`these
`systems use
`the user
`profile to define user file naming convention.
`
`is
`The discussion about programming activities
`justified
`in
`the
`use
`of
`the Alto, or other
`minicomputers as well.
`In many cases these activities
`are not sharply distinguishable.
`These activities
`might be integrated into
`a
`programming
`system.
`The
`programming
`systems APL
`[15],
`INTERLISP
`[16],
`and
`PYGMALION [17] are complete
`systems
`that
`include an
`editor and
`an
`interpreter
`so that once entering the
`system, the user does all activities
`there and exits
`when finished.
`
`integrated
`an
`proposed
`Habermann et al. [18]
`software
`development
`system
`in which programming
`activities are interleaved. The NLS/Augment, developed
`at SRI
`International, already uses such a system for
`large scale
`software
`engineering
`[19,29].
`The
`programmer's Workbench, another
`important project in
`this class, was developed at Bell Laboratories [21,22].
`
`the various programming
`In both TSO and TOPS19,
`activities are distinguishable and use separate tools.
`In this paper it was found that edit and compile are
`coupled activities (Fig. 2).
`In TOPS19, however, the
`special command Execute will activate
`the
`commands
`Compile, Load and Run for the same file.
`
`file naming
`a dynamic
`The advantage of "having
`convention becomes evident while adding new tools to
`the system. For example, when one receives a new
`text
`processing
`tool, one can
`readily declare
`the file
`extension ".DOC" as associating
`the compile activity
`with
`the new
`tool
`so that by executing edit-compile
`commands one can conveniently prepare a document.
`
`CONCLUSIONS:
`
`The following were emphasized in this paper:
`
`suggest
`languages
`1) Recent developments in command
`assigning
`file types to files. This inspires the
`analogy between use of files at the user interface
`level and variables in programming languages.
`
`2) The user's individuality must be preserved when
`dealing with personal computers by use of a "user
`profile" in which one pan define
`the meaning of
`different file types.
`
`•
`
`•
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 15
`
`

`

`Page 16
`
`type of file,
`3) By using the file name to declare
`the user creates his own file naming convention.
`
`solution
`a
`is concerned,
`4) As far as programming
`which
`is
`based
`on
`the
`assumptions about
`programming activities (Section 3), is proposed.
`
`A file naming convention designated to define file
`types
`is not
`a new idea per se, but here it was made
`dynamic and user definable. This approach is justified
`in
`a
`personal
`computing
`environment.
`As user
`interfaces become more
`and more programmable, one
`should consider assigning types to files as it is often
`done for variables in programming
`languages.
`In
`the
`context
`of
`programming activities,
`the suggested
`solution uses a user profile
`for
`this purpose.
`An
`algorithm
`for
`file name parsing
`is described;
`it
`refers to the user profile and
`intelligently assists
`the user
`in keying his commands.
`Implementing these
`ideas did not involve changes to system programs. This
`is significantly attributed
`to
`the use of a simple
`executive, running on a personal computer.
`
`Further research may involve expansion of the use
`of file types to other tasks performed by the executive
`besides invoking programming tools.
`
`•
`
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 16
`
`

`

`Page 17
`
`Appendix: Actual Practice and Experience
`
`in my
`Here is an example of the "user profile"
`personal disk pack for the Alto mini-computer. This is
`the actual structure that is used by
`the
`implemented
`system.
`For
`a
`new user,
`the first time any of the
`command-executives
`is called,
`it creates
`such
`a
`structure
`on
`the
`"user.cm"
`file.
`The
`initial
`user-profile provides a minimal environment under
`some
`default convention.
`The user is then in a convenient
`position to change and adjust it to his own preference.
`
`[USER PROFILE]
`
`runfile: "testmicro.bcpl
`"
`editfile: "user.cm
`"
`extensions: "bcpl" "b" "doc" "mem" "cm" "asm" "spl" "al"
`bcpl: "SCPL" "FLASH" "SLOR"
`b: "XSCPL" "FLASH" "XSLOR"
`
`spl: "MicroSpl" "FLASH" ""
`
`doc: "Altorunoff" "FLASH" ""
`
`asm: "ASM" "FLASH" ""
`
`al:
`"" "fontEdit" ""
`
`default: "" "FLASH" "n
`
`programs: "FLASH" "SCPL" "SLOR"
`
`
`fields
`The
`meanings:
`
`in
`
`this structure have
`
`the
`
`following
`
`1.
`
`is used
`runfile: The string following this ent'ry
`for
`the
`the ellipsis mechanism
`to
`implement
`contains
`the
`activities.
`load-run/debug
`It
`filename used in the most recent invocation of any
`of them.
`
`2. editfile: The string following this entry is used
`the
`to
`implement
`the ellipsis mechanism
`for
`edit-compile activities.
`
`in my
`legal extensions
`3. extensions: The list of
`environment.
`Their meaning is explained below in
`the association table, with an entry for each
`such
`legal extension.
`
`4. The association table consists of the entries bcpl,
`b, ~, doc, ~, aI, and default.
`
`type
`this
`a. bcpl: SCPL source file. A file of
`is compiled by the program 'bcpl', editted by
`'flash' (a general purpose
`full-screen
`text
`ed i tor),
`and
`loaded by
`'bId r'
`(the general
`purpose loader for the Alto machine).
`
`•
`
`•
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 17
`
`

`

`•
`
`
`Page 18
`
`is
`b. b: Xbcpl source file. A file of this type
`compiled by
`the cross-compiler 'xbcpl' (which
`creates
`code
`to
`run
`on
`an
`Eclipse
`mini-computer),
`and loaded by the cross-loader
`'xbldr' (for the Eclipse machine as well).
`It
`is editted by 'flash'.
`
`the
`for micro-coding
`c. spl: High level source
`Alto.
`A file of this type is compiled by the
`compiler 'spl'. There is no
`loading activity
`defined
`for this type, since the author of the
`compiler
`has
`introduced
`all
`levels
`of
`a
`processing
`in
`single sub-system.
`It
`is
`editted by 'Flash'.
`
`this
`A file of
`d. doc: Documentation source.
`type
`is
`compiled
`by
`the
`text processor
`'AltoRunOff', and has no
`loader since
`that
`activity
`is not defined for this type. It is
`editted by 'flash'.
`
`is
`e. ~ Assembly source. A file of this type
`compiled by the 'ASM' assembler, and editted by
`'flash'. No loader is defined, though one can
`imagine configurations
`in which an assembly
`file is the main source file of a program--very
`unlikely
`in our environment, but certainly
`possible.
`
`this
`f. al: A font-definition file. A file of
`type is editted by the graphics oriented editor
`'FontEdit'. There are no compile and
`load
`activities defined.
`
`the
`g. default: All other legal types have only
`edit activity defined for them, which will be
`performed by 'flash'.
`
`5. programs: This list of programs is used to "boost"
`invocation of a (program) tool, once it is selected
`to carry out an activity. Since the directory
`is
`available
`for
`search during command execution, it
`is used to find
`the physical disk addresses of
`these programs,
`and
`thus
`take
`a
`short-cut
`in
`"opening" and starting the chosen program.
`
`the sense of
`This structure is very flexible in
`categorizing
`activities with
`files
`under
`the
`edit-compile-load classification. As an example of the
`extended
`utilization
`of
`this structure,
`the new
`command-executive program
`'print' was
`added
`to
`the
`environment.
`This
`tool prints a text file on a line
`printer. It participates with the 'edit' and 'compile'
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 18
`
`

`

`Page 19
`
`in using the same ellipsis for file names.
`activities
`This design is based on two assumptions:
`1) editted
`files are
`text files;
`and 2)
`the print activity is
`coupled with the edit-compile activities owing
`to
`its
`important
`role
`in this cycle. The first statement is
`not always true (e.g.,
`the
`.AL
`files are not
`text
`files, but are edittable), but is assumed in order to
`prevent the common mistake of feeding binary file
`to
`the
`line
`printer and
`"jamming"
`it.
`The
`second
`assumption has been found to be very useful.
`
`the
`The experience with this new tool may lead to
`conclusion
`that
`a more
`flexible structure must be
`designed to allow also the arbitrary addition of new
`activities.
`In this case, the 'print' activity will be
`associated with a tool according to the definitions
`in
`the user-profile.
`In
`this new setup, a line printer
`will be called for text files, while a plotter will do
`the work for font-files •
`
`•
`
`•
`
`
`APPLE EXHIBIT 1077
`APPLE v. PMC
`IPR2016-01520
`Page 19
`
`

`

`Page 20
`
`REFERENCES:
`
`'Dec System !! operating System Command Manual' ,
`
`DEC-10-0SCMA-A-D (May 1974).
`
`
`1.
`
`Program Generator' ,
`Rapid
`'RPG-
`2. R.E Gorin,
`Stanford Artificial
`Intelligence Laboratory,
`Operating note 51.1 (September 1973).
`
`'Reference
`al.,
`et
`Deutsch
`3. L.P.
`Manual
`TIME-SHARING SYSTEM. Document Mo R-2l', Office of
`Secretary of Defense, Advanced ~esearch projects
`Agency (October 1968).
`
`the Personal
`'Microelectronics and
`Kay,
`4. A.C.
`Scient.
`Am.
`273 (3) ,
`Computer',
`231-244
`(September 1977).
`
`5. J.E. Stoy and C. Strachey, 'OS6- An Experimental
`Operating System
`for
`a S