nyuuzyou/wikis huggingface dataset:
Synced

Synced is an esolang designed by User:ZippyMagician one day due to boredom.
==Description of language==
Synced is a synchronous language that runs every line of the program at the same time. Each operation on each line is performed in a tick, with the pointer for each moving after evaluation. Users can simulate a "do nothing for one tick" by putting in a space or ^. Due to the nature of this language, programs will be very long. Each line of the program (henceforth referred to as an operator) stores a value, initialized at 0. Every operator can interact with the values of other operators, through referencing them by use of a number marking the line. Once a line ends, the operator wraps around to the beginning of the line or the first ^ if there is one. Once every operator is halted, a program terminates.
Parameters, if needed, are inserted after the main command. These parameters do not take an extra tick to parse. Input can be taken as either a character or integer, and output can be given as a character, string, or integer if needed. The value of an operator can only be an integer, however.
Every print command will output a newline afterwards.
This language is not Turing Complete.
==Syntax==
===Commands===
Command code 	Takes Parameter	Description
: 	Yes 	Print with no formatting
; 	Yes 	Print ascii equivalent of the inputted integer
. 	Yes 	Stores the argument into the current operator's value. If it is a character, it gets its ascii value
+, -, /, *, %	Yes 	Will perform their respected operation on the current operator's value and the referenced operator's value. For example, +1 will add the second line's operator's value to the current operator's value
| 	No 	Halts current operator
~ 	No 	If the operator's value is 0, continue. Otherwise, wrap around the line
===References===
Character	Description
$ 	Does not do anything. Instead is used to reference the current operator's value
% 	Reference to next item in STDIN. It can take in a single letter or an integer
@ 	Reference to the next item in STDIN. This command converts the next character to its ascii value
Strings are denoted between quotation marks.
==Programs==
Here are a few programs in this esolang.
===Hello World===
 :"Hello, World!"|
===Cat program===
 .@;$~|
===Truth-machine===
 .%^:$~|
===Fibonacci Sequence===
 .1^:$+1
 .0^+0:$
===Factorial Calculator===
 .%^ -1 ~|
 .1|
 ^.0+3*0~+3:$|
 .1^*0 ~|
==Implementations==
*https://repl.it/@ZippyMagician/Synced
Category:Languages Category:2020 Category:Implemented Category:Low-level Category:Finite_state_automata Category:Cell-based
Syncin

syncin is an esoteric programming language created by BowlingPizzaBall. syncin is the reverse order of insync (based off syllables), and so every single instruction must be written in reverse order. It has support for multiple lines.
== Instructions ==
Name 	What it does 	Usage
def 	Defines a variable. This is the only way strings in the code can be displayed. 	<varcontent> <varname> def
var 	Calls a variable. 	<varname> var
sum 	Adds 2 numbers. 	<number2> sum <number1>
sub 	Subtracts 2 numbers. 	<number2> sub <number1>
mul 	Multiplies 2 numbers. 	<number2> mul <number1>
div 	Divides 2 numbers. 	<number2> div <number1>
equals 	Used as a comparison, checks if something is equal to something. Returns 1 if so, 0 if not.	<thing2> equals <thing1>
if 	If statement. equals is used here. 	<thing2> equals <thing1> if
else 	Else statement. 	<content> if; else
endif 	Ends an if statement. 	
endelse 	Ends an else statement. 	
loopstart 	Starts a loop. 	<times_to_loop(optional)> loopstart
loopend 	Ends a loop. 	<loop>; loopend
input 	Checks the input, then returns it. 	
length 	Checks the length of the input, then returns it. 	
pleaseendthismiseryrightnow	Ends the program. (not required for all programs) 	
== Examples ==
=== Hello World ===
"Hello World" helloworld def;
helloworld var;
=== Truth Machine ===
"0" 0 def;
"1" 1 def;
0 equals input if:
0 var;
pleaseendthismiseryrightnow;
else:
loopstart:
1 var;
loopend;
endelse;
endif;
=== Cat ===
input
=== Fibonacci ===
"0" firstnum def;
"1" secondnum def;
1 n1 def;
1 n2 def;
firstnum var;
secondnum var;
secondnum var;
loopstart:
n2 sub n1 n1 def;
n1 var;
n1 sub n2 n2 def;
n2 var;
loopend;
Category:Languages
Category:2022
Category:Unimplemented
SyntaxError: invalid syntax

SyntaxError: invalid syntax is an esolang created by User:None1 and inspired by foo : The term 'foo' is not recognized as the name of a cmdlet, function, script file, or operable program. Check the spelling of the name, or if a path was included, verify that the path is correct and try again. which is inspired by bash: foo: No such file or directory. It imitates a Python error which is common for beginners - Syntax error.
==Command==
Every command is valid, and prints:
 File "<stdin>", line 1
 [command]
SyntaxError: invalid syntax
==Interpreter==
===Python===
 print('\n'.join([f' File "<stdin>", line 1\n {i}\n\nSyntaxError: invalid syntax' for i in __import__('sys').stdin.read().split('\n')]))
===C===
The program implements a REPL, and uses the insecure function gets to read the program.
#include<stdio.h>
char _[1000000];int main(){while(!feof(stdin)){printf(">>> ");gets(_);printf(" File \"<stdin>\", line 1\n %s\n\nSyntaxError: invalid syntax\n",_);}}
===Batch===
@echo off
:bad
set /p x=^>^>^> 
echo File "<stdin>", line 1
echo %x%
echo.
echo SyntaxError: invalid syntax
goto bad
Category:Languages
Category:Joke languages
Category:Unusable for programming
Category:Output only
Category:Total
Category:2023
Category:Implemented
Synth

Synth is an esoteric programming language created by User:Avethenoul as a digital synthesizer. It was largely inspired by Befunge.
== Overview ==
Like Befunge, Synth uses single-byte commands and a stack. In fact, most of the commands are direct translations.
Unlike Befunge, a large part of any Synth program is track data, and all output is in audio form (accomplished by piping its output to aplay).
All data is of the "unsigned char" type. As a result of this, there are up to 255 tracks, each with up to 255 notes, and the program is up to 255 commands long. Output is done via unsigned 8-bit integers, sampled at 8000Hz. The first part of the program is track data, with each track ending in a newline. The first line starting with a colon (:) denotes the start of the program data, and a dollar sign ($) denotes its end. The remainder of the file is ignored.
Note values are encoded as ascii, with the 49th ascii code (1) corresponding to the 49th piano key (middle A, 440Hz), and the remainder tuned in equal temperament. One exception is the space character (ascii value 32), which denotes a pause. The below table serves as a handy lookup:
 !"#$%&'
 ()*+, -./0123
 45678 9:;<=>?
 @ABCD EFGHIJK
 LMOPQ RSTUVWX
 ||_|_|||_|_|_||
 |_|_|_|_|_|_|_|
== Commands ==
Cmd 	Description
0123456789abcdef 	all of these push their value (as read in hexadecimal) on the stack.
` 	pops a and b, pushes a+b*64. Iow it combines two nibbles into a byte.
: 	duplicates the uppermost value
/ 	swaps the uppermost values
! 	inverts the uppermost value (pops a, pushes 255-a)
* 	pops the uppermost values and pushes their product (divided by 256 to renormalize it)
pops a and b, returns b-a 	
pops a, then pops that many values and pushes their average. This functions as a mixer.	
~_%^ 	pops the uppermost value and generates a sine/square/sawtooth/triangle wave with that tone. See Overview for an explanation on how wave frequency is encoded.
t 	takes two values, returns a note. The uppermost value tells it play speed (in eigths of a second), the second uppermost value tells it which track to read the value from.
z 	takes the uppermost value, returns a sawtooth wave over that many notes (iow period length is measured in eigths of a second, like above). This, combined with the inverter and product, can be used to make basic envelopes.
== Examples ==
Gran Vals, aka the Nokia Jingle:
 DB::<<A?6688?=5588 
 = 
 :01t~16t~6z!*2+$
The last note is played on a separate track, to allow use of z for a fade effect.
== External resources ==
* Webpage describing the synth in detail
* Reference implementation
Category:Languages Category:2022 Category:Stack-based Category:Output_only Category:Audio_Output Category:Implemented
Systemf

systemf is a programming language enhancing Brainfuck with Linux system calls.
Command	Description
> 	Move the pointer to the right
< 	Move the pointer to the left
+ 	Increment the memory cell under the pointer
- 	Decrement the memory cell under the pointer
. 	Output the character signified by the cell at the pointer
, 	Input a character and store it in the cell at the pointer
[ 	Jump past the matching ] if the cell under the pointer is 0
] 	Jump back to the matching [ if the cell under the pointer is nonzero
% 	Execute system call
Analogously to Brainfuck, characters other than ><+-.,[]% should be considered comments and ignored. But, see extensions below.
==External resources==
*Reference implementation with examples
Category:Languages
Category:Brainfuck_derivatives
Category:Cell-based
Category:Turing complete
Category:Turing tarpits
Category:Implemented
Category:Low-level
Szewczyk notation for Minsky machine

Szewczyk notation is a tool invented by Kamila Szewczyk of thought useful when describing counter machines. Simply put, this notation for Minsky machines is a minimalistic representation of its capabilities.
== Syntax ==
Minsky machine code is represented by a list of pairs separated from each other. The text representation looks like this:
a0 a1
b0 b1
c0 c1
 ...
Each row is given an unique, consecutive ID. The notation supports two instructions:
* inc rX => X -1: increment register rX
* dec rX, Y => X Y: decrement register rX if rX > 0, else jump to row with ID Y.
== Properties ==
Numbers can be assumed of infinite precision. The ID's are 0 indexed and registers are initialized to 0
== Examples ==
===Infinite loop===
1 -1
1 1
1 1
===Cat===
0 -3
0 5
0 -1
0 -2
1 0
I/O extension required.
== Implementations ==
A tiny, 321 byte Perl emulator for the Minsky machine code (assuming Szewczyk notation).
#!/usr/bin/perl
use bignum;my(@a,@c,$d);push(@a,0)for(1..$ARGV[0]);s/(-?[0-9]+)[ \t]+(-?[0-9]+)/push(@{$c[$d++]},($1,$2));/ge while(<STDIN>);
for($d=0;$d<@c;$d++){$a[$c[$d][0]]++if$c[$d][1]==-1;if($c[$d][1]>=0){$d=$c[$d][1]-1if($a[$c[$d][0]]==0);$a[$c[$d][0]]--if($a[
$c[$d][0]]>0);}}print((shift@a)."\n")for(1..$ARGV[0]);
The following Python script is also an interpreter.
prgm = [[]]
prgm.pop(0)
while True:
 line = input('%s: ' % len(prgm)) # Displays line numbers automatically
 if line != "eof":
 line = list(line.split(" "))
 prgm.append([int(line[0]), int(line[1])])
 else:
 break
tape = []
for i in range(0, 5): # Adjustable
 tape.append(0)
# Executes the program
def szewczyk(A, B):
 global tape
 global inst
 global Input
 global part
 if B == -1:
 tape[A] += 1
 inst += 1
 elif B == -2: # Extensions
 print(chr(tape[A]), end="")
 inst += 1
 elif B == -3: # Extensions
 if part < len(Input):
 tape[A] = ord(Input[part])
 else:
 tape[A] = 0
 part += 1
 inst += 1
 else:
 if tape[A] > 0:
 tape[A] -= 1
 inst += 1
 else:
 inst = B
Input = input('>i ')
part = 0
inst = 0
while inst < len(prgm):
 szewczyk(prgm[inst][0], prgm[inst][1])
== Extensions ==
An I/O extension can be implemented as x1 equal to -2 (for output) and -3 (for input) to a given register.
Category:Concepts
T3rc+

t3rc+ is an extension is t3rc
== commands ==
 ←↑→↓↖↗↘↙ work the same by moving the pointer but not actually outputting
 ; output cell at pointer
 \ toggle output cell at pointer every arrow
 : input cell at pointer
 0-z[] do commands in brackets while cell at pointer is the alphanumeric (09AZaz) character (kind of like brainfuck)
 ! if next command is a while, reverse the conditions (i.e. !0[] is just brainfuck brackets, but 0[] is reverse conditions)
 + adds 1 to cell at pointer (works through the 0-z cycle and loops)
 - removes 1 to cell at pointer (same as + but backwards)
 ? go in random direction
 / move pointer backwards from that random direction
also, you start bottom right, you dont need to go to top right center, and grids can be any size
note: another language may be made if the creator feels this one is not good enough
== truth machine ==
 :;1[;] 
 
 t
== hello world ==
 \;↗↘↗↘↗↙←←←
 
 e l w
 hdlro
== kiwiscript ==
 \;↑↘↖
 
 i
 kw
== AAAAAAAAAAAA ==
 A[;]
 
 A
== skibidiskibidiskibidiskibidi... ==
 \→s[↗→↓↑↙↗\↙←\;]
 
 ki
 sdb
Category:Languages Category:2024 Category:Cell-based Category:Unimplemented
TACC

TACC is an esolang by User:ChuckEsoteric08 which is mix of Uppercase=Lowercase and Sreg.
==Specification==
TACC uses Tape and Accumulator to store values. Cell indexes start with 1. CP is cell pointer.
 :X - set CP to X
 > - set CP to accumulator
 < - set accumulator to cell pointed by CP
 ^ - set cell pointed by CP to accumulator
 +X - increment accumulator by X
 -X - decrement accumulator by X if result was negative set cell to 0
 !X - skip next command if accumulator is not X
 " - output accumulator as ASCII character
 ; - set accumulator to ASCII value of input
 [X - declare label X
 ]X - goto label X
==Examples==
===Cat===
 [a
 ;
 "
 ]a
===Truth-Machine===
This program's compass embraces a truth-machine:
 ;
 [print
 "
 !49
 ]print
===ASCII Characters Printer===
Deploy this program in order to print all ASCII character by ascending order of their codes:
 [repeat
 "
 +1
 !256
 ]terminate
 ]repeat
 [terminate
===Hello, World!===
This program harnesses the communicative warklumes betwixt the tape and the accumulator in order to print the message “Hello, World!”:
 :1 +72 ^
 :2 +29 ^
 :3 +7 ^
 :4 ^
 :5 +3 ^
 :6 -67 ^
 :7 -12 ^
 :8 +55 ^
 :9 +24 ^
 :10 +3 ^
 :11 -6 ^
 :12 -8 ^
 :13 -67 ^
 -32
 :14
 ^
 [repeat
 >
 <
 "
 :14
 <
 +1
 ^
 !14
 ]end
 ]repeat
 [end
===brainfuck interpreter===
Program and input are seprated by !
+3
^
[input
:1
<
+1
>
;
^
!33
]endinp
]input
[endinp
:1
<
+2
:2
^
:1
[dectozero
<
-1
^
!0
]set3
]dectozero
[set3
+3
^
>
[interpret
:1
<
+1
^
>
!43
]+
!45
]-
!44
],
!46
].
!60
]<
!62
]>
!91
][
!93
][
]interpret
[+
:2
<
>
<
+1
^
]interpret
[-
:2
<
>
<
-1
^
]interpret
[>
:2
<
-1
^
]interpret
[<
:2
<
-1
^
]interpret
[,
:2
<
>
;
^
]interpret
[.
:2
<
>
<
"
^
]interpret
[[
:2
<
>
<
!0
]find]
]interpret
[find]
:1
<
+1
^
>
<
!91
][inc
!93
][dec
]find]
[[inc
:3
<
+1
^
]find]
[[dec
:3
<
!0
]interpret
-1
^
]find]
[]
:2
<
>
<
!0
]interpret
[find[
:1
<
-1
^
>
<
!91
]]inc
!93
]]dec
]find[
[]inc
:3
<
+1
^
]find[
[]dec
:3
<
!0
]interpret
-1
^
]find[
==Interpreter==
* Common Lisp implementation of the TACC programming language.
Category:Languages Category:Turing complete Category:Cell-based Category:2023 Category:Implemented
TAbrain

TAbrain is a brainfuck derivative made by User:Tommyaweosme
== Commands ==
 + increment
 - decrement
 > move right
 < move left
 [ go to ] if 0
 ] go to [ if not 0
 {n{ go to } if current cell is n not
 } close {n{
 ( infinite loop
 ) close infinite loop
 | acts as an else for the {n{} loop
 , input
 . output
 / output as number
 ; clear cell
 $ terminate program (can be skipped over with loops)
 * multiply cell by next cell
 " put next character in program in current cell (even if its a prexisting command, even if its a quotation mark itself)
 # integerize current value
 @ asciize current value
 (any other character else) put in current cell
=== If/else ===
If/else is really simple. If current cell is n, then do c, else do d:
{n{c|d}
=== Numbers inline ===
If you want to set current cell to 124, you would do this:
 #124
Instead of this:
 124
Because if you did that, or @124, it gets saved as ASCII values overriding eachother until 4.
== Hello world ==
 h.e.l..o.w.o.r.l.d
== Kiwiscript ==
 k.i.w.i.
== Truth machine ==
=== Design 1 ===
 +>,[</>]/
=== Design 2 ===
 ,{1{(/)|/$}
== A+B problem ==
 ,>,[<+>-]
== Deadfish ==
 (,{105{>+<}{100{>-<}{115{>>++<*<}>{256{[-]}<{111{>/<})
== Notes ==
* Although this program has a terminate command, this still makes it turing-complete due to 1. just don't use it, and 2. there are ways to skip it with loops.
TBTBFS

TBTBFS is an esolang created by Brain Boy 53 (talk) 15:16, 24 May 2024 (UTC). It stands for TMMLPTEALPAITAFNFAL but trivial brainf**k substitutions. 
 Table of Commands
Command	Use
+ 	Add 1 to the current cell's value
- 	Subtracts 1 from the current cell's value
< 	Moves the cell pointer to the left
> 	Moves the cell pointer to the right
. 	Out puts the current cells value as an ASCII character
, 	Gets input from the user as an ASCII character and stores its value in the current cell.
[ 	Nothing
] 	If the current cell's value is not 0, go to the corresponding [
==See also==
* Newbiefuck
Category:Languages Category:2024 Category:Brainfuck derivatives Category:Cell-based Category:Low-level Category:Turing complete Category:Turing tarpits Category:Implemented
TC

This is TC in small bytes, data places have only two cells
 Commands
CM	DESC 	EX 	ID
* 	flips the bit here 	**** 	0000
/ 	flips the data pointer 	*/*/ 	0001
# 	enter this cell and make another data place in it 	*/#*/#/#/#/*/# 	010
@ 	exit this cell 	*/#*@ 	0011
! 	run one of these commands in binary using the cells in the data place 	/#/#@@! (runs *) 	100
? 	inputs one bit 	?* 	0101
. 	outputs one bit 	?. 	0110
$ 	run the whole code 	?.$ 	0111
% 	place the whole code but only until the nth commmand using the binary thing, but if no binary thing after, just do the whole code at this bit	%. (quine) 	1000
^ 	run the code here 	%^ (infinite loop)	1001
Category:Languages Category:Cell-based
TCC

"TCC" stands for "Table Changing Code". It was inspired by SQL and was invented by User:A.
==Syntax==
It has a simple syntax. All of its commands are not case-sensitive.
===CREATE===
This command is used for creating a table.
Syntax:
 CREATE table_name
===IN===
This command is used for choosing columns of a table and print it.
Syntax:
 IN table_name CHOOSE column_number
TCC will print the column.
===INSERT===
This command is used for inserting data into a table.
Syntax:
 INSERT table_name VALUES (value1, value2, value3, ...)
===DELETE===
Delete a row.
Syntax:
 DELETE table_name WHERE row_number
===Grammar===
An Extended Backus-Naur Form (ENBF) description shall elucidate the program structure:
 program := optSpaces
 , [ command , { spaces , command } ]
 , optSpaces
 ;
 
 command := create | in | insert | delete ;
 create := "CREATE" , spaces , tableName ;
 in := "IN" , spaces , tableName , spaces
 , "CHOOSE" , spaces , index ;
 insert := "INSERT" , spaces , tableName , spaces
 , "VALUES" , spaces , cellValueList
 ;
 delete := "DELETE" , spaces , tableName , spaces
 , "WHERE" , spaces , index
 ;
 
 tableName := letter , { letter | digit | "_" } ;
 index := digit , { digit } ;
 cellValueList := "(" , optSpaces
 , [ cellValue , cellValueRest ]
 , optSpaces , ")"
 ;
 cellValueRest := { optSpaces , "," , optSpaces , cellValue } ;
 cellValue := integer | string ;
 string := quote , { character - quote } , quote ;
 quote := '"' ;
 integer := [ "+" | "-" ] , digit , { digit } ;
 digit := "0" | "1" | "2" | "3" | "4"
 | "5" | "6" | "7" | "8" | "9"
 ;
 optSpaces := { space } ;
 spaces := space , { space } ;
 space := " " | "\t " ;
==Examples==
===Hello, World!===
This program prints the message “Hello, World!” employing a single column:
 CREATE hello_world
 INSERT hello_world VALUES ("H")
 INSERT hello_world VALUES ("e")
 INSERT hello_world VALUES ("l")
 INSERT hello_world VALUES ("l")
 INSERT hello_world VALUES ("o")
 INSERT hello_world VALUES (",")
 INSERT hello_world VALUES (" ")
 INSERT hello_world VALUES ("W")
 INSERT hello_world VALUES ("o")
 INSERT hello_world VALUES ("r")
 INSERT hello_world VALUES ("l")
 INSERT hello_world VALUES ("d")
 INSERT hello_world VALUES ("!")
 IN hello_world CHOOSE 1
This second variant utilizes two columns — one embracing the moeity “Hello, ”, the other the part “World!” — in its pursuit to display “Hello, World!”: 
 CREATE hello_world
 INSERT hello_world VALUES ("H", "W")
 INSERT hello_world VALUES ("e", "o")
 INSERT hello_world VALUES ("l", "r")
 INSERT hello_world VALUES ("l", "l")
 INSERT hello_world VALUES ("o", "d")
 INSERT hello_world VALUES (",", "!")
 INSERT hello_world VALUES (" ")
 IN hello_world CHOOSE 1
 IN hello_world CHOOSE 2
==Interpreter==
* Common Lisp implementation of the TCC programming language.
Category:Languages
Category:Output only
Category:Implemented
TDML

TDML (Two Dimensional Minimalistic Language) is an Turning tarpit by User:ChuckEsoteric08 inspired by 2L and 1L. It also is a languge where many commands can function differently in various implementations
==Specification==
TDML is a cell-based two-dimensional language with has four commands: +, *, ? and NOP, which can be represented as any other character. The tape is binary and infinite in both sides
===+===
This is command changes the directiion of Instruction Pointer clockwise. For example (arrows represent direction):
 >>+
 ^ v
 ^ v
 +<<+
===* and NOP===
This two commands operate on instruction wheel which looks like this (where > represents current command, which is flip by default, although it can be other command depending on implementation (and in some the order of commands is different, some even deleting in and out entirely, with this one being official one)
 > flip
 right
 left
 in
 out
Each time a NOP is met instruction is changed to the next one on a wheel. When * is met the instruction is executed. flip would flip the cell under the cell pointer, right would move cell pointer right, and left would move it left, in would store next byte input of input as a binary value, with first bit in the current cell, and the other 7 in the next 7 cells to the right (or to the left, depending on implementation). out would output bit in the current cell followed by the next 7 cells to the right (or to the left, depending on implementation). I/O instruction can instead function on 8 cells to the right or to the left in some implementations
===?===
This command is a conditional instruction, which would skip the instruction in the same direction if the cell is 0
==Variations==
Note that this varuations can be combined together, called TDML-RMe, TDML-R-Mi, TDML-RMeMi and TDML-MeMi
===TDML-R===
R stands for "Restart", in which after executing * the wheel restarts to the same position it started on
===TDML-Me===
Me stands for "Merged", in this one command ? becomes skip on instruction wheel, with this being official order:
 > flip
 right
 left
 skip
 in
 out
===TDML-Mi===
Mi stands for "Minimised" in which flip is merged with either right or left, with the instruction to which is merged to and whether it would flip the cell after or before moving the cell pointer depends on implementation, with none being official
==Computational class==
The language and all of it variations are Turing-complete, however it is very difficult to program in them.
Category:Languages Category:Two-dimensional languages Category:Turing complete Category:Turing tarpits Category:Turning tarpits Category:Unimplemented
TECO

:
TECO is a 1963 language created for use in the text editor of the same name, designed for performing arbitrary edits to text. Due to limitations regarding the paper-tape that TECO programs were originally stored on when they were fed into computers, TECO syntax is terse and illegible. Almost every possible character is a command. TECO programs were used to perform replacements in program source code in order to correct mistakes, based on context rather than line numbers. Surprisingly, this was often more efficient than the alternatives available in its heyday. Programs were often written with exact specific input text in mind, and given their incomprehensible syntax it was joked that TECO enabled "Write-only Programming". In other words, TECO programs can be written, but afterwards cannot be read or understood.
TECO follows the imperative paradigm, with subprocedures being stored as text in variables.
The text editor TECO was the predecessor to Emacs, which used TECO internally before the adoption of Emacs Lisp; 'EMACS' refers to extensible TECO macros that originally comprised it.
Category:LanguagesCategory:Before 1993Category:Turing completeCategory:Implemented