Jonathan Aldrich

(n-s: the source of my attempted analog : https://www.cs.cmu.edu/~aldrich/courses/15-819O-13sp/resources/dataflo… A concise few pages worth drowning in! (For me)) (p-s: 2 "repulsive fixed-points" of 2 messianics of interest: PG: the anti-prig Thiel: the protocolizer as chief optimist/protocolization creditor/secretary of the politburo ) (p-p-s, from the comments: Henry VIII as designer of new kinds of windmills, would have been awesome snack if that checks out, roughly on par with Lawrence of A coming up with a new jet engine)

Maybe not everyone will know this but Typestate was one of the original 'headline features' of Rust when Graydon Hoare started it. It was based on the Strom/Yemeni paper[0] for the NIL language. There's a mention of in this SO answer from 2010[1] and in the LtU discussion[2]. I'm not sure why it was de-emphasised, I think it didn't work as well as anticipated in the 'real world' [0]: http://www.cs.cmu.edu/~aldrich/papers/classic/tse12-typestate.pdf [1]: https://stackoverflow.com/questions/3210025/what-is-typestate [2]: http://lambda-the-ultimate.org/node/4009

I don't know of any discussion forums, but would recommend the following resources for learning: Accessible (at least compared to more formal texts) lecture notes: http://www.cs.cmu.edu/~aldrich/courses/17-355-18sp/ Free book that's more readable than "Principles of Program Analysis" by Nielson et al: https://cs.au.dk/~amoeller/spa/ Some practical resources for binary PA: https://reversing.io/resources/

The Rust language (by Mozilla) is putting statically verifiable state machines in the type system: http://lambda-the-ultimate.org/node/4009 It's based on Typestate, a really good 1986 paper: http://www.cs.cmu.edu/~aldrich/papers/classic/tse12-typestate.pdf I hope this idea catches on in other programming languages.

Since Rust implements a typestate system, here is a link to the classic 1986 paper by Strom and Yemini which introduces the concept of typestate: http://www.cs.cmu.edu/~aldrich/papers/classic/tse12-typestate.pdf LtU has a thread on Rust: http://lambda-the-ultimate.org/node/4009

I agree, TypeState seems especially interesting. This paper from one of the comments does a good job describing it: http://www.cs.cmu.edu/~aldrich/papers/classic/tse12-typestate.pdf

I don't usually respond to old comments, so I don't know if you'll read this, but I hope I can encourage you to think more broadly about what "differentiable programming" means. Different fields have a different perspective on the same set of tools because those tools have different pathological cases in different areas. Context really matters. > Well, that was my point above: You can't really lump quantum programming together with probabilistic programming, as they are paradigms on different "levels" This distinction is not useful. If I write in a functional or logic programming language, it gets translated into imperative commands for an underlying architecture that is some mix of dataflow, event driven, automata-based, concurrent, etc... that is then further built on top of some physical atoms where an engineer worried about quantum effects. If I write in a quantum programming language, it will probably go through the same process for at least another 5 years. You might argue that quantum is somehow more dictated by the underlying physical model the way that people argue that imperative programming is closer to the physical world than functional programming. But the "level" doesn't change the usefulness of viewing all of these as "paradigms" worthy of study and analysis on their own terms with their own tools. At the level of studying a programming language, the "level" is a useful thing to be aware of for implementations and motivation but usually not for a…

Well, in terms of whether the example is a well-posed question, a networked window system isn't too different from the WWW, which as we know by now works pretty flawlessly. Perhaps the key contrast here is between the tendency toward static mathematical perfection of the APL family and the notion of dynamic languages for building systems that Alan Kay et al would propose. "APL is like a beautiful diamond - flawless, beautifully symmetrical. But you can’t add anything to it. If you try to glue on another diamond, you don’t get a bigger diamond." --Joel Moses There's a talk by Ian Piumarta that tries to get to the core of what the VPRI guys feel is important. I'm not sure about it but it seems worth mentioning in this context: Ian Piumarta "Building Your Own Dynamic Language" http://www.youtube.com/watch?v=cn7kTPbW6QQ Also, this: https://www.cs.cmu.edu/~aldrich/papers/objects-essay.pdf

Also: 2003 Traits: Composable Units of Behaviour https://www.cs.cmu.edu/~aldrich/courses/819/Scha03aTraits.pdf " Traits as described in this paper are implemented in Squeak [22], an open-source dialect of Smalltalk-80."

> I've noticed many large C projects resort to these sorts of OOP-like patterns to manage the complexity of the design and size of the code base The Power of Interoperability: Why Objects Are Inevitable https://www.cs.cmu.edu/~aldrich/papers/objects-essay.pdf

> For example if a function needs to take a record containing x as a field with type int, it should also accept a record with y as a field that it does not use. Not sure if I misunderstand what you mean, but this does not require subtyping. One of the key distinguishing features of row polymorphism is that exactly this can be achieved without subtyping. The extra unused fields (`y` in your example) are represented as a polymorphic type variable _instead_ of using subtyping. See for instance page 7 in these slides: https://www.cs.cmu.edu/~aldrich/courses/819/slides/rows.pdf

A fun excerpt from "Capabilities: Effects for Free" Capability-safe languages prohibit the ambient authority [18] that is present in noncapability-safe languages. An implementation of a logger in Java, for example, does not need to be initialised with a log file capability, as it can simply import the appropriate file-access library and open the log file for appending by itself. But critically, a malicious implementation could also delete the log, read from another file, or exfiltrate logging information over the network. Other mechanisms such as sandboxing can be used to limit the damage of such malicious components, but recent work has found that Java’s sandbox (for instance) is difficult to use and therefore often misused [2, 12]. Emphasis added my own. [1] https://www.cs.cmu.edu/~aldrich/papers/effects-icfem2018.pdf

More about this can be found in the literature on using capabilities to provide/implement effect systems. For example: - "Capabilities: Effects for Free": https://www.cs.cmu.edu/~aldrich/papers/effects-icfem2018.pdf - "Effects as Capabilities: Effect Handlers and Lightweight Effect Polymorphism" https://dl.acm.org/doi/pdf/10.1145/3428194 I think this is a quite effective approach and I hope it is used more. In some sense it's just good coding style, which lets you do effect-system-style reasoning in any language.

The thing you are referring to with open and closed files is called typestate. Check out its implementation in the Plaid programming language: http://www.cs.cmu.edu/~aldrich/papers/onward2009-state.pdf

This is one of the projects out of Jonathan Aldrich's (http://www.cs.cmu.edu/~aldrich/) group at CMU ... "The Penrose team is based at Carnegie Mellon University, comprising Katherine Ye, Nimo Ni, Dor Ma'ayan, Max Krieger, Rain Du, Josh Sunshine, Jonathan Aldrich, and Keenan Crane. (Emeritus: Jenna Wise and Lily Shellhammer.)" http://www.penrose.ink

Even Datalog can be extremely useful: http://www.cs.cmu.edu/~aldrich/courses/654/tools/bierhoff-bddbddb-05.p… Also take a look at this, quite a convincing example of how useful Prolog can be in a compiler pipeline: https://pdfs.semanticscholar.org/3667/96ef0c3e9a8b4acb70f838873e4933cd…

Personally I'd rather see this class of problem solved at the language level [0] through strong typing of DSLs, rather than at the editor level. Nonetheless this is still an interesting approach. [0] http://www.cs.cmu.edu/~aldrich/wyvern/

html version http://webcache.googleusercontent.com/search?q=cache%3Ahttp%3A%2F%2Fww… I'd almost forgotten this trick, just google cache:http://www.cs.cmu.edu/~aldrich/papers/objects-essay.pdf request: could HN do this automatically pls? (similar to how it used to provide a second link to scribd for pdf) I always prefer a html version, to assess it. If it's interesting, and diagrams/formulae are garbled, I can always get the pdf later.

Just because something is complex doesn't mean it is bad, but something being really really complex (or feature rich), doesn't mean it is good either. Now I might be mistaken, but Scala is one of rare languages that actually has compiler commands that disable parts of it syntax (or there was a plan to do so). To me that yells - Too complex. I'm quite sure it is powerful. But it doesn't look like something I'd enjoy using. My main gripes about Scala is that the trait system is way less elegant than the Smalltalk variant [1], there seems to be a hundred different ways to do a thing (as opposed to a more unified way of doing things) and the overall "automagical" implicit. Not to mention the overall verbosity and ways the different features mesh together. [1]http://www.cs.cmu.edu/~aldrich/courses/819/Scha03aTraits.pdf