This page focuses on simplicity—one of the key attributes of TOO that makes it viable for citizens.
Always remember, however, that there’s usually a simpler and better way to do something than the first way that pops into your head.
Donald Knuth Tweet
A typical general-purpose programming language (GPL) comprises around 150 syntax rules, 30 operators, and 40 keywords. In contrast, TOO is minimalistic relative to a common GPL. TOO is simplified to the bare minimum. TOO aims to be the world’s smallest practical GPL, with 0 keywords, 5 operators, and 9 syntax rules. In comparison, Go, which is a fairly small language, has 25 keywords, 34 operators, and about 100 syntax rules. This facilitates rapid acquisition of the language and rapid development. Refer to the following table for a comparison.
Language | Keywords | Operators | Syntax rules | Year |
---|---|---|---|---|
Fortran | 39 | 16 | 170 | 1957 |
C | 32 | 27 | 100 | 1970 |
C++ | 90 | 35 | 200 | 1979 |
Python | 33 | 39 | 90 | 1991 |
Java | 51 | 34 | 250 | 1995 |
Ruby | 13 | 28 | 60 | 1995 |
C# | 78 | 41 | 220 | 2000 |
Go | 25 | 34 | 100 | 2009 |
Typescript | 50 | 35 | 150 | 2012 |
Rust | 35 | 45 | 250 | 2015 |
TOO | 0 | 5 | 9 | 2022 |
TOO 9 syntax rules
A carefully designed language with just 9 syntax rules can be remarkably powerful.
thing ::= Id “{” {decl|event|when|func}* “}”
event ::= Id params
when ::= {Idsrc [“[” decl “]”]}+ Idsignal params “{” {act}* “}”
func ::= Id paramsin “→” paramsout [“{” {act}* “}”]body
act ::= [“*”]iter expr [“?” “{” {actT}* “}” [“{” {actF}* “}”]]
expr ::= ((Const|Id|call) [“[” (expr|“*”) “]”]index [“→” (decl|params)]redirect)+
call ::= Id “(” [{expr|“*”}*“,”]args “)”
params ::= “(” [{decl}+“,” […]variadic “)”
decl ::= [“[]”]array [Idalias “:”] {Id}+ [“=” Const] [Constimport]
TOO 5 operators
It is assumed that citizens are familiar with spreadsheets and this reassures the use of functions (e.g., AND(x,y), IF(x,y,z)) together with fluent style chaining that is natural for citizens, refraining completely from infix binary operators that might be difficult to remember (e.g., “<<=”), solving precedence of operations and simplifying readability.
→ Redirect
[ ] Subscript
? Decision point
* Wildcard and iteration
= Initial value for thing in declaration
Expert systems especially, and rule-based systems in general, present a simplified approach to flow control that is human-friendly and easy to master. In such systems, the logic is structured in rules with a trigger and a list of sequential actions.
While most GPLs advocate loops that considerably increase citizen incomprehension, TOO provides many ways to create an iterative logic but it is loop-free. The algorithms in TOO may only contain downstream branching. This means that rule actions (or function actions) are executed in a sequential order and there is no way to go back and re-execute an action that was already executed. This is illustrated in the flowchart below.
TOO flowcharts feature only downstream branching. Action details are shown on hover.
Editing a TOO program requires only a mouse:
(a) The data structure is created by point and click – moving instances from the INVENTORY to the MEMBERS section.
(b) The flowchart skeleton is created by dragging and dropping a box over an edge, and there are only two types of boxes to choose from: rectangle and diamond.
(c) Editing a flowchart box only requires selection from a dropdown menu with fairly limited alternatives and only at specific points where the expression can grow or shrink. In the example below, there are two edit points marked by the blue “+” symbols.
Editing a flowchart box is limited to specific points.
Example 1: Redirect Operator (→)
radius squared times math π → area times height → cylinder
Explanation:
The redirect operator (→) is used to assign the byproduct(s) of a sub-expression to a temporary variable(s). These temporary variables can be used later in the code, allowing for clear and concise expressions. The expression is intuitive, close to a spoken language, and can be read as: “radius squared times pi goes to area, times height goes to cylinder”.
Example 2: Spawning lightweight threads
go run(fixtures, schedule[*], *)
Explanation:
The star operator (*) acts as a wildcard, effectively creating a loop that iterates over the array elements. The “go run” function spawns a lightweight thread for each element in the array, with each thread handling one schedule.
Example 3: Loop within a loop
* fixtures control(schedule split(“,”)[*], name)
Explanation:
Effectively, in this single action we have a loop within a loop.
Simplicity is the ultimate sophistication. It takes a lot of hard work to make something simple, to truly understand the underlying challenges and come up with elegant solutions. [...] It's not just minimalism or the absence of clutter. It involves digging through the depth of complexity. To be truly simple, you have to go really deep. [...] You have to deeply understand the essence of a product in order to be able to get rid of the parts that are not essential.
Steve Jobs Tweet
.