New Computer Language

New Computer Language 

We as programmers could have a new computer language.

No heap. No pointers. So deterministic.

Bounded while statements. Bounded loops. Active models. Go back to record structure (or plex). Extremely high if you have that.

build for GPU vs. CPU are 2 completely different ways.

CPUs are optimized for path finding and just preloading data.

GPU is very deterministic - allocate a piece of memory, fill it, run some functions on it.

  no heap or allocation.

Single Instruction, Multiple Data (SIMD) 

  

Do not do dynamic allocations anymore

Discriminated unions - Rust

Borrow checker - heap - don't use

Imagine with no borrow checker. Start index. Now only have offsets for all of 

  the fields in your record.

Hard Real-Time and Embedded Languages: MISRA C / SPARK Ada. Lustre synchronous programming language and Esterel.

* No Recursion: The call stack depth must be completely predictable at compile time.

* Fixed-Size Collections: Arrays cannot grow dynamically; their maximum boundaries must be hardcoded.

* No Closures: Functions cannot dynamically capture variables from surrounding scopes in a way that requires lifetime extensions on a heap.

* Static Memory Allocation

* no garbage collection

* Impossibility of Memory Leaks

* Without a heap, all software variables are stored directly on the call stack.

Time Determinism (Execution Speed)

* No Garbage Collection Pauses

* No Allocation Overhead

* Predictable Cache Performance

Memory Size Determinism (Memory Footprint)

* No Out-of-Memory Crashes

Data Determinism (Data Layout)

Still non-deterministic due to three external factors:

1) External Hardware and Inputs such as sensors and I/O and hardware clock

2) Concurrency and Concurrency Race Conditions

3) Undefined Behavior (Compiler Language Rules)

    If the language is poorly designed or permits uninitialized variables.

Not used by Large AI:

* No On-the-Fly Learning: You cannot easily perform backpropagation (training) in Lustre because updating millions of weights typically requires flexible matrix manipulation and dynamic memory allocation.

* Size Explosions: LLMs with billions of parameters would run out of memory or 

create a binary file too massive to ever fit onto a chip.