brandonbloom

9 tháng trướcdiscuss

If you watched the video closely, you'll have noticed that this design parameterizes the code by an `io` interface, which enables pluggable implementations. Correctly written code in this style can work transparently with evented or threaded runtimes.

brandonbloom

2 năm trướcdiscuss

There is a huge spectrum from no proposal at all to a magic bullet on a silver platter. To some extent, the default and implicit proposal is: "You should something about it!". Which is markedly worse than "_We_ should do something about it.", and worse still than "Let's do something about it, here's how I can help..."

Some other useful intermediate proposals include:

- "Allow me and my team time to investigate a solution."

- "I've organized my complaints into requirements for a solution. Please identify an expert to solve the problem."

- "I've socialized these problems with ${people}, I recommend you speak to ${person} about ${topic} for next steps."

Having said that, I agree that complaints can be counted as "votes" for which problems to solve in the future. The problem is that they are not one complaint = one vote. At the very least, the complainer's role and responsibilities need to be accounted for within the scope of the larger organizational goals.

brandonbloom

2 năm trướcdiscuss

> that still needs A to talk to D

That should not be the case with promise pipelining. The "Mobile Almost-Code" section of the E page explains this. You mentioned "continuation passing style", which is effectively what promise pipelining does: For the constrained class of continuations that can be serialized as a dataflow graph, pass those along with the message.

Importantly, the system wide constraint is willing participation from each actor, not a shared database. Instead of each actor needing to know how to interact with the shared database, each actor needs to be willing and able to execute these passed continuations.

brandonbloom

2 năm trướcdiscuss

The request/response optimization discussed in the first half of this post has been explored quite a bit in the context of Object-Oriented Programming and Actors, where the desired feature is called "Promise Pipelining":

http://www.erights.org/elib/distrib/pipeline.html

Outside of the E programming language and in the realm of language-agnostic tooling, you can find promise pipelining in some RPC frameworks, such as Cap'n Proto:

https://capnproto.org/rpc.html

Generally, this work comes from the Object-Capabilities community.

brandonbloom

2 năm trướcdiscuss

Nice! Looks like most modern list-comprehension syntaxes.

> iteration and value accumulation are orthogonal problems which should be solved by orthogonal constructs

This is also covered to an extent by "Why Functional Programming Matters" in the discussion of laziness: https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.p...

For a direct comparison of combining this syntax with "accumulation" into a lazy sequence, see Clojure's `for` macro:

https://clojuredocs.org/clojure.core/for

brandonbloom

4 năm trướcdiscuss

> Internet doesn't help.

Just ask anyone who has moved to Seattle, but has conservative family back in their home state. Folks believe we live in an anarchist hellscape. Myself and several friends have had the experience of being called liars by family members who trust Fox News over the word of their blood relatives. It's absolutely maddening.

brandonbloom

13 năm trướcdiscuss

Clojure has provided an excellent model for how to do similar operations in a dynamically typed language with pervasive maps & vectors:

    (update-in player1 [:location :x] + 10)

This works especially nicely with the threading macros. Here's some random example I'll make up:

    (-> player1
        (update-in [:location :x] + 10)
        (assoc-in [:inventory 3 :equipped] true))

The general idea is that a tree of associative data structures (which include integer-indexed vectors) can have a path to a location in the tree reified as normal data. Then, you can run any ordinary function on a deep position in the tree without any of the applicative functors machinery.

brandonbloom

Submissions

Brex tests agents: by committing fraud

comments