FORTRAN —"the infantile disorder"—, by now nearly 20 years old, is hopelessly inadequate for whatever computer application you have in mind today: it is now too clumsy, too risky, and too expensive to use.

He told the truth and in turn Fortran corrected its course, but Dijkstra probably didn't change his mind about it.

---

> These pioneers, even when they disagreed, had pretty precise arguments and very rarely feeling the feelies.

The feud between Backus and Dijkstra kinda persuaded me of the opposite.

https://medium.com/@acidflask/this-guys-arrogance-takes-your...

Dijkstra was highly influential in theoretical (proofs, algos) and practical (spec&compiler for Algol60) compuper science. But in reality he used his fountain pen disproportionately more than the computer.

As he said, Java is a mess and any sensible person would oppose the switch from Haskell to Java. I am almost sure he never used any of them. Might have read about them, but highly doubt he run any on computer.

As for the high-level status of Haskell and APL — both languages are very mathematical. Haskell goes very into the abstract realm of computation, while APL tackles very raw form of computation. Semantically, Haskell is way more high-level. In terms of economy of notation and unified concepts, APL has no match.

What I would like to know is how he would bend Algol 60 if he had tablet with pencil that could evaluate it in real-time.

Kinda hard to find where Dijkstra praised something (except Algol 60).

One funny example: he called FORTRAN "an infantile disorder", though he said this about the team behind it: "At that time this was a project of great temerity and the people responsible for it deserve our great admiration.".

On LISP: "LISP has jokingly been described as 'the most intelligent way to misuse a computer'. I think that description is a great compliment because it transmits the full flavor of liberation: it has assisted a number of our most gifted fellow humans in thinking previously impossible thoughts."

Alan Kay on Dijkstra: "Arrogance in computer science is measured in nano-dijkstras."

FORTRAN — "an infantile disorder"

COBOL — "the use of COBOL cripples the mind"

BASIC — students exposed to it are "mentally mutilated beyond hope of regeneration"

PL/I — "the fatal disease"

APL — "a mistake, carried through to perfection"

He liked his languages and programs to be easily traceable with pen & paper. He always wrote programs on the paper (and proved correctness) and only then into computer. REPL-driven development (what APL pioneered) was a foreign concept to him. He would be so appalled by LLM code generation.

Monadic/dyadic case for single glyph works nice only when you have a default value associated with it. For example `√16` is actually `2√16`. Or `log 100` is `10 log 100`. And `-3` is `0-3`.

Last sentence is epic.

There are 5 parts so far:

1. https://mlajtos.mu/posts/new-kind-of-paper – overview of the concept

2. https://mlajtos.mu/posts/new-kind-of-paper-2 – intro to Fluent notation

3. https://mlajtos.mu/posts/new-kind-of-paper-3 – inspirational prior inventions

4. https://mlajtos.mu/posts/new-kind-of-paper-4 - how to think efficiently (including longer demo)

5. https://mlajtos.mu/posts/new-kind-of-paper-5 – review of Apple Math Notes and suggestions for improvements

Keyboard version of Fluent is available here: https://mlajtos.github.io/fluent/?code=RG9jdW1lbnRhdGlvbg

Fair. Thank you :)

https://github.com/mlajtos/fluent/blob/main/client.tsx

In 2021, I made a prototype calculator designed for iPad and Pencil and wrote four essays called "New Kind of Paper" describing this concept. The video demonstration of the prototype [Demo] sums up pretty well how it might be used.

In 2024, Apple released Math Notes, which implements this concept for standard math notation. My "review" of it is at [MathNotes]. In short, it is currently a preview of a damn great tool, but its future depends on notation and expressivity.

APL is a language from 2066, created in 1966. While its semantics make more sense now due to machine learning, syntactically it remains alien to most people. Backus' FP/FL and Iverson's J are more approachable to current programmers, but still not there. In New Kind of Paper, I created a tiny language called Fluent, which is nowhere near the ambition of any language mentioned, but it is intentionally designed to be handwritten. A week ago, I open-sourced it. [Fluent]

There is plenty of work left to do, but it is a good start.

[NKoP]: https://mlajtos.mu/posts/new-kind-of-paper

[MathNotes]: https://mlajtos.mu/posts/new-kind-of-paper-5

[Fluent]: https://news.ycombinator.com/item?id=46649223

[Demo]: https://youtu.be/y5Tpp_y2TBk

Thanks for coming to my TED talk.

I finally pushed myself to open-source Fluent, a differentiable array-oriented language I've been building for the New Kind of Paper project [1-5]. Demo is available at [0].

Few salient features:

1. Every operator is user-(re)definable. Don't like writing assignment with `:`, change it to whatever you like. Create new and whacky operators – experiment to the death with it.

2. Differentiability. Language is suitable for machine learning tasks using gradient descent.

3. Reactivity. Values can be reactive, so down-stream values are automatically recomputed as in spreadsheet.

4. Strict left-to-right order of operations. Evaluation and reading should be the same thing.

5. Words and glyphs are interchangeable. All are just names for something. Right?

6. (Pre,In,Post)-fix. You can choose style that suits you.

It has its own IDE with live evaluation and visualization of the values. The whole thing runs in browser (prefer Chrome), it definitely has ton of bugs, will crash your browser/computer/stock portfolio, so beware.

Some bait – linear regression (Ctrl+O, "linear-regression-compressed" or [6]):

    x: (0 :: 10),

    y: (x × 0.23 + 0.47),

    θ: ~([0, 0]),

    f: { x | x × (θ_0) + (θ_1) },

    L: { μ((y - f(x)) ^ 2) },

    minimize: adam(0.03),

    losses: $([]),

    (++): concat,

    { losses(losses() ++ [minimize(L)]), } ⟳ 400,

    (losses, θ)

    1 + 2,

    1 add 2,

    add(1,2),

    +(1,2),

    (1,2) . +,

    (1,2) apply add,

[0]: https://mlajtos.github.io/fluent/?code=RG9jdW1lbnRhdGlvbg

[1]: https://mlajtos.mu/posts/new-kind-of-paper

[2]: https://mlajtos.mu/posts/new-kind-of-paper-2

[3]: https://mlajtos.mu/posts/new-kind-of-paper-3

[4]: https://mlajtos.mu/posts/new-kind-of-paper-4

[5]: https://mlajtos.mu/posts/new-kind-of-paper-5

[6]: https://mlajtos.github.io/fluent/?code=eDogKDAgOjogMTApLAp5O...

Comments URL: https://news.ycombinator.com/item?id=46649223

Points: 3

# Comments: 0