Editing Action! (programming language)

{{Short description|Atari 8-bit computer programming language}}
{{about|the programming language|other uses|Action (disambiguation)}}
{{Infobox software
| name = Action!
| logo  = <!-- Image name is enough -->
| logo caption = 
| logo size = 
| logo alt = 
| screenshot = actionscr.png
| caption = Fullscreen editor
| screenshot alt = Action! fullscreen editor
| author = Clinton Parker
| developer = [[Optimized Systems Software]]
| discontinued = yes
| released  = {{Start date and age|1983|08|}}
| latest release version = v3.6
| latest release date = {{Start date and age|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 switching|bank-switched]] 16&nbsp;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.

Parker, working with [[Henry Baker (computer scientist)|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 (magazine)|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.<ref>[http://atariage.com/forums/topic/217770-action-source-code/?p=3168885 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''</ref>

==Development environment==
Action! is one of the earlier examples of the OSS SuperCartridge format. Although ROM cartridges for the Atari could support 16&nbsp;kB,<ref>{{cite book |last=Chadwick |first=Ian |date=1983 |title=Mapping the Atari |url=https://archive.org/details/Mapping_the_Atari/page/n133/mode/1up |publisher=[[Compute!]] |page=103 |isbn=9780874550047}}</ref> OSS opted for bank-switching 16&nbsp;kB, organized as four 4&nbsp;kB blocks, [[Memory map|mapped]] onto 8kB of [[address space]]. The lower 4&nbsp;kB did not change, and system could [[bank switch]] between the other three blocks by changing the value in address $AFFF.<ref>{{cite web |url=https://atariwiki.org/wiki/Wiki.jsp?page=Cartridges |title= RAM/ROM Control On An XL/XE Computer |website=AtariWiki}}</ref>{{sfn|Moriarty|1984|p=55}} This allowed for more [[RAM]] available for user programs.<ref>{{cite web |url=https://atariwiki.org/wiki/attach/Newsletters/OSS_Newsletter-Summer_1983.pdf |title=OSS Newsletter |author=<!--Not stated--> |date=1983 |website=atariwiki.org |access-date=2024-05-24}}</ref>

Action! used this design by breaking the system into four sections, the editor, the compiler, a [[machine code monitor|monitor]] for testing code and switching between the editor and compiler, and the run-time library.{{sfn|Moriarty|1984|p=55}} 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.{{sfn|Moriarty|1984}}

Action! constructs were designed to map cleanly to 6502 [[opcode]]s, to provide high performance without needing complex optimizations in the [[one-pass compiler]].<ref>[http://atariki.krap.pl/index.php/ACTION! ACTION! in Atariki (PL)]</ref> For example, local variables are assigned fixed addresses in memory, instead of being allocated on a stack of [[activation record]]s. 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]].{{sfn|Moriarty|1984}}

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.{{sfn|Moriarty|1984}}

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.{{sfn|Moriarty|1984}}

== Language ==
=== Data types ===
Action! has three fundamental [[data type]]s, all of which are numeric.

'''BYTE''' is internally represented as an [[signedness|unsigned]] 8-[[bit]] integer. Values range from 0 to 255.<br>
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

'''CARD'''inal is internally represented as an [[signedness|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

'''INT'''eger is internally represented as a [[signedness|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.

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

=== 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 [[Direct memory access|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 driver]]s. He later moved to the [[Xerox Alto]] project where he wrote several games for the system.{{sfn|Parker|2015|loc=6:00}} His PhD was in [[natural language]] parsing and he had worked on compiler theory during his graduate work.{{sfn|Parker|2015|loc=6:30}}

[[Henry Baker (computer scientist)|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.{{sfn|Baker|Parker|1979|p=1}}

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.{{sfn|Baker|Parker|1979|p=1}}

===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!{{sfn|Parker|2015|loc=7:00}} 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!{{sfn|Parker|2015|loc=28:00}} Sales were strong enough for Parker to make a living off the royalties for several years.{{sfn|Parker|2015|loc=20:00}}

The [[IBM PC]] had [[C programming language|C]] compilers available, and Parker decided there was no point in porting Action! to that platform.{{sfn|Parker|2015|loc=21:30}} 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.{{sfn|Parker|2015|loc=2:45}} 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.{{sfn|Parker|2015|loc=1:00}}

==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."{{sfn|Moriarty|1984|p=60}}

[[Leo Laporte]] reviewed Action in the May/June 1984 edition of ''[[Hi-Res (magazine)|Hi-Res]]''. He began the review, "This is the best thing to happen to Atari since [[Nolan Bushnell]] figured out people would play [[Pong|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."<ref>{{cite magazine |url=https://www.atarimagazines.com/hi-res/v1n4/action.php |title=Lights, Camera, ACTION! |first=Leo |last=Laport |magazine=Hi-Res |date= May–June 1984 |page=72}}</ref>

''[[BYTE]]'' in 1985 praised the compilation and execution speed of software written in Action!. Using the [[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".<ref name="schneeflock198503">{{cite news | url=https://archive.org/stream/byte-magazine-1985-03-rescan/1985_03_BYTE_10-03_Bargain_Computing#page/n283/mode/2up | title=Action! A Poor Man's C? | work=BYTE | date=March 1985 | access-date=19 March 2016 | author=Schneeflock, Ed | pages=273}}</ref>

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."<ref name="chadwick1985">{{Cite book |title=Mapping the Atari |last=Chadwick |first=Ian |publisher=Compute! Publications, Inc. |year=1985 |isbn=0-87455-004-1 |location=Greensboro, North Carolina |pages=v-vi |chapter=Author's Preface To The Revised Edition |chapter-url=http://www.atariarchives.org/mapping/revisedpreface.php}}</ref>

== References ==
===Citations===
{{Reflist}}

===Bibliography===
* {{cite tech report |first1=Henry |last1=Baker |first2= Clinton |last2=Parker |title=Micro-SPL |publisher=Synapse Computer Services |date=September 1979 |citeseerx = 10.1.1.126.6877 |url=http://www.bitsavers.org/pdf/xerox/alto/micro-spl/Micro-SPL_Sep79.pdf }}
* {{cite interview |url=http://ataripodcast.libsyn.com/antic-interview-111-clinton-parker-action |title= ANTIC Interview 111, Clinton Parker, Action! |date= 31 December 2015 |interviewer=Randy Kindig |first=Clinton |last=Parker |type=podcast }}
* {{Cite magazine |last=Moriarty |first=Brian |date=February 1984 |title=Action! - A new language for the Atari! |url=https://archive.org/details/analog-computing-magazine-16/page/n55/mode/2up?view=theater |magazine=ANALOG Computing |pages=54–61 |issue=16}}

== External links ==
*{{sourceforge|atari-action}}
*[https://archive.org/details/ActionVersion36_SourceCode Action! Programming Language Version 3.6 - Source Code], by Optimized Systems Software at archive.org
*[https://web.archive.org/web/20120309213853/http://retrobits.net/atari/action.shtml Action! info at Retrobits.com]
*[http://x868k.com/retro/action/ Action! Archive]
*[http://x868k.com/retro/action/man/ Action! reference manual]
*[http://gury.atari8.info/effectus/ Effectus cross-compiler]

[[Category:Atari 8-bit computer software]]
[[Category:ALGOL 68 dialect]]
[[Category:Optimized Systems Software]]
[[Category:Procedural programming languages]]
[[Category:Programming languages created in 1983]]
[[Category:Statically typed programming languages]]
[[Category:Systems programming languages]]