• B-series assembler

    From Randall Gellens@21:1/5 to Hans Vlems on Sun Oct 27 12:39:34 2019
    On Sunday, October 21, 2018 at 12:15:30 AM UTC-7, Hans Vlems wrote:
    So SAFE in NEWP identifies parts of code that are in assembly language?
    In C the term usually indicates improper use of pointer variables. Thiat language is very generous in offering options with unexpected side effects when using pointers.
    NEWP Opens the door to machine language instructions but the programmer always has to open that door knowingly, right?
    Hans

    Back when I used NEWP, there was only the UNSAFE declarative, which permitted constructs that could bypass security. If you used any such constructs without an UNSAFE declaration, it was a compile-time error. If you had any UNSAFE blocks, the
    executable needed to be blessed before it could be run. I used NEWP in purely safe ways for some projects.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Randall Gellens@21:1/5 to Paul Kimpel on Sun Oct 27 12:54:22 2019
    On Sunday, October 21, 2018 at 11:42:17 AM UTC-7, Paul Kimpel wrote:

    ESPOL was an acronym for Executive Systems Problem Oriented Language. As
    I understand it, NEWP is not officially an acronym and doesn't stand for anything. The bit about washroom privileges was an in-plant joke that
    got spread around. The other story about the origin of NEWP as a name
    was that whenever someone would ask John McClintock (the chief
    developer) whether the new compiler was ready to use yet, he'd reply "Newp."

    My recollection is that the P in ESPOL is for "Program" rather than "Problem." I believe NEWP was a contraction for New Programming language. The jokes about washrooms and McClintock were just that, jokes, as Paul says.

    1. The Mark II.1 SYMBOL/MCP (ca. 1972) was 25,376 lines. The MCP 12.0 SYMBOL/MCP (ca. 2008) was 1,282,948 lines.

    If I recall correctly, there was some work we had to do to allow a source file to exceed a million lines.

    The tools that we developed to do software development on large shared source files was impressive. PATCHMANAGER, the Editor, the SEPCOMP facility (it detected which modules had been modified since the previous compilation, and only recompiled those).


    2. To the best of my knowledge, there has never been any hard-coded
    assembly language in the B6500 and later MCPs.

    That matches my understanding. The lack of assembly was a major point of pride throughout the Burroughs/Unisys Large Systems group when I was there.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Randall Gellens@21:1/5 to Hans Vlems on Sun Oct 27 12:43:49 2019
    On Sunday, October 21, 2018 at 12:15:30 AM UTC-7, Hans Vlems wrote:
    So SAFE in NEWP identifies parts of code that are in assembly language?
    In C the term usually indicates improper use of pointer variables. Thiat language is very generous in offering options with unexpected side effects when using pointers.
    NEWP Opens the door to machine language instructions but the programmer always has to open that door knowingly, right?
    Hans

    Unsafe constructs were provisions that allowed one to do things that system software needed, such as pausing other processors, altering a stack, etc. These were accomplished using language constructs rather than machine operators.

    The old Programmer's Workbench editor allowed one to put the cursor on a source code line and use the "]" command to view the generated machine code. I used to do that fairly often when I was optimizing code. It didn't let you change the generated code,
    but you could change your source code to coax the compiler into generating the machine code you wanted.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Randall Gellens@21:1/5 to Randall Gellens on Sun Oct 27 12:57:50 2019
    On Sunday, October 27, 2019 at 12:54:23 PM UTC-7, Randall Gellens wrote:

    If I recall correctly, there was some work we had to do to allow a source file to exceed a million lines.

    Ir was in the late 1980s or early 1990s, if I recall correctly, when the MCP first exceeded a million lines.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Paul Kimpel@21:1/5 to Randall Gellens on Tue Oct 29 15:06:12 2019
    On 10/27/2019 12:54 PM, Randall Gellens wrote:
    On Sunday, October 21, 2018 at 11:42:17 AM UTC-7, Paul Kimpel wrote:

    ESPOL was an acronym for Executive Systems Problem Oriented Language.
    <snip>

    My recollection is that the P in ESPOL is for "Program" rather than "Problem."
    <snip>

    The B5500 ESPOL Reference Manual of October 1967, page ix, indicates
    it's "Problem":

    http://bitsavers.org/pdf/burroughs/B5000_5500_5700/1032638_B5500_ESPOL_RefManOct67.pdf

    The B6500 ESPOL Reference Manual of January 1970, page vi, also refers
    to it as "Problem":

    http://bitsavers.org/pdf/burroughs/B6500_6700/1042744_B6500_ESPOL_Jan70.pdf

    Paul

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Paul Kimpel@21:1/5 to Randall Gellens on Fri Nov 8 09:08:21 2019
    On 10/27/2019 12:43 PM, Randall Gellens wrote:
    On Sunday, October 21, 2018 at 12:15:30 AM UTC-7, Hans Vlems wrote:
    So SAFE in NEWP identifies parts of code that are in assembly language?
    In C the term usually indicates improper use of pointer variables. Thiat language is very generous in offering options with unexpected side effects when using pointers.
    NEWP Opens the door to machine language instructions but the programmer always has to open that door knowingly, right?
    Hans

    Unsafe constructs were provisions that allowed one to do things that system software needed, such as pausing other processors, altering a stack, etc. These were accomplished using language constructs rather than machine operators.

    The old Programmer's Workbench editor allowed one to put the cursor on a source code line and use the "]" command to view the generated machine code. I used to do that fairly often when I was optimizing code. It didn't let you change the generated
    code, but you could change your source code to coax the compiler into generating the machine code you wanted.

    It was news to me that Programmer's Workbench has this feature, but
    after trying, I can't see how it could work. To me, PWB is the editor
    for the MCP that has a Windows GUI client, and is also known as NX/EDIT.
    It's been around (as a product available to users) since the late 1990s.

    What I think Randy is describing is The Editor, or OBJECT/ED, originally written by Darryl High for the TD/MT/ET/T27 poll-select terminals. It is usually run from CANDE by means of the "U ED" command. It's been around
    since ca. 1980.

    Indeed, The Editor does use "]" commands and does allow you to view the generated object code for a program, interleaved with the source code
    lines, in much the same way that compilers show generated code when the
    $CODE option is set. I still use this quite frequently -- most recently
    last week -- when debugging or trying to understand what code the
    compiler generates.

    For those who are unfamiliar with it, The Editor operates mostly in
    forms mode and makes use of several of the more unusual features of the Burroughs TD-style terminals, including the SPCFY (specify) key. It is a full-screen, dumb-terminal WYSIWYG editor in somewhat the same way that
    vi and emacs are, but since the TD-style terminals are block mode
    devices instead of async character-at-a-time devices, The Editor does
    not see individual keystrokes. Instead, it "offers" lines of the source
    as unprotected fields on the form (usually one line at a time), you use
    the local insert/delete/overtype features of the terminal to do line
    editing, and transmit the updated line or lines to the host where The
    Editor program is running. The interface is an acquired taste, but works
    very nicely once you get used to it. It's far more capable than CANDE
    page mode.

    I originally got interested in The Editor because it has very nice
    support for creating and editing patch files while presenting a unified
    view of the base source and the patch. That feature has since been
    carried forward into PWB and the other modern GUI editors for the MCP.
    These days I tend to use PWB for everyday editing, but still fall back
    to The Editor when I need to do something that no other MCP editor supports.

    Brief instructions for using The Editor to view object code are:

    1. Get the source file in CANDE.
    2. Run The Editor: transmit "U ED".
    3. Make sure a line on the screen is offered as an unprotected field.
    The top (command) line will be offered initially. You can also position
    the cursor over the text of any other line and press SPCFY.
    4. Load the object code file. There are two options:
    a. If the code file exists, load it by clearing the offered line and
    entering "]LOAD CODE <file title>". The "]" is optional on the
    command line.
    b. If the code file does not exist, you can compile it as a workfile
    by entering "]COMP".
    5. View the object code by entering "]LISTCODE". You can start the code
    listing at a specific point by entering "]LISTCODE <seq number>".
    6. Page forward through the code list by pressing SPCFY. Paging
    backwards is not supported.
    7. The list will stop automatically after the end of the current code
    segment. You can stop earlier by simply transmitting anything except SPCFY.
    8. Quit The Editor with a "]END" command.

    "]LISTCODE" can be abbreviated "]LISTC" and "]LOAD CODE" can be
    abbreviated "]LOAD C". For more details, enter "]HELP LISTCODE".

    I presented a tutorial on The Editor at the 2013 Universe/UNITE
    conference. It describes the idiosyncratic user interface and discusses
    several of its major features, including code listing:

    http://www.digm.com/UNITE/2013/

    Paul

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)