[singlow]

real-time - being concerned with predictable latency rather than overall throughput

symbolic processing - symbolic expressions (s-expressions) being the building blocks of lisp programs

single processor - not considering multitasking or multiprocessor concerns

[whage]

I appreciate the clarification but what I didn't get is what "symbolic processing" has to do with "hard real-time" (who cares what the language looks like?) and similarly, how is "single processor" related to "hard real-time"

[martincmartin]

This terminology was common in the 1990s, before AI meant "machine learning" (aka adjusting parameters). Symbolic processing involves having an object in memory for things in the real world, and manipulating them. There's some vague relation to object oriented programming. The point is, it involves creating & destroying objects, memory allocation, that sort of thing. As opposed to purely numerical computing: for a neural net with a fixed architecture, there are a fixed number of operations (multiplying, adding) to get an answer. It's easy to do that in real time, since the computation is not only bounded, but of constant time. Symbolic manipulations can take variable amounts of time, and depend on the particulars of the inputs & problem being solved.

Lisp was championed by people in AI working on symbolic reasoning back in the 1990s.

[Jtsummers]

Symbolic reasoning based AI goes back to at least the 1950s. You're missing almost a half-century of history there.

[Jtsummers]

"A real-time symbolic processing system on a single processor should have the following four features"

The language they're developing in/for is Lisp, which is used (a lot) for symbolic processing. That's the "symbolic processing" part. "real-time" is the constraint they're trying to achieve and relates to system performance. "single processor" is just another constraint. If you permit multiple processors then some of the problems making Lisp real-time go away or are mitigated as you can do things like shove the GC bit into a second processor and execute it in parallel. Being constrained to a single processor means you can't do this, when the GC is going it's using the full CPU and taking time away from other computations (symbolic processing, in their case).

[kazinator]

> who cares what the language looks like

I would guess, the paper cares what the language looks like since it's about Lisp being real-time.

Lisp has been dubbed as a "symbolic processing language" since its early days, since MacCarthy used that language in some papers.*

Basically it means the ability to juggle complex data structures that can represent formulas; e.g. solving algebraic equations (something easily hacked up in Lisp) is an example of symbolic processing.

This is entirely relevant to the topic because the dynamic allocation used in symbolic processing presents challenges to real-time processing, like garbage collection pauses, and whatnot. What if you want asynchronous interrupts to be able to allocate cons cells and other objects?

In a Lisp program, memory-allocating expressions casually appear throughout a program. Something like (list a b c), if we translate it to C, would call a malloc-like routine three times. Some people doing some kinds of embedded work even today eschew dynamic allocation.

---

* Like: Recursive Functions of Symbolic Expressions and Their Computation by Machine. Memo 8, Artificial Intelligence Project, RLE and MIT Computation Center, March 13, 1959, 19 pages. https://dspace.mit.edu/handle/1721.1/6096

[lispm]

"symbolic processing" means computing with symbols, not numbers.

Like: (simplify '(2 * a + 4 * a)) -> (6 * a).

An application for symbolic processing could be a rule-based system. The application then consists of a lot of rules and facts. Facts also could be symbols, not just numbers. Like a physical pressure value could be a number, but it could also be a qualitative value like low-pressure.

A relatively old application (originating in the mid 80s) is real-time control with a rule-based system in technical systems. Technical systems could be a fleet of satellites, a chemical plant, a cement production plant, ...

The software might get sensor inputs and based on rules may cause physical actions like opening or closing a valve, while getting more live sensor inputs, then possibly triggering other rules.

Typically Lisp systems have some kind of GC and most of the time this will not allow real-time applications. There are are some specialized Lisp systems which have no GC and the application code is written in a way to not dynamically allocate memory during runtime - one says that the style is non-consing, where CONS is the basic operation to allocate a new list cell. This way they avoid garbage collections. This allows some real-time applications, like the mentioned rule-based process control software. This is rare and exotic stuff. It's also considered 'old AI' technology.

The paper describes also something exotic: a concurrent Garbage Collector for a Japanese Lisp Machine, which runs a Lisp operating system - that was a thing when Japan was investing a lot into Artificial Intelligence in the 'Fifth Generation Project'. Such a GC would be useful so that the machine's network stack could be written directly in Lisp, but also for applications (similar to above control of external physical systems): robots, machines, production plants, ... It was thought that an important application domain for expert systems could be in industrial control systems.

[Test0129]

To be clear for OP hard real-time means that missing a response guarantee constitutes a total system failure.