Great concept but I found their execution lackluster. The studio (IDE) is an Atom-based editor that is horribly slow and very buggy. I'm still waiting for a cleaner, smoother implementation. Honestly, if they were reinventing the GUI, might as well be an extension for VS Code.
VS Code is not universally extensible. Atom is.
Extensions in VS Code have a lot more limitations. This is also in part because VS Code was designed to be more performant than Atom.
there is dataflow with some level of control flow (boolean conditions, boolean loops, and event-driven conditions) in https://ossia.io - it's tailored to artistic uses however :-)
This looks seriously cool and partly resembles how I think computation should be in that it is a series of steps that meat together in a data pipeline.
In this linked document for Magritte, it describes its pipeline operator in a section called "Syntax Design - Linear Composition: Why Not Lisp?".
..The problem is the prefix-only calling convention that requires a back-and-forth movement of the cursor, and causes the expression to expand leftwards, opposite of the direction of the user’s typing.
While some languages have some support for linear composition using operators such as Clojure’s arrow macros or OCaml’s |> operator, the integration of these macros with the underlying subsystem is shallow.
I question this last statement.
Just this weekend I was reading about Hy's (based on Clojure's) threading macros:
"Threading macros, also known as arrow macros, convert nested function calls into a linear flow of function calls"
-> (or the threading macro) is used to avoid nesting of expressions. The threading macro inserts each expression into the next expression’s first argument place.
->> (or the threading tail macro) is similar to the threading macro, but instead of inserting each expression into the next expression’s first argument, it appends it as the last argument.
At least to me this seems far from "shallow" and even more useful/flexible than the pipeline operator.
I've always used many languages, but I tried clojure for data processing stuff. I moved away from it because the number of libraries was tiny; I had to write my own libraries for doing basic SQLy things. Some hard things were easy in Clojure, but too many easy things were hard.
Thanks! That was interesting to hear about your experience with Clojure. I've heard good things about the language, reading here and there about its features and strengths - so I was curious to know if there were any critiques/cons (pun intended :).
1.4 The Desktop-Scripting Problem
Related to the shell-language design problem is the desktop-scripting problem:
How should unrelated programs written in different languages be integrated—especially
in an ad-hoc manner in a desktop environment? Such a task can require a large
amount of glue code, written by users who are unfamiliar with the inner workings of
the programs they are using. Notable attempts at solving the desktop-scripting prob-
lem include the TCL language [Ousterhout, 1989] and Guile Scheme [Blandy, 1998].
However, while most of these approaches use a large, robust language, it still remains
difficult to integrate them with external programs—instead putting the burden on
those programs to integrate with their system. We believe a shell-based approach is
promising
Hmm, Scheme as a large language? Well, I don't know much about the extensions Guile Scheme has over RxRS, would hope for someone to add info here.
This is only a partial answer, but I remember the designers of Julia saying that the Scheme spec spends many dozens of pages on the semantics of integers and floats. That makes the language large.
Remember that Scheme is not the lambda calculus -- you need dynamic types like integers, strings, vectors, hash tables, IO, etc. to get anything done.
In contrast in Julia they said that the semantics of numbers are defined in Julia. Julia has a much richer notion of number than any other language AFAICT, e.g. int8 .. int128, uint8 .. uint128, vectors of those, matrices of those, rationals, etc. They're all on the "same level" -- there aren't primitives vs. libraries, as far as I know.
It is mind boggling that despite the name, they did not (given the (I assume) joke with the name) say, "Ceci n'est pas une pipe" anywhere in the paper. Only once does the phrase, "This is not" occur, but completely out of context of Magritte's most famous painting.
I'm serious - this isn't Joke 101, but this is Marketing 101 in some respects.
I assume they felt it was a bit too on the nose? Anyone familiar with Magritte will be familiar with the painting; any attempts to shoehorn the quote in there would have felt forced, I think. Maybe if they had a website to go with it... but this is just a paper.
Plus, as jpfed says below: The twist here is that this language doesn't use actual pipes; it just creates representations of pipes that can be used by a different interpreter.
I wrote clojure for a while. Forward chaining basically facilitates pipe based programming. When it fits it’s great, but when it doesn’t try code is ugly.
Some computations just want to be imperative. IMO, if you can avoid developing programming fetishes; power to you.
Reminds me of nushell, which pipes around 2D tables (which can instead store hierarchical structured data, for example when reading toml files): https://news.ycombinator.com/item?id=20783006
Except for the comparisons with Lisp in the third section, I thought the idea of pipes with complex data structures to be a pretty neat idea. Also, this is for a Master’S Thesis from the University of Tokyo? That looks like a lot of work for a MS thesis.
The problem as it's defined in this thesis sounds a lot like the problem of microservice architecture. I'm curious how something like protobufs would compare in solving this problem
