Action! (programming language)

Last updated
Action!
Original author(s) Clinton Parker
Developer(s) Optimized Systems Software
Initial releaseAugust 1983;40 years ago (1983-08)
Final release
v3.6 / November 4, 1983;40 years ago (1983-11-04)
Platform Atari 8-bit computers
Size 16K bank-switched cartridge

Action! is a procedural programming language and integrated development environment written by Clinton Parker for the Atari 8-bit computers. The language, which is similar to ALGOL, compiles to high-performance code for the MOS Technology 6502 of the Atari computers. Action! was distributed on ROM cartridge by Optimized Systems Software starting in 1983. It was one of the company's first bank-switched 16 kB "Super Cartridges". The runtime library is stored in the cartridge; to make a standalone application requires the Action! Toolkit which was sold separately by OSS.

Contents

Parker, working with Henry Baker, had previously developed Micro-SPL, a systems programming language for the Xerox Alto. Action! is largely a port of Micro-SPL concepts to the Atari with changes to support the 6502 processor and the addition of an integrated fullscreen editor and debugger.

Action! was used to develop at least two commercial products—the HomePak productivity suite and Games Computers Play client program—and numerous programs in ANALOG Computing and Antic magazines. The editor inspired the PaperClip word processor. The language was not ported to other platforms.

The assembly language source code for Action! was made available under the GNU General Public License by the author in 2015. [1]

Development environment

Action! is one of the earlier examples of the OSS SuperCartridge format. Although ROM cartridges for the Atari could support 16 kB, [2] OSS opted for bank-switching 16 kB, organized as four 4 kB blocks, mapped onto 8kB of address space. The lower 4 kB did not change, and system could bank switch between the other three blocks by changing the value in address $AFFF. [3] [4] This allowed for more RAM available for user programs. [5]

Action! used this design by breaking the system into four sections, the editor, the compiler, a monitor for testing code and switching between the editor and compiler, and the run-time library. [4] The run-time library is stored in the cartridge itself. To distribute standalone applications requires a separate run-time package which was sold by OSS as the Action! Toolkit. [6]

Action! constructs were designed to map cleanly to 6502 opcodes, to provide high performance without needing complex optimizations in the one-pass compiler. [7] For example, local variables are assigned fixed addresses in memory, instead of being allocated on a stack of activation records. This eliminates the significant overhead associated with stack management, which is especially difficult in the case of the 6502's 256-byte stack. However, this precludes the use of recursion. [6]

Unlike the integrated Atari BASIC and Atari Assembler Editor environments, the Action! editor does not use line numbers. It has a fullscreen, scrolling display capable of displaying two windows, and includes block operations and global search and replace. [6]

The monitor serves as a debugger, allowing an entire program or individual functions to be run, memory to be displayed and modified, and program execution to be traced. [6]

Language

Data types

Action! has three fundamental data types, all of which are numeric.

BYTE is internally represented as an unsigned 8-bit integer. Values range from 0 to 255.
The CHAR keyword can also be used to declare BYTE variables.

 BYTE age=[21]      ; declare age and initialize it to the value 21  BYTE leftMargin=82 ; declare leftMargin at address 82

CARDinal is internally represented as an unsigned 16-bit integer. Values range from 0 to 65,535.

 CARD population=$600             ; declare population and store it at address 1536 and 1537  CARD prevYear, curYear, nextYear ; use commas to declare multiple variables

INTeger is internally represented as a signed 16-bit integer. Values range from -32,768 to 32,767.

 INT veryCold = [-10]  INT profitsQ1, profitsQ2,  ; declaring multiple variables can       profitsQ3, profitsQ4   ; span across multiple lines

Action! also has ARRAYs, POINTERs and user-defined TYPEs. No floating point support is provided.

An example of a user-defined TYPE:

 TYPE CORD=[CARD x,y]  CORD point  point.x=42  point.y=23

Reserved words

A reserved word is any identifier or symbol that the Action! compiler recognizes as something special. It can be an operator, a data type name, a statement, or a compiler directive.

AND       FI         OR         UNTIL    =     (ARRAY     FOR        POINTER    WHILE    <>    )BYTE      FUNC       PROC       XOR      #     .CARD      IF         RETURN     +        >     [CHAR      INCLUDE    RSH        -        >=    ]DEFINE    INT        SET        *        <     "DO        LSH        STEP       /        <=    'ELSE      MOD        THEN       &        $     ;ELSEIF    MODULE     TO         %        ^EXIT      OD         TYPE       !        @

Example code

The following is example code for Sieve of Eratosthenes written in Action!. In order to increase performance, it disables the ANTIC graphics coprocessor, preventing its DMA engine from "stealing" CPU cycles during computation.

BYTE RTCLOK=20, ; addr of sys timer      SDMCTL=559 ; DMA control  BYTE ARRAY FLAGS(8190)  CARD COUNT,I,K,PRIME,TIME  PROC SIEVE()    SDMCTL=0 ; shut off Antic   RTCLOK=0 ; reset the clock to zero    COUNT=0         ; init count   FOR I=0 TO 8190 ; and flags     DO     FLAGS(I)='T ; "'T" is a compiler-provided constant for True     OD    FOR I=0 TO 8190 ; now run the sieve     DO     IF FLAGS(I)='T THEN       PRIME=I+I+3       K=I+PRIME       WHILE K<=8190         DO         FLAGS(K)='F ; "'F" is a compiler-provided constant for False         K==+PRIME         OD       COUNT==+1     FI     OD   TIME=RTCLOK ; get timer reading   SDMCTL=34   ; restore screen    PRINTF("%E %U PRIMES IN",COUNT)   PRINTF("%E %U JIFFIES",TIME) RETURN

History

Micro-SPL

While taking his postgraduate studies, Parker started working part-time at Xerox PARC working on printer drivers. He later moved to the Xerox Alto project where he wrote several games for the system. [8] His PhD was in natural language parsing and he had worked on compiler theory during his graduate work. [9]

Henry Baker and Parker released Micro-SPL in September 1979. Micro-SPL was intended to be used as a systems programming language on the Xerox Alto workstation computer, which was normally programmed in BCPL. The Alto used a microcode system which the BCPL compiler output. Micro-SPL output the same format, allowing BCPL programs to call Micro-SPL programs. [10]

Aside from differences in syntax, the main difference between Micro-SPL and BCPL, and the reason for its existence, was that Micro-SPL produced code that was many times faster than the native BCPL compiler. In general, Micro-SPL programs were expected to run about ten times as fast as BCPL, and about half as fast as good hand-written microcode. In comparison to microcode, they claimed it would take half as long to write and 10% of the time to debug it. [10]

Action!

It was during this period that Parker purchased an Atari computer for use at home. He was disappointed with the lack of development systems for it, which was the impetus for creating Action! [11] Parker considered releasing the system himself, but decided to partner with Optimized Systems Software (OSS) for sales and distribution. OSS focused on utilities and programming languages like BASIC XL, so this was a natural fit for Action! [12] Sales were strong enough for Parker to make a living off the royalties for several years. [13]

The IBM PC had C compilers available, and Parker decided there was no point in porting Action! to that platform. [14] As the sales of the Atari 8-bit computers wound down in North America, OSS wound down as well. Late in its history Action! distribution moved from OSS to Electronic Arts, but they did little with the language and sales ended shortly after. [15] In a 2015 interview, Parker expressed his surprise in the level of interest in the language continued to receive, suggesting it was greater than it had been in the late 1980s. [16]

Reception

Brian Moriarty, in a February 1984 review for ANALOG Computing , concluded that Action! was "one of the most valuable development tools ever published for the Atari." He cited the manual as the only weak point of the package, claiming it "suffers from lack of confidence, uncertain organization and a shortage of good, hard technical data." [17]

Leo Laporte reviewed Action in the May/June 1984 edition of Hi-Res . He began the review, "This is the best thing to happen to Atari since Nolan Bushnell figured out people would play ping-pong on a TV screen." Laporte praised the editor, noting its split-screen and cut and paste capabilities and describing it as a "complete word processing system that's very responsive." He said that Action! ran about 200 times as fast as Atari BASIC, concluding that "This language is like a finely tuned racing car." [18]

BYTE in 1985 praised the compilation and execution speed of software written in Action! Using their Byte Sieve benchmark as a test, ten iterations of the sieve completed in 18 seconds in Action!, compared to 10 seconds for assembly and 38 minutes in BASIC. The magazine also lauded the language's editor. BYTE reported that the language resembled C closely enough to "routinely convert programs between the two", and approved of its pointer support. The magazine concluded that "Action! is easy to use, quick, and efficient. It can exploit the Atari's full power. Action! puts programming for the Atari in a whole new dimension." [19]

Ian Chadwick wrote in Mapping the Atari that "Action! is probably the best language yet for the Atari; it's a bit like C and Pascal, with a dash of Forth. I recommend it." [20]

Related Research Articles

BCPL is a procedural, imperative, and structured programming language. Originally intended for writing compilers for other languages, BCPL is no longer in common use. However, its influence is still felt because a stripped down and syntactically changed version of BCPL, called B, was the language on which the C programming language was based. BCPL introduced several features of many modern programming languages, including using curly braces to delimit code blocks. BCPL was first implemented by Martin Richards of the University of Cambridge in 1967.

In processor design, microcode serves as an intermediary layer situated between the central processing unit (CPU) hardware and the programmer-visible instruction set architecture of a computer, also known as its machine code. It consists of a set of hardware-level instructions that implement the higher-level machine code instructions or control internal finite-state machine sequencing in many digital processing components. While microcode is utilized in general-purpose CPUs in contemporary desktops, it also functions as a fallback path for scenarios that the faster hardwired control unit is unable to manage.

<span class="mw-page-title-main">MOS Technology 6502</span> 8-bit microprocessor from 1975

The MOS Technology 6502 is an 8-bit microprocessor that was designed by a small team led by Chuck Peddle for MOS Technology. The design team had formerly worked at Motorola on the Motorola 6800 project; the 6502 is essentially a simplified, less expensive and faster version of that design.

In computer architecture, 8-bit integers or other data units are those that are 8 bits wide. Also, 8-bit central processing unit (CPU) and arithmetic logic unit (ALU) architectures are those that are based on registers or data buses of that size. Memory addresses for 8-bit CPUs are generally larger than 8-bit, usually 16-bit. 8-bit microcomputers are microcomputers that use 8-bit microprocessors.

<span class="mw-page-title-main">Atari 8-bit computers</span> Home computer series introduced in 1979

The Atari 8-bit computers, formally launched as the Atari Home Computer System, are a series of 8-bit home computers introduced by Atari, Inc. in 1979 with the Atari 400 and Atari 800. It is the first home computer architecture with coprocessors, enabling more advanced graphics and sound than most of its contemporaries. Video games are key to its software library, and the 1980 first-person space combat simulator Star Raiders is considered the platform's killer app.

<span class="mw-page-title-main">Xerox Alto</span> Computer made by Xerox

The Xerox Alto is a computer system developed at Xerox PARC in the 1970s. It is considered one of the first workstations or personal computers, and its development pioneered many aspects of modern computing. It features a graphical user interface (GUI), a mouse, Ethernet networking, and the ability to run multiple applications simultaneously. It is one of the first computers to use a WYSIWYG text editor and has a bit-mapped display. The Alto did not succeed commercially, but it had a significant influence on the development of future computer systems.

A blitter is a circuit, sometimes as a coprocessor or a logic block on a microprocessor, dedicated to the rapid movement and modification of data within a computer's memory. A blitter can copy large quantities of data from one memory area to another relatively quickly, and in parallel with the CPU, while freeing up the CPU's more complex capabilities for other operations. A typical use for a blitter is the movement of a bitmap, such as windows and icons in a graphical user interface or images and backgrounds in a 2D video game. The name comes from the bit blit operation of the 1973 Xerox Alto, which stands for bit-block transfer. A blit operation is more than a memory copy, because it can involve data that's not byte aligned, handling transparent pixels, and various ways of combining the source and destination data.

<span class="mw-page-title-main">Atari BASIC</span> Dialect of the BASIC programming language

Atari BASIC is an interpreter for the BASIC programming language that shipped with Atari 8-bit computers. Unlike most American BASICs of the home computer era, Atari BASIC is not a derivative of Microsoft BASIC and differs in significant ways. It includes keywords for Atari-specific features and lacks support for string arrays.

Interlisp is a programming environment built around a version of the programming language Lisp. Interlisp development began in 1966 at Bolt, Beranek and Newman in Cambridge, Massachusetts with Lisp implemented for the Digital Equipment Corporation (DEC) PDP-1 computer by Danny Bobrow and D. L. Murphy. In 1970, Alice K. Hartley implemented BBN LISP, which ran on PDP-10 machines running the operating system TENEX. In 1973, when Danny Bobrow, Warren Teitelman and Ronald Kaplan moved from BBN to the Xerox Palo Alto Research Center (PARC), it was renamed Interlisp. Interlisp became a popular Lisp development tool for artificial intelligence (AI) researchers at Stanford University and elsewhere in the community of the Defense Advanced Research Projects Agency (DARPA). Interlisp was notable for integrating interactive development tools into an integrated development environment (IDE), such as a debugger, an automatic correction tool for simple errors, and analysis tools.

The Atari Microsoft BASIC and Atari Microsoft BASIC II variants of the 6502-version of Microsoft BASIC ported to the Atari 8-bit computers. The first version, released 1981, required 32 KB of RAM and was supplied on floppy disk. The second version, released the next year, had most of the code on a ROM cartridge with additional functions on an optional floppy.

<span class="mw-page-title-main">Television Interface Adaptor</span> Video/audio/input chip of the Atari 2600

The Television Interface Adaptor (TIA) is the custom computer chip, along with a variant of the MOS Technology 6502 constituting the heart of the 1977 Atari Video Computer System game console. The TIA generates the screen display, sound effects, and reads the controllers. At the time the Atari VCS was designed, even small amounts of RAM were expensive. The chip was designed around not having a frame buffer, instead requiring detailed programming to create even a simple display.

Bravo was the first WYSIWYG document preparation program. It provided multi-font capability using the bitmap displays on the Xerox Alto personal computer. It was produced at Xerox PARC by Butler Lampson, Charles Simonyi and colleagues in 1974.

Optimized Systems Software (OSS) was a company that produced disk operating systems, programming languages with integrated development environments, and applications primarily for Atari 8-bit computers. The founders of OSS previously developed Atari DOS, Atari BASIC, and the Atari Assembler Editor for Atari, Inc., and many OSS products are substantially improved versions. OS A+ and DOS XL are based on Atari DOS. BASIC A+, BASIC XL, and BASIC XE are based on Atari BASIC. EASMD and MAC/65 are modeled on the Atari Assembler Editor. Action! is an ALGOL-inspired compiled programming language with an integrated full-screen editor. OSS also sold some software for the Apple II.

Atari Assembler Editor is a ROM cartridge-based development system released by Atari, Inc. in 1981. It is used to edit, assemble, and debug 6502 programs for Atari 8-bit computers without the need for additional tools. It was programmed by Kathleen O'Brien of Shepardson Microsystems, the company which wrote Atari BASIC, and Assembler Editor shares many design concepts with that language implementation.

<span class="mw-page-title-main">Atari Logo</span>

Atari Logo is ROM cartridge-based version of the Logo programming language for the Atari 8-bit computers published by Atari, Inc. in 1983. It was developed by Logo Computer Systems, Inc. (LCSI) in Quebec, Canada. LCSI wrote Apple Logo, and the Atari version maintains strong compatibility with it.

Systems Programming Language, often shortened to SPL but sometimes known as SPL/3000, was a procedurally-oriented programming language written by Hewlett-Packard for the HP 3000 minicomputer line and first introduced in 1972. SPL was used to write the HP 3000's primary operating system, Multi-Programming Executive (MPE). Similar languages on other platforms were generically referred to as system programming languages, confusing matters.

<span class="mw-page-title-main">Atari 8-bit computer software</span>

Many games, utilities, and educational programs were available for Atari 8-bit computers. Atari, Inc. was primarily the publisher following the launch of the Atari 400/800 in 1979, then increasingly by third parties. Atari also distributed "user written" software through the Atari Program Exchange from 1981 to 1984. After APX folded, many titles were picked up by Antic Software.

Happy drives are series of disk drive enhancements for the Atari 8-bit and Atari ST computer families produced by a small company Happy Computers. Happy Computers is most noted for the add-in boards for the Atari 810 and Atari 1050 floppy disk drives, which achieved a tremendous speed improvement for reading and writing, and for the ability to "back up" floppies. Happy's products were among the most popular Atari computer add-ons. They were still in use and active in the aftermarket as of 2009.

<span class="mw-page-title-main">MAC/65</span> Atari 8-bit family 6502 assembler

MAC/65 is a 6502 assembler written by Stephen D. Lawrow for Atari 8-bit computers. MAC/65 was first released on disk by Optimized Systems Software in 1982, with the program requiring 16 KB RAM. A bank switched "SuperCartridge" from OSS followed in January 1984 for US$99, occupying only 8 KB.

The Byte Sieve is a computer-based implementation of the Sieve of Eratosthenes published by Byte as a programming language performance benchmark. It first appeared in the September 1981 edition of the magazine and was revisited on occasion. Although intended to compare the performance of different languages on the same computers, it quickly became a widely used machine benchmark.

References

Citations

  1. ↑ Action! Source Code - Page 2, Alfred (Chopper Commander) Posted Mon Feb 2, 2015 1:38 PM, AtariAge Forums, This is the original Action! source as I received it from ICD. It uses the ICD cross assembler which is not included in the zip. It can be easily converted to other formats
  2. ↑ Chadwick, Ian (1983). Mapping the Atari. Compute!. p. 103. ISBN   9780874550047.
  3. ↑ "RAM/ROM Control On An XL/XE Computer". AtariWiki.
  4. 1 2 Moriarty 1984, p. 55.
  5. ↑ "OSS Newsletter" (PDF). atariwiki.org. 1983. Retrieved 2024-05-24.
  6. 1 2 3 4 Moriarty 1984.
  7. ↑ ACTION! in Atariki (PL)
  8. ↑ Parker 2015, 6:00.
  9. ↑ Parker 2015, 6:30.
  10. 1 2 Baker & Parker 1979, p. 1.
  11. ↑ Parker 2015, 7:00.
  12. ↑ Parker 2015, 28:00.
  13. ↑ Parker 2015, 20:00.
  14. ↑ Parker 2015, 21:30.
  15. ↑ Parker 2015, 2:45.
  16. ↑ Parker 2015, 1:00.
  17. ↑ Moriarty 1984, p. 60.
  18. ↑ Laport, Leo (May–June 1984). "Lights, Camera, ACTION!". Hi-Res. p. 72.
  19. ↑ Schneeflock, Ed (March 1985). "Action! A Poor Man's C?". BYTE. p. 273. Retrieved 19 March 2016.
  20. ↑ Chadwick, Ian (1985). "Author's Preface To The Revised Edition". Mapping the Atari. Greensboro, North Carolina: Compute! Publications, Inc. pp. v–vi. ISBN   0-87455-004-1.

Bibliography

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.